From 209239705fff9b3545d6856387203f12accd603b Mon Sep 17 00:00:00 2001
From: mo khan <mo@mokhan.ca>
Date: Thu, 24 Jul 2025 14:01:44 -0600
Subject: refactor: use username as id for demo

---
 app/init.go | 84 +++++++++++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 65 insertions(+), 19 deletions(-)

(limited to 'app/init.go')

diff --git a/app/init.go b/app/init.go
index d26a962..b88cb00 100644
--- a/app/init.go
+++ b/app/init.go
@@ -5,6 +5,7 @@ import (
 	"net/http"
 	"os"
 
+	v1 "github.com/authzed/authzed-go/proto/authzed/api/v1"
 	"github.com/authzed/authzed-go/v1"
 	"github.com/rs/zerolog"
 	"github.com/xlgmokha/x/pkg/env"
@@ -22,50 +23,53 @@ import (
 )
 
 func init() {
-	ioc.RegisterSingleton[*zerolog.Logger](ioc.Default, func() *zerolog.Logger {
+	c := ioc.Default
+
+	ioc.RegisterSingleton[*zerolog.Logger](c, func() *zerolog.Logger {
 		return log.New(os.Stdout, log.Fields{"app": "sparkled"})
 	})
-	ioc.RegisterSingleton[*authzed.Client](ioc.Default, func() *authzed.Client {
+	ioc.RegisterSingleton[*authzed.Client](c, func() *authzed.Client {
 		return authz.NewSpiceDBClient(
 			context.Background(),
 			env.Fetch("ZED_ENDPOINT", ":50051"),
 			env.Fetch("ZED_TOKEN", "secret"),
 		)
 	})
-	ioc.Register[authz.CheckPermissionService](ioc.Default, func() authz.CheckPermissionService {
-		return ioc.MustResolve[*authzed.Client](ioc.Default)
+	ioc.Register[authz.CheckPermissionService](c, func() authz.CheckPermissionService {
+		return ioc.MustResolve[*authzed.Client](c)
 	})
-	ioc.RegisterSingleton[*event.Aggregator](ioc.Default, func() *event.Aggregator {
+	ioc.RegisterSingleton[*event.Aggregator](c, func() *event.Aggregator {
 		return x.New[*event.Aggregator](event.WithDefaults())
 	})
-	ioc.RegisterSingleton[domain.Repository[*domain.Sparkle]](ioc.Default, func() domain.Repository[*domain.Sparkle] {
-		return db.NewRepository[*domain.Sparkle](
-			x.New[*event.TypedAggregator[*domain.Sparkle]](event.WithAggregator[*domain.Sparkle](
-				ioc.MustResolve[*event.Aggregator](ioc.Default),
-			)),
-		)
+	ioc.Register[*event.TypedAggregator[*domain.Sparkle]](c, func() *event.TypedAggregator[*domain.Sparkle] {
+		return x.New[*event.TypedAggregator[*domain.Sparkle]](event.WithAggregator[*domain.Sparkle](
+			ioc.MustResolve[*event.Aggregator](c),
+		))
+	})
+	ioc.RegisterSingleton[domain.Repository[*domain.Sparkle]](c, func() domain.Repository[*domain.Sparkle] {
+		return db.NewRepository[*domain.Sparkle](ioc.MustResolve[*event.TypedAggregator[*domain.Sparkle]](c))
 	})
-	ioc.RegisterSingleton[*http.ServeMux](ioc.Default, func() *http.ServeMux {
+	ioc.RegisterSingleton[*http.ServeMux](c, func() *http.ServeMux {
 		return http.NewServeMux()
 	})
-	ioc.Register[*dashboard.Controller](ioc.Default, func() *dashboard.Controller {
+	ioc.Register[*dashboard.Controller](c, func() *dashboard.Controller {
 		return dashboard.New()
 	})
-	ioc.Register[*sparkles.Controller](ioc.Default, func() *sparkles.Controller {
+	ioc.Register[*sparkles.Controller](c, func() *sparkles.Controller {
 		return sparkles.New(
-			ioc.MustResolve[domain.Repository[*domain.Sparkle]](ioc.Default),
-			ioc.MustResolve[authz.CheckPermissionService](ioc.Default),
+			ioc.MustResolve[domain.Repository[*domain.Sparkle]](c),
+			ioc.MustResolve[authz.CheckPermissionService](c),
 		)
 	})
-	ioc.RegisterSingleton[*http.Client](ioc.Default, func() *http.Client {
+	ioc.RegisterSingleton[*http.Client](c, func() *http.Client {
 		return &http.Client{
 			Transport: &web.Transport{
-				Logger: ioc.MustResolve[*zerolog.Logger](ioc.Default),
+				Logger: ioc.MustResolve[*zerolog.Logger](c),
 			},
 		}
 	})
 
-	http.DefaultClient = ioc.MustResolve[*http.Client](ioc.Default)
+	http.DefaultClient = ioc.MustResolve[*http.Client](c)
 
 	mapper.Register[*http.Request, log.Fields](func(r *http.Request) log.Fields {
 		return log.Fields{
@@ -76,4 +80,46 @@ func init() {
 			"request_id":  r.Header.Get("x-request-id"),
 		}
 	})
+
+	ioc.MustResolve[*event.TypedAggregator[*domain.Sparkle]](c).SubscribeTo("after.create", func(item *domain.Sparkle) {
+		client := ioc.MustResolve[*authzed.Client](c)
+		client.WriteRelationships(context.Background(), &v1.WriteRelationshipsRequest{
+			Updates: []*v1.RelationshipUpdate{
+				&v1.RelationshipUpdate{
+					Operation: v1.RelationshipUpdate_OPERATION_CREATE,
+					Relationship: &v1.Relationship{
+						Resource: item.ToObjectReference(),
+						Relation: "sparkler",
+						Subject:  item.Author.ToSubjectReference(),
+					},
+				},
+				&v1.RelationshipUpdate{
+					Operation: v1.RelationshipUpdate_OPERATION_CREATE,
+					Relationship: &v1.Relationship{
+						Resource: item.ToObjectReference(),
+						Relation: "sparklee",
+						Subject: &v1.SubjectReference{
+							Object: &v1.ObjectReference{
+								ObjectType: "user",
+								ObjectId:   item.Sparklee,
+							},
+						},
+					},
+				},
+				&v1.RelationshipUpdate{
+					Operation: v1.RelationshipUpdate_OPERATION_CREATE,
+					Relationship: &v1.Relationship{
+						Resource: item.ToObjectReference(),
+						Relation: "reader",
+						Subject: &v1.SubjectReference{
+							Object: &v1.ObjectReference{
+								ObjectType: "user",
+								ObjectId:   "*",
+							},
+						},
+					},
+				},
+			},
+		})
+	})
 }
-- 
cgit v1.2.3