bug fixes with ssf and message queue and updated README

Author: dstpierre

README.md

@@ -40,71 +40,78 @@ over and over on the backend. If your application needs one or all of
 user management, database, file storage, real-time interactions, it should be 
 a good fit.
 
-I'm personally using it to build SaaS.
+I'm personally using it to build SaaS:
 
-## How it works / dev workflow
-
-The main idea is that StaticBackend is your backend API for your frontend apps.
-
-It needs to have access to MongoDB and Redis servers. Once you have your instance 
-running you create accounts for your applications.
+* [Tangara - one page checkout for creators](https://tangara.io)
 
-An account has its own database, file storage, etc.
-
-I think `app` might have been a better name instead of `account`. Naming things 
-is hard.
+## How it works / dev workflow
 
-A StaticBackend account(app) can have multiple user accounts and each user 
-accounts may have multiple users.
+The main idea is that StaticBackend is your backend API for your frontend apps. 
+A performant free and open-source Firebase alternative.
 
-From there each users can create database documents that are by default Read/Write 
-for the owner (the user) and Read for its parent account. You may customize 
-permission for each of your collection (see that later in the documentation).
+_Note that it can also be used from your backend code as well._
 
-You have the basic building blocks to create a typical web 
-application. You have all your CRUD and data query operations covered, file 
-storage and websocket-like capabilities.
+Once you have an instance running and your first app created, you may install 
+the JavaScript client-side library:
 
-We have a [JavaScript library](https://www.npmjs.com/package/@staticbackend/js) to 
-get started quickly. We have also server-side libraries for Node and Go atm.
+```shell
+$> npm install @staticbackend/js
+```
 
-Why would you need server-side libraries, was it not supposed to be a backend 
-for client-side applications.
+Let's create a user account and get a session `token` and create a `task` 
+document in the `tasks` collection:
 
-Yes, but, there's always a but. Sometimes your application will need to 
-perform tasks on behalf of users or public user that do not have access to 
-perform CRUD from the client-side.
+```javascript
+import { Backend } from "@staticbackend/js";
 
-Let's imagine we're building an invoicing app. Here's the major entities 
-we have for this examples:
+const bkn = new Backend("your_public-key", "dev");
 
-* A StaticBackend account (our app inside our SB instance)
-* An account with 2 users (this would be your customer)
-* An invoices collection (where your customer create invoice)
-* A clients collection (Your customer send invoice to their clients)
+let token = "";
 
-Now let's imagine our customer (our app user) sends an invoice to their Client.
+login = async () => {
+	const res = await bkn.login("[email protected]", "password");
+	if (!res.ok) {
+		console.error(res.content);
+		return;
+	}
+	token = res.content();
 
-Their client does not have any user account, but they need to see their invoice 
-when they click on the unique link on their email they received.
+	createTask();
+}
 
-This can be achieve via a backend function. Couple of ways:
+createTask = async () => {
+	const task = {
+		desc: "Do something for XYZ",
+		done: false
+	};
 
-* The email the client received can be directly a unique URL pointing to a 
-function as a service hosted somewhere. (We will have functions soon). That 
-function returns the invoice HTML.
-* Or it could be pointing to your client-side app and you perform a call to 
-a serverless function you're hosting somewhere. That function uses the 
-server-side library to perform a `GET` on behalf of the creator of the invoice 
-document, which is our customer.
+	const res = bkn.create(token, "tasks", task);
+	if (!res.ok) {
+		console.error(res.content);
+		return;
+	}
+	console.log(res.content);
+}
+```
 
-The function will be able to perform a Read operation using a special `Root Token`.
+The last `console.log` prints
 
-This `Root Token` allows your system to do anything on the server-side.
+```json
+{
+	"id": "123456-unique-id",
+	"accountId": "aaa-bbb-unique-account-id",
+	"desc": "Do something for XYZ",
+	"done": false
+}
+```
 
-I hope I did not lost the majority of people here ;)
+From there you build your application using the 
+[database](https://staticbackend.com/docs/database/) CRUD and query functions, 
+the [real-time component](https://staticbackend.com/docs/websocket/),
+the [storage API](https://staticbackend.com/docs/storage/), etc.
 
-This is one example of your typical day-to-day workflow using StaticBackend.
+You may use server-side libraries for Node and Go or use an HTTP client 
+and use your preferred language.
 
 ## Get started with the self-hosted version
 
@@ -195,6 +202,7 @@ Here's the examples we have created so far:
 
 * [To-do list example](https://staticbackend.com/getting-started/)
 * [Realtime collaboration](https://staticbackend.com/blog/realtime-collaboration-example/)
+* [Live chat using server-side function & real-time component](https://staticbackend.com/blog/server-side-functions-task-scheduler-example/)
 
 ## Deploying in production
 

function/runtime.go

@@ -328,6 +328,7 @@ func (env *ExecutionEnvironment) addVolatileFunctions(vm *goja.Runtime) {
 		if err != nil {
 			return vm.ToValue(Result{Content: fmt.Sprintf("error converting your data: %v", err)})
 		}
+		fmt.Println("DEBUG: ", string(b))
 
 		msg := internal.Command{
 			SID:     env.Data.ID.Hex(),

function/subscriber.go

@@ -26,9 +26,8 @@ func (sub *Subscriber) Start() {
 		select {
 		case msg := <-receiver:
 			go sub.process(msg)
-		case _ = <-close:
+		case <-close:
 			log.Println("system event channel closed?!?")
-			break
 		}
 	}
 }

functions.go

@@ -1,7 +1,6 @@
 package staticbackend
 
 import (
-	"fmt"
 	"net/http"
 	"staticbackend/db"
 	"staticbackend/function"
@@ -100,9 +99,6 @@ func (f *functions) exec(w http.ResponseWriter, r *http.Request) {
 
 	curDB := client.Database(conf.Name)
 
-	fmt.Println("DEBUG: search for name: ", data.FunctionName)
-	fmt.Println("DEBUG: base: ", conf.Name)
-
 	fn, err := function.GetForExecution(curDB, data.FunctionName)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)

internal/account.go

@@ -3,6 +3,7 @@ package internal
 import (
 	"context"
 	"fmt"
+	"strings"
 	"time"
 
 	"github.com/gbrlsnchs/jwt/v3"
@@ -21,6 +22,9 @@ type Auth struct {
 }
 
 func (auth Auth) ReconstructToken() string {
+	if strings.HasPrefix(auth.Token, "__tmp__experimental_public") {
+		return auth.Token
+	}
 	return fmt.Sprintf("%s|%s", auth.UserID.Hex(), auth.Token)
 }
 

internal/mailer.go

@@ -15,6 +15,8 @@ type SendMailData struct {
 	HTMLBody string `json:"htmlBody"`
 	TextBody string `json:"textBody"`
 	ReplyTo  string `json:"replyTo"`
+
+	Body string `json:"body"`
 }
 
 // Mailer is used to have different implementation for sending email

sendmail.go

@@ -3,6 +3,7 @@ package staticbackend
 import (
 	"context"
 	"net/http"
+	"staticbackend/email"
 	"staticbackend/internal"
 	"staticbackend/middleware"
 
@@ -16,6 +17,25 @@ func sudoSendMail(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// all email are sent from the env var MAIL_FROM
+	from := data.From
+	if len(data.ReplyTo) > 0 {
+		from = data.ReplyTo
+	}
+
+	data.From = FromEmail
+	data.ReplyTo = from
+
+	// if only body is provided
+	if len(data.Body) > 0 {
+		data.HTMLBody = data.Body
+		data.TextBody = email.StripHTML(data.Body)
+	} else if len(data.TextBody) == 0 && len(data.HTMLBody) > 0 {
+		data.TextBody = email.StripHTML(data.HTMLBody)
+	} else if len(data.HTMLBody) == 0 && len(data.TextBody) > 0 {
+		data.HTMLBody = data.TextBody
+	}
+
 	if err := emailer.Send(data); err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return

server.go

@@ -58,18 +58,20 @@ func Start(dbHost, port string) {
 	b := realtime.NewBroker(func(ctx context.Context, key string) (string, error) {
 		//TODO: Experimental, let un-authenticated user connect
 		// useful for an Intercom-like SaaS I'm building.
-		if strings.HasPrefix(key, "__tmp__experimental_public_19378246_") {
+		if strings.HasPrefix(key, "__tmp__experimental_public") {
 			// let's create the most minimal authentication possible
 			a := internal.Auth{
 				AccountID: primitive.NewObjectID(),
 				UserID:    primitive.NewObjectID(),
 				Email:     "[email protected]",
 				Role:      0,
+				Token:     key,
 			}
 
 			if err := volatile.SetTyped(key, a); err != nil {
 				return key, err
 			}
+
 			return key, nil
 		}
 
@@ -232,7 +234,16 @@ func initServices(dbHost string) {
 		var exe function.ExecutionEnvironment
 
 		var conf internal.BaseConfig
-		if err := volatile.GetTyped("base:"+token, &conf); err != nil {
+		// for public websocket (experimental)
+		if strings.HasPrefix(token, "__tmp__experimental_public") {
+			pk := strings.Replace(token, "__tmp__experimental_public_", "", -1)
+			pairs := strings.Split(pk, "_")
+			fmt.Println("checking for base in cache: ", pairs[0])
+			if err := volatile.GetTyped(pairs[0], &conf); err != nil {
+				log.Println("cannot find base for public websocket")
+				return exe, err
+			}
+		} else if err := volatile.GetTyped("base:"+token, &conf); err != nil {
 			log.Println("cannot find base")
 			return exe, err
 		}
@@ -246,6 +257,7 @@ func initServices(dbHost string) {
 		exe.Auth = auth
 		exe.Base = &db.Base{PublishDocument: volatile.PublishDocument}
 		exe.DB = client.Database(conf.Name)
+		exe.Volatile = volatile
 
 		return exe, nil
 	}