Refactor Deferred

Author: emacsway

grade/internal/infrastructure/seedwork/batch/multi_query.go

@@ -84,9 +84,11 @@ func (q MultiQuery) Evaluate(s session.DbSession) (session.Result, error) {
 		return nil, err
 	}
 	for i := range q.results {
-		err = q.results[i].Resolve(0, 0)
-		if err != nil {
-			errs = multierror.Append(errs, err)
+		d := q.results[i]
+		d.Resolve(0, 0)
+		occurredErr := d.OccurredErr()
+		if occurredErr != nil {
+			errs = multierror.Append(errs, occurredErr)
 		}
 	}
 	return r, errs
@@ -110,9 +112,11 @@ func (q AutoincrementMultiInsertQuery) Evaluate(s session.DbSession) (session.Re
 		if err != nil {
 			return nil, err
 		}
-		err = q.results[i].Resolve(id, 0)
-		if err != nil {
-			errs = multierror.Append(errs, err)
+		d := q.results[i]
+		d.Resolve(id, 0)
+		occurredErr := d.OccurredErr()
+		if occurredErr != nil {
+			errs = multierror.Append(errs, occurredErr)
 		}
 		i++
 	}

grade/internal/infrastructure/seedwork/deferred/deferred.go

@@ -0,0 +1,86 @@
+package deferred
+
+import "github.com/hashicorp/go-multierror"
+
+/**
+* Simplified version of
+* - https://github.com/emacsway/store/blob/devel/polyfill.js#L199
+* - https://github.com/emacsway/go-promise
+**/
+
+func Noop[T interface{}](_ T) error { return nil }
+
+type handler[T interface{}] struct {
+	onSuccess DeferredCallback[T]
+	onError   DeferredCallback[error]
+	next      *DeferredImp[any]
+}
+
+type DeferredImp[T interface{}] struct {
+	value       T
+	err         error
+	occurredErr error
+	isResolved  bool
+	isRejected  bool
+	handlers    []handler[T]
+}
+
+func (d *DeferredImp[T]) Resolve(value T) {
+	d.value = value
+	d.isResolved = true
+	for _, h := range d.handlers {
+		d.resolveHandler(h)
+	}
+}
+
+func (d *DeferredImp[T]) Reject(err error) {
+	d.isRejected = true
+	for _, h := range d.handlers {
+		d.rejectHandler(h)
+	}
+}
+
+func (d *DeferredImp[T]) Then(onSuccess DeferredCallback[T], onError DeferredCallback[error]) Deferred[any] {
+	next := &DeferredImp[any]{}
+	h := handler[T]{
+		onSuccess: onSuccess,
+		onError:   onError,
+		next:      next,
+	}
+	d.handlers = append(d.handlers, h)
+	if d.isResolved {
+		d.resolveHandler(h)
+	} else if d.isRejected {
+		d.rejectHandler(h)
+	}
+	return next
+}
+
+func (d *DeferredImp[T]) resolveHandler(h handler[T]) {
+	err := h.onSuccess(d.value)
+	if err == nil {
+		h.next.Resolve(true)
+	} else {
+		d.occurredErr = multierror.Append(d.occurredErr, err)
+		h.next.Reject(err)
+	}
+}
+
+func (d *DeferredImp[T]) rejectHandler(h handler[T]) {
+	err := h.onError(d.err)
+	if err != nil {
+		d.occurredErr = multierror.Append(d.occurredErr, err)
+		h.next.Reject(err)
+	}
+}
+
+func (d *DeferredImp[T]) OccurredErr() error {
+	err := d.occurredErr
+	for _, h := range d.handlers {
+		nestedErr := h.next.OccurredErr()
+		if nestedErr != nil {
+			err = multierror.Append(err, nestedErr)
+		}
+	}
+	return err
+}

grade/internal/infrastructure/seedwork/deferred/interfaces.go

@@ -0,0 +1,7 @@
+package deferred
+
+type DeferredCallback[T interface{}] func(T) error
+
+type Deferred[T interface{}] interface {
+	Then(DeferredCallback[T], DeferredCallback[error]) Deferred[any]
+}

grade/internal/infrastructure/seedwork/session/deferred.go

@@ -1,6 +1,9 @@
 package session
 
-import "github.com/emacsway/grade/grade/internal/application/seedwork/session"
+import (
+	"github.com/emacsway/grade/grade/internal/application/seedwork/session"
+	"github.com/emacsway/grade/grade/internal/infrastructure/seedwork/deferred"
+)
 
 type Result interface {
 	LastInsertId() (int64, error)
@@ -51,23 +54,16 @@ type EventSourcedQueryEvaluator interface {
 
 // Deferred
 
-type DeferredCallback[T interface{}] func(T) error
-
-type Deferred[T interface{}] interface {
-	Then(DeferredCallback[T]) error
-	Catch(DeferredCallback[error]) error
-}
-
 type DeferredResult interface {
-	Deferred[Result]
+	deferred.Deferred[Result]
 }
 
 type DeferredRows interface {
-	Then(DeferredCallback[Rows]) error
+	deferred.Deferred[Rows]
 }
 
 type DeferredRow interface {
-	Then(DeferredCallback[Row]) error
+	deferred.Deferred[Row]
 }
 
 type DeferredDbSessionExecutor interface {

grade/internal/infrastructure/seedwork/session/interfaces.go

@@ -2,14 +2,13 @@ package session
 
 import (
 	"errors"
+
+	"github.com/emacsway/grade/grade/internal/infrastructure/seedwork/deferred"
 )
 
 func NewResult(lastInsertId, rowsAffected int64) *DeferredResultImp {
 	r := &DeferredResultImp{}
-	err := r.Resolve(lastInsertId, rowsAffected)
-	if err != nil {
-		panic(err)
-	}
+	r.Resolve(lastInsertId, rowsAffected)
 	return r
 }
 
@@ -39,11 +38,11 @@ func (r ResultImp) RowsAffected() (int64, error) {
 }
 
 type DeferredResultImp struct {
-	DeferredImp[Result]
 	ResultImp
+	deferred.DeferredImp[Result]
 }
 
-func (r *DeferredResultImp) Resolve(lastInsertId, rowsAffected int64) error {
+func (r *DeferredResultImp) Resolve(lastInsertId, rowsAffected int64) {
 	r.ResultImp = ResultImp{lastInsertId, rowsAffected}
-	return r.DeferredImp.Resolve(r)
+	r.DeferredImp.Resolve(r)
 }