Add Hooks

Author: srikrsna

create.go

@@ -5,6 +5,9 @@ import (
 	"fmt"
 )
 
+// OnCreateHook is the signature of [Hooks.OnCreate] hook.
+type OnCreateHook func(*HookContext, any, *CreateOptions)
+
 // CreateOptions are options for the `Create` operation.
 type CreateOptions struct {
 	CreateMetadata Metadata
@@ -28,6 +31,12 @@ type CreateResult struct{}
 //
 // See `CreateOptions` for replacing documents if already present.
 func (s *Store[T]) Create(ctx context.Context, doc *T, opts CreateOptions) (*CreateResult, error) {
+	hookCtx := NewHookContext(ctx, s)
+	for _, hook := range s.hooks {
+		if hook.OnCreate != nil {
+			hook.OnCreate(hookCtx, doc, &opts)
+		}
+	}
 	id := s.idFn(doc)
 	if id == "" {
 		return nil, fmt.Errorf("nidhi: id cannot be empty")

delete.go

@@ -7,6 +7,12 @@ import (
 	sq "github.com/elgris/sqrl"
 )
 
+// OnDeleteHook is the function signature for the [Hooks.OnDelete] hook.
+type OnDeleteHook func(*HookContext, string, *DeleteOptions)
+
+// OnDeleteManyHook is the function signature for the [Hooks.OnDeleteMany] hook.
+type OnDeleteManyHook func(*HookContext, Sqlizer, *DeleteManyOptions)
+
 // DeleteOptions are options for the `Delete` operation
 type DeleteOptions struct {
 	// Metadata is the metadata of the document.
@@ -45,6 +51,12 @@ type DeleteManyResult struct {
 //
 // By default all deletes are soft deletes. To hard delete, see `DeleteOptions`
 func (s *Store[T]) Delete(ctx context.Context, id string, opts DeleteOptions) (*DeleteResult, error) {
+	hookCtx := NewHookContext(ctx, s)
+	for _, h := range s.hooks {
+		if h.OnDelete != nil {
+			h.OnDelete(hookCtx, id, &opts)
+		}
+	}
 	var (
 		sqlStr string
 		args   []any
@@ -79,6 +91,12 @@ func (s *Store[T]) Delete(ctx context.Context, id string, opts DeleteOptions) (*
 }
 
 func (s *Store[T]) DeleteMany(ctx context.Context, q Sqlizer, opts DeleteManyOptions) (*DeleteManyResult, error) {
+	hookCtx := NewHookContext(ctx, s)
+	for _, h := range s.hooks {
+		if h.OnDeleteMany != nil {
+			h.OnDeleteMany(hookCtx, q, &opts)
+		}
+	}
 	var (
 		sqlStr string
 		args   []any

get.go

@@ -10,6 +10,12 @@ import (
 	"golang.org/x/exp/maps"
 )
 
+// OnGetHook is the signature of [Hooks.OnGet] hook.
+type OnGetHook func(*HookContext, string, *GetOptions)
+
+// OnQueryHook is the signature of [Hooks.OnQuery] hook.
+type OnQueryHook func(*HookContext, Sqlizer, *QueryOptions)
+
 // Document is wrapper for a resource.
 type Document[T any] struct {
 	// Value is the resource.
@@ -91,6 +97,12 @@ type QueryResult[T any] struct {
 
 // Get is used to get a document from the store.
 func (s *Store[T]) Get(ctx context.Context, id string, opts GetOptions) (*GetResult[T], error) {
+	hookCtx := NewHookContext(ctx, s)
+	for _, h := range s.hooks {
+		if h.OnGet != nil {
+			h.OnGet(hookCtx, id, &opts)
+		}
+	}
 	var selection any = ColDoc
 	if len(s.fields) > 0 && len(opts.ViewMask) > 0 {
 		selection = sq.Expr(ColDoc+" - ?::text[]", pg.Array(difference(s.fields, opts.ViewMask)))
@@ -130,6 +142,12 @@ func (s *Store[T]) Get(ctx context.Context, id string, opts GetOptions) (*GetRes
 
 // Query queries the store and returns all matching documents.
 func (s *Store[T]) Query(ctx context.Context, q Sqlizer, opts QueryOptions) (*QueryResult[T], error) {
+	hookCtx := NewHookContext(ctx, s)
+	for _, h := range s.hooks {
+		if h.OnQuery != nil {
+			h.OnQuery(hookCtx, q, &opts)
+		}
+	}
 	selection := any(ColDoc)
 	if len(s.fields) > 0 && len(opts.ViewMask) > 0 {
 		selection = sq.Expr(ColDoc+" - ?::text[]", pg.Array(difference(s.fields, opts.ViewMask)))

hooks.go

@@ -0,0 +1,56 @@
+package nidhi
+
+import "context"
+
+// Hooks are callbacks that are called on store operations.
+//
+// The passed values can if modified will change for the op.
+type Hooks struct {
+	// OnCreate is called on [Store.Create].
+	OnCreate OnCreateHook
+	// OnGet is called on [Store.Get].
+	OnGet OnGetHook
+	// OnQuery is called on [Store.Query].
+	OnQuery OnQueryHook
+	// OnDelete is called on [Store.Delete].
+	OnDelete OnDeleteHook
+	// OnDeleteMany is called on [Store.DeleteMany].
+	OnDeleteMany OnDeleteManyHook
+	// OnReplace is called on [Store.Replace].
+	OnReplace OnReplaceHook
+	// OnUpdate is called on [Store.Update].
+	OnUpdate OnUpdateHook
+	// OnUpdateMany is called on [Store.UpdateMany].
+	OnUpdateMany OnUpdateManyHook
+}
+
+// HookContext is the context passed to [Hooks]
+type HookContext struct {
+	context.Context
+
+	idFn    func(any) string
+	setIdFn func(any, string)
+}
+
+// NewHookContext returns a [HookContext].
+func NewHookContext[T any](ctx context.Context, store *Store[T]) *HookContext {
+	return &HookContext{
+		Context: ctx,
+		idFn: func(t any) string {
+			return store.idFn(t.(*T))
+		},
+		setIdFn: func(t any, s string) {
+			store.setIdFn(t.(*T), s)
+		},
+	}
+}
+
+// SetId sets the id field of the document.
+func (s *HookContext) SetId(v any, id string) {
+	s.setIdFn(v, id)
+}
+
+// Id returns the id of the document
+func (s *HookContext) Id(v any) string {
+	return s.idFn(v)
+}

hooks_test.go

@@ -0,0 +1,81 @@
+package nidhi_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/akshayjshah/attest"
+	"github.com/srikrsna/nidhi"
+)
+
+func TestHooks(t *testing.T) {
+	db := newDB(t)
+	const (
+		create int = iota
+		get
+		query
+		replace
+		update
+		updateMany
+		delete
+		deleteMany
+	)
+	called := map[int]bool{}
+	store := newStore(t, db, nidhi.StoreOptions{
+		Hooks: []nidhi.Hooks{
+			{
+				OnCreate:     func(*nidhi.HookContext, any, *nidhi.CreateOptions) { called[create] = true },
+				OnGet:        func(*nidhi.HookContext, string, *nidhi.GetOptions) { called[get] = true },
+				OnQuery:      func(*nidhi.HookContext, nidhi.Sqlizer, *nidhi.QueryOptions) { called[query] = true },
+				OnDelete:     func(*nidhi.HookContext, string, *nidhi.DeleteOptions) { called[delete] = true },
+				OnDeleteMany: func(*nidhi.HookContext, nidhi.Sqlizer, *nidhi.DeleteManyOptions) { called[deleteMany] = true },
+				OnReplace:    func(*nidhi.HookContext, any, *nidhi.ReplaceOptions) { called[replace] = true },
+				OnUpdate:     func(*nidhi.HookContext, string, any, *nidhi.UpdateOptions) { called[update] = true },
+				OnUpdateMany: func(*nidhi.HookContext, any, nidhi.Sqlizer, *nidhi.UpdateManyOptions) { called[updateMany] = true },
+			},
+		},
+	})
+	ctx := context.TODO()
+	_, _ = store.Create(ctx, defaultResource(), nidhi.CreateOptions{})
+	attest.True(t, called[create])
+	_, _ = store.Get(ctx, "", nidhi.GetOptions{})
+	attest.True(t, called[get])
+	_, _ = store.Query(ctx, nil, nidhi.QueryOptions{})
+	attest.True(t, called[query])
+	_, _ = store.Delete(ctx, "", nidhi.DeleteOptions{})
+	attest.True(t, called[delete])
+	_, _ = store.DeleteMany(ctx, nil, nidhi.DeleteManyOptions{})
+	attest.True(t, called[deleteMany])
+	_, _ = store.Replace(ctx, defaultResource(), nidhi.ReplaceOptions{})
+	attest.True(t, called[replace])
+	_, _ = store.Update(ctx, "", nil, nidhi.UpdateOptions{})
+	attest.True(t, called[update])
+	_, _ = store.UpdateMany(ctx, nil, nil, nidhi.UpdateManyOptions{})
+	attest.True(t, called[updateMany])
+}
+
+func TestHookContext(t *testing.T) {
+	var (
+		idFn    = func(t *resource) string { return t.Id }
+		setIdFn = func(t *resource, s string) { t.Id = s }
+	)
+	db := newDB(t)
+	store, err := nidhi.NewStore(
+		context.Background(),
+		db,
+		"schema",
+		"table",
+		[]string{"field"},
+		idFn,
+		setIdFn,
+		nidhi.StoreOptions{},
+	)
+	attest.Ok(t, err)
+	attest.NotZero(t, store)
+	ctx := nidhi.NewHookContext(context.Background(), store)
+	r := defaultResource()
+	r.Id = "id"
+	attest.Equal(t, ctx.Id(r), r.Id)
+	ctx.SetId(r, "new")
+	attest.Equal(t, r.Id, "new")
+}

store.go

@@ -41,6 +41,8 @@ type (
 type StoreOptions struct {
 	// MetadataRegistry is the registry of metadata parts.
 	MetadataRegistry map[string]func() MetadataPart
+	// Hooks for the store operations.
+	Hooks []Hooks
 }
 
 // Store is the collection of documents
@@ -53,7 +55,8 @@ type Store[T any] struct {
 	idFn    IdFn[T]
 	setIdFn SetIdFn[T]
 
-	mdr map[string]func() MetadataPart
+	mdr   map[string]func() MetadataPart
+	hooks []Hooks
 }
 
 // NewStore returns a new store.
@@ -82,5 +85,6 @@ func NewStore[T any](
 		idFn:    idFn,
 		setIdFn: setIdFn,
 		mdr:     opts.MetadataRegistry,
+		hooks:   opts.Hooks,
 	}, nil
 }

update.go

@@ -7,6 +7,15 @@ import (
 	sq "github.com/elgris/sqrl"
 )
 
+// OnReplaceHook is the signature for the [Hooks.OnReplace] hook.
+type OnReplaceHook func(*HookContext, any, *ReplaceOptions)
+
+// OnUpdateHook is the signature for the [Hooks.OnUpdate] hook.
+type OnUpdateHook func(*HookContext, string, any, *UpdateOptions)
+
+// OnUpdateManyHook is the signature for the [Hooks.OnUpdateMany] hook.
+type OnUpdateManyHook func(*HookContext, any, Sqlizer, *UpdateManyOptions)
+
 // ReplaceOptions are options for `Replace` operation.
 type ReplaceOptions struct {
 	// Metadata is the metadata of the document.
@@ -54,6 +63,12 @@ type UpdateManyResult struct {
 //
 // Returns a NotFound error, if the document doesn't exist or the revision doesn't exist.
 func (s *Store[T]) Replace(ctx context.Context, doc *T, opts ReplaceOptions) (*ReplaceResult, error) {
+	hookCtx := NewHookContext(ctx, s)
+	for _, h := range s.hooks {
+		if h.OnReplace != nil {
+			h.OnReplace(hookCtx, doc, &opts)
+		}
+	}
 	rc, err := s.update(ctx, doc, sq.Eq{ColId: s.idFn(doc)}, false, opts.Metadata, opts.Revision)
 	if err != nil {
 		return nil, err
@@ -68,6 +83,12 @@ func (s *Store[T]) Replace(ctx context.Context, doc *T, opts ReplaceOptions) (*R
 //
 // Returns a NotFound error on id and revision mismatch.
 func (s *Store[T]) Update(ctx context.Context, id string, updates any, opts UpdateOptions) (*UpdateResult, error) {
+	hookCtx := NewHookContext(ctx, s)
+	for _, h := range s.hooks {
+		if h.OnUpdate != nil {
+			h.OnUpdate(hookCtx, id, updates, &opts)
+		}
+	}
 	rc, err := s.update(ctx, updates, sq.Eq{ColId: id}, true, opts.Metadata, opts.Revision)
 	if err != nil {
 		return nil, err
@@ -80,6 +101,12 @@ func (s *Store[T]) Update(ctx context.Context, id string, updates any, opts Upda
 
 // UpdateMany updates all the documents that match the given query.
 func (s *Store[T]) UpdateMany(ctx context.Context, updates any, q Sqlizer, opts UpdateManyOptions) (*UpdateManyResult, error) {
+	hookCtx := NewHookContext(ctx, s)
+	for _, h := range s.hooks {
+		if h.OnUpdateMany != nil {
+			h.OnUpdateMany(hookCtx, updates, q, &opts)
+		}
+	}
 	rc, err := s.update(ctx, updates, q, true, opts.Metadata, -1)
 	if err != nil {
 		return nil, err