Merge branch 'main' into feature/server-side-functions

Author: dstpierre

CHANGELOG.md

@@ -0,0 +1,64 @@
+# Changelog for StaticBackend
+
+### Aug 12, 2021
+
+* Updated the realtime broker to handle distribution by having all messages 
+using Redis's PubSub
+
+### Aug 3, 2021
+
+* Added Dockerfile and made it easier to use Docker Compose to start an 
+instance quickly.
+
+### ### Aug 2, 2021
+
+* Added form submission list/view to the web UI
+
+### Jul 31, 2021
+
+* Huge database refactor to make it easier to share with UI
+* Created first basic web UI to make it easier to get started with new instance
+
+### ### Jul 29, 2021
+
+* Removed AWS requirements by provider local implementation for storage and 
+email
+
+### Jul 27, 2021
+
+* Created interface for sending email
+* Created interface for storage operations
+* Binary release 1.0.0-alpha1
+
+### Jul 26, 2021
+
+* Refactored lots of code into sub-packages
+
+* 
+
+### Jul 2021
+
+* Added possibilities to delete files
+* Added possibilities to send email (still not on client library)
+* Released as open source
+
+### May 2021
+
+* New realtime implementation using SSE, websocket was causing lots of issues.
+* Added the MIT LICENSE, preparing for open source release
+
+### Jan 2021
+
+Started the websocket implementation
+
+### Dec 2020
+
+After almost 1 year of in and out, the first production version is deployed.
+
+### Jan 2020
+
+First commit to GitHub, when the project got real and rewritten in Go.
+
+### Oct 2019
+
+Project started, first version was written in Node.

Makefile

@@ -8,8 +8,9 @@ start: build
 	@./cmd/staticbackend
 
 deploy:
-	CGO_ENABLED=0 go build
-	scp staticbackend sb-poc:/home/dstpierre/sb
+	@cd cmd && rm -rf staticbackend && CGO_ENABLED=0 go build -o staticbackend
+	scp cmd/staticbackend sb-poc:/home/dstpierre/sb
+	scp -qr ./templates/* sb-poc:/home/dstpierre/templates/
 
 test:
 	@JWT_SECRET=okdevmode go test -v --race --cover ./...

account.go

@@ -61,8 +61,11 @@ func (a *accounts) create(w http.ResponseWriter, r *http.Request) {
 	}
 
 	stripeCustomerID, subID := "", ""
+	active := true
+
+	if AppEnv == AppEnvProd && len(os.Getenv("STRIPE_KEY")) > 0 {
+		active = false
 
-	if AppEnv == AppEnvProd {
 		cusParams := &stripe.CustomerParams{
 			Email: stripe.String(email),
 		}
@@ -99,6 +102,7 @@ func (a *accounts) create(w http.ResponseWriter, r *http.Request) {
 		Email:          email,
 		StripeID:       stripeCustomerID,
 		SubscriptionID: subID,
+		IsActive:       active,
 		Created:        time.Now(),
 	}
 
@@ -127,6 +131,7 @@ func (a *accounts) create(w http.ResponseWriter, r *http.Request) {
 		ID:        primitive.NewObjectID(),
 		SBID:      acctID,
 		Name:      dbName,
+		IsActive:  active,
 		Whitelist: []string{"localhost"},
 	}
 
@@ -146,7 +151,7 @@ func (a *accounts) create(w http.ResponseWriter, r *http.Request) {
 	}
 
 	signUpURL := "no need to sign up in dev mode"
-	if AppEnv == AppEnvProd {
+	if AppEnv == AppEnvProd && len(os.Getenv("STRIPE_KEY")) > 0 {
 		params := &stripe.BillingPortalSessionParams{
 			Customer:  stripe.String(stripeCustomerID),
 			ReturnURL: stripe.String("https://staticbackend.com/stripe"),

cache/cache.go

@@ -42,6 +42,14 @@ func (c *Cache) Set(key string, value string) error {
 	return nil
 }
 
+func (c *Cache) Inc(key string, by int64) (int64, error) {
+	return c.Rdb.IncrBy(c.Ctx, key, by).Result()
+}
+
+func (c *Cache) Dec(key string, by int64) (int64, error) {
+	return c.Rdb.DecrBy(c.Ctx, key, by).Result()
+}
+
 func (c *Cache) Subscribe(send chan internal.Command, token, channel string, close chan bool) {
 	pubsub := c.Rdb.Subscribe(c.Ctx, channel)
 

internal/data.go

@@ -12,7 +12,7 @@ type BaseConfig struct {
 	SBID      primitive.ObjectID `bson:"accountId" json:"-"`
 	Name      string             `bson:"name" json:"name"`
 	Whitelist []string           `bson:"whitelist" json:"whitelist"`
-	Valid     bool               `bson:"valid" json:"valid"`
+	IsActive  bool               `bson:"active" json:"-"`
 }
 
 var (
@@ -39,6 +39,7 @@ const (
 	MsgTypeToken     = "token"
 	MsgTypeJoin      = "join"
 	MsgTypeJoined    = "joined"
+	MsgTypePresence  = "presence"
 	MsgTypeChanIn    = "chan_in"
 	MsgTypeChanOut   = "chan_out"
 	MsgTypeDBCreated = "db_created"

internal/pubsuber.go

@@ -0,0 +1,12 @@
+package internal
+
+// PubSuber contains functions to make realtime communication distributed
+type PubSuber interface {
+	Get(key string) (string, error)
+	Set(key string, value string) error
+	Inc(key string, by int64) (int64, error)
+	Dec(key string, by int64) (int64, error)
+	Subscribe(send chan Command, token, channel string, close chan bool)
+	Publish(msg Command) error
+	PublishDocument(channel, typ string, v interface{})
+}

main_test.go

@@ -98,7 +98,7 @@ func deleteAndSetupTestAccount() {
 		SBID:      acctID,
 		Name:      dbName,
 		Whitelist: []string{"localhost"},
-		Valid:     true,
+		IsActive:  true,
 	}
 
 	if _, err := sysDB.Collection("bases").InsertOne(ctx, base); err != nil {

middleware/withdb.go

@@ -54,6 +54,9 @@ func WithDB(client *mongo.Client) Middleware {
 				if err != nil {
 					http.Error(w, err.Error(), http.StatusInternalServerError)
 					return
+				} else if !conf.IsActive {
+					http.Error(w, "your account is not inactive. Please contact us support@staticbackend.com", http.StatusUnauthorized)
+					return
 				}
 
 				ctx = context.WithValue(ctx, ContextBase, conf)

realtime/broker.go

@@ -26,20 +26,23 @@ type Broker struct {
 	clients            map[chan internal.Command]string
 	ids                map[string]chan internal.Command
 	conf               map[string]context.Context
-	subscriptions      map[string][]string
+	subscriptions      map[string][]chan bool
 	validateAuth       Validator
+
+	pubsub internal.PubSuber
 }
 
-func NewBroker(v Validator) *Broker {
+func NewBroker(v Validator, pubsub internal.PubSuber) *Broker {
 	b := &Broker{
 		Broadcast:          make(chan internal.Command, 1),
 		newConnections:     make(chan ConnectionData),
 		closingConnections: make(chan chan internal.Command),
 		clients:            make(map[chan internal.Command]string),
 		ids:                make(map[string]chan internal.Command),
 		conf:               make(map[string]context.Context),
-		subscriptions:      make(map[string][]string),
+		subscriptions:      make(map[string][]chan bool),
 		validateAuth:       v,
+		pubsub:             pubsub,
 	}
 
 	go b.start()
@@ -85,6 +88,13 @@ func (b *Broker) unsub(c chan internal.Command) {
 		fmt.Println("cannot find connection id")
 	}
 
+	subs, ok := b.subscriptions[id]
+	if ok {
+		for _, ch := range subs {
+			ch <- true
+		}
+	}
+
 	delete(b.ids, id)
 }
 
@@ -140,12 +150,15 @@ func (b *Broker) Accept(w http.ResponseWriter, r *http.Request) {
 }
 
 func (b *Broker) getTargets(msg internal.Command) (sockets []chan internal.Command, payload internal.Command) {
+	var sender chan internal.Command
+
 	if msg.SID != internal.SystemID {
-		sender, ok := b.ids[msg.SID]
+		s, ok := b.ids[msg.SID]
 		if !ok {
 			fmt.Println("cannot find sender socket", msg.SID)
 			return
 		}
+		sender = s
 		sockets = append(sockets, sender)
 	}
 
@@ -167,15 +180,27 @@ func (b *Broker) getTargets(msg internal.Command) (sockets []chan internal.Comma
 
 		payload = internal.Command{Type: internal.MsgTypeToken, Data: msg.Data}
 	case internal.MsgTypeJoin:
-		members, ok := b.subscriptions[msg.Data]
+		subs, ok := b.subscriptions[msg.SID]
 		if !ok {
-			members = make([]string, 0)
+			subs = make([]chan bool, 0)
 		}
 
-		members = append(members, msg.SID)
-		b.subscriptions[msg.Data] = members
+		closesub := make(chan bool)
+
+		subs = append(subs, closesub)
+		b.subscriptions[msg.SID] = subs
+
+		go b.pubsub.Subscribe(sender, msg.Token, msg.Data, closesub)
 
 		payload = internal.Command{Type: internal.MsgTypeJoined, Data: msg.Data}
+	case internal.MsgTypePresence:
+		v, err := b.pubsub.Get(msg.Data)
+		if err != nil {
+			//TODO: Make sure it's because the channel key does not exists
+			v = "0"
+		}
+
+		payload = internal.Command{Type: internal.MsgTypePresence, Data: v}
 	case internal.MsgTypeChanIn:
 		if len(msg.Channel) == 0 {
 			payload = internal.Command{Type: internal.MsgTypeError, Data: "no channel was specified"}
@@ -188,7 +213,8 @@ func (b *Broker) getTargets(msg internal.Command) (sockets []chan internal.Comma
 			return
 		}
 
-		go b.Publish(msg, msg.Channel)
+		go b.pubsub.Publish(msg)
+		//go b.Publish(msg, msg.Channel)
 
 		payload = internal.Command{Type: internal.MsgTypeOk}
 	default:
@@ -198,24 +224,3 @@ func (b *Broker) getTargets(msg internal.Command) (sockets []chan internal.Comma
 
 	return
 }
-
-// Publish sends a message to all socket in that channel
-func (b *Broker) Publish(msg internal.Command, channel string) {
-	if msg.Type == internal.MsgTypeChanIn {
-		msg.Type = internal.MsgTypeChanOut
-	}
-
-	members, ok := b.subscriptions[channel]
-	if !ok {
-		return
-	}
-
-	for _, sid := range members {
-		c, ok := b.ids[sid]
-		if !ok {
-			continue
-		}
-
-		c <- msg
-	}
-}

server.go

@@ -19,6 +19,7 @@ import (
 	"staticbackend/cache"
 
 	"github.com/stripe/stripe-go/v71"
+	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
 	"go.mongodb.org/mongo-driver/mongo/readpref"
@@ -53,11 +54,26 @@ func Start(dbHost, port string) {
 
 	// Server Send Event, alternative to websocket
 	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_") {
+			// let's create the most minimal authentication possible
+			a := internal.Auth{
+				AccountID: primitive.NewObjectID(),
+				UserID:    primitive.NewObjectID(),
+				Email:     "exp@tmp.com",
+				Role:      0,
+			}
+
+			internal.Tokens[key] = a
+			return key, nil
+		}
+
 		if _, err := middleware.ValidateAuthKey(client, ctx, key); err != nil {
 			return "", err
 		}
 		return key, nil
-	})
+	}, volatile)
 
 	database := &Database{
 		client: client,