feat: allow to pass a slice to the preload function

errors.go

@@ -12,6 +12,10 @@ var (
 	ErrInvalidDriver = fmt.Errorf("a makroud driver is required")
 	// ErrPointerRequired is returned when given value is not a pointer.
 	ErrPointerRequired = fmt.Errorf("a pointer is required")
+	// ErrPointerOrSliceRequired is returned when given value is not a pointer or a slice.
+	ErrPointerOrSliceRequired = fmt.Errorf("a pointer or a slice is required")
+	// ErrUnknownPreloadRule is returned when given rule is unknown.
+	ErrUnknownPreloadRule = fmt.Errorf("unknown rule")
 	// ErrStructRequired is returned when given value is not a struct.
 	ErrStructRequired = fmt.Errorf("a struct is required")
 	// ErrSchemaColumnRequired is returned when we cannot find a column in current schema.

preload.go

@@ -11,23 +11,47 @@ import (
 	"github.com/ulule/makroud/reflectx"
 )
 
+type preloadRule uint8
+
+const (
+	preloadRulePointerOnly = preloadRule(iota)
+	preloadRulePointerAndSlice
+)
+
+func canPreload(rule preloadRule, dest interface{}) error {
+	switch rule {
+	case preloadRulePointerOnly:
+		if !reflectx.IsPointer(dest) {
+			return errors.Wrapf(ErrPointerRequired, "cannot preload %T", dest)
+		}
+	case preloadRulePointerAndSlice:
+		if !reflectx.IsPointer(dest) && !reflectx.IsSlice(dest) {
+			return errors.Wrapf(ErrPointerOrSliceRequired, "cannot preload %T", dest)
+		}
+	default:
+		return errors.Wrapf(ErrUnknownPreloadRule, "cannot preload with rule %v", rule)
+	}
+	return nil
+}
+
 // Preload preloads related fields.
 func Preload(ctx context.Context, driver Driver, out interface{}, handlers ...PreloadHandler) error {
-	err := preload(ctx, driver, out, handlers...)
+	err := preload(ctx, driver, preloadRulePointerAndSlice, out, handlers...)
 	if err != nil {
 		return errors.Wrap(err, "makroud: cannot execute preload")
 	}
 	return nil
 }
 
 // preload preloads related fields.
-func preload(ctx context.Context, driver Driver, dest interface{}, handlers ...PreloadHandler) error {
+func preload(ctx context.Context, driver Driver, rule preloadRule, dest interface{}, handlers ...PreloadHandler) error {
 	if driver == nil {
 		return errors.WithStack(ErrInvalidDriver)
 	}
 
-	if !reflectx.IsPointer(dest) {
-		return errors.Wrapf(ErrPointerRequired, "cannot preload %T", dest)
+	err := canPreload(rule, dest)
+	if err != nil {
+		return err
 	}
 
 	groups := getPreloadGroupOperations(handlers)
@@ -267,7 +291,7 @@ func executePreloadWalker(ctx context.Context, driver Driver,
 		err := walker.Find(operation.Parent(), func(values interface{}) error {
 			op := WithPreloadCallback(operation.Name(), operation.Callback())
 			op.unscoped = operation.Unscoped()
-			return preload(ctx, driver, values, op)
+			return preload(ctx, driver, preloadRulePointerOnly, values, op)
 		})
 		if err != nil {
 			return err