refactor:

- aggregator: Support hooks.
- callback: Enable field hook by default, support before* and after* hooks.
- collection: Add fields field to Collection struct and pass it to finder, creator, updater, deleter, and aggregator objects.
- field: Add field package to store metadata of the struct bound to the Collection.
- hook: Refactor field hook, remove other hooks.
- operation: Add before* and after* hook types.
- model: Add mongox tag to ID field in the Model struct.

Author: chenmingyong0423

aggregator/aggregator.go

@@ -16,7 +16,12 @@ package aggregator
 
 import (
 	"context"
+	"time"
 
+	"github.com/chenmingyong0423/go-mongox/v2/operation"
+
+	"github.com/chenmingyong0423/go-mongox/v2/callback"
+	"github.com/chenmingyong0423/go-mongox/v2/field"
 	"go.mongodb.org/mongo-driver/v2/mongo"
 	"go.mongodb.org/mongo-driver/v2/mongo/options"
 )
@@ -32,20 +37,52 @@ var _ IAggregator[any] = (*Aggregator[any])(nil)
 type Aggregator[T any] struct {
 	collection *mongo.Collection
 	pipeline   any
+
+	dbCallbacks *callback.Callback
+	fields      []*field.Filed
+
+	modelHook   any
+	beforeHooks []beforeHookFn
+	afterHooks  []afterHookFn
 }
 
-func NewAggregator[T any](collection *mongo.Collection) *Aggregator[T] {
+func NewAggregator[T any](collection *mongo.Collection, dbCallbacks *callback.Callback, fields []*field.Filed) *Aggregator[T] {
 	return &Aggregator[T]{
-		collection: collection,
+		collection:  collection,
+		dbCallbacks: dbCallbacks,
+		fields:      fields,
 	}
 }
 
+func (a *Aggregator[T]) ModelHook(modelHook any) *Aggregator[T] {
+	a.modelHook = modelHook
+	return a
+}
+func (a *Aggregator[T]) RegisterBeforeHooks(hooks ...beforeHookFn) *Aggregator[T] {
+	a.beforeHooks = append(a.beforeHooks, hooks...)
+	return a
+}
+
+func (a *Aggregator[T]) RegisterAfterHooks(hooks ...afterHookFn) *Aggregator[T] {
+	a.afterHooks = append(a.afterHooks, hooks...)
+	return a
+}
+
 func (a *Aggregator[T]) Pipeline(pipeline any) *Aggregator[T] {
 	a.pipeline = pipeline
 	return a
 }
 
 func (a *Aggregator[T]) Aggregate(ctx context.Context, opts ...options.Lister[options.AggregateOptions]) ([]*T, error) {
+	currentTime := time.Now()
+	globalOpContext := operation.NewOpContext(a.collection, operation.WithPipeline(a.pipeline), operation.WithMongoOptions(opts), operation.WithModelHook(a.modelHook), operation.WithStartTime(currentTime), operation.WithFields(a.fields))
+	opContext := NewOpContext(a.collection, a.pipeline, WithMongoOptions(opts), WithModelHook(a.modelHook), WithStartTime(currentTime), WithFields(a.fields))
+
+	err := a.preActionHandler(ctx, globalOpContext, opContext, operation.OpTypeBeforeInsert)
+	if err != nil {
+		return nil, err
+	}
+
 	cursor, err := a.collection.Aggregate(ctx, a.pipeline, opts...)
 	if err != nil {
 		return nil, err
@@ -57,12 +94,30 @@ func (a *Aggregator[T]) Aggregate(ctx context.Context, opts ...options.Lister[op
 	if err != nil {
 		return nil, err
 	}
+
+	globalOpContext.Result = cursor
+	opContext.Result = cursor
+	err = a.postActionHandler(ctx, globalOpContext, opContext, operation.OpTypeAfterInsert)
+	if err != nil {
+		return nil, err
+	}
+
 	return result, nil
 }
 
 // AggregateWithParse is used to parse the result of the aggregation
 // result must be a pointer to a slice
 func (a *Aggregator[T]) AggregateWithParse(ctx context.Context, result any, opts ...options.Lister[options.AggregateOptions]) error {
+
+	currentTime := time.Now()
+	globalOpContext := operation.NewOpContext(a.collection, operation.WithPipeline(a.pipeline), operation.WithMongoOptions(opts), operation.WithModelHook(a.modelHook), operation.WithStartTime(currentTime), operation.WithFields(a.fields))
+	opContext := NewOpContext(a.collection, a.pipeline, WithMongoOptions(opts), WithModelHook(a.modelHook), WithStartTime(currentTime), WithFields(a.fields))
+
+	err := a.preActionHandler(ctx, globalOpContext, opContext, operation.OpTypeBeforeInsert)
+	if err != nil {
+		return err
+	}
+
 	cursor, err := a.collection.Aggregate(ctx, a.pipeline, opts...)
 	if err != nil {
 		return err
@@ -72,5 +127,41 @@ func (a *Aggregator[T]) AggregateWithParse(ctx context.Context, result any, opts
 	if err != nil {
 		return err
 	}
+
+	globalOpContext.Result = cursor
+	opContext.Result = cursor
+	err = a.postActionHandler(ctx, globalOpContext, opContext, operation.OpTypeAfterInsert)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (a *Aggregator[T]) preActionHandler(ctx context.Context, globalOpContext *operation.OpContext, opContext *OpContext, opType operation.OpType) error {
+	err := a.dbCallbacks.Execute(ctx, globalOpContext, opType)
+	if err != nil {
+		return err
+	}
+	for _, beforeHook := range a.beforeHooks {
+		err = beforeHook(ctx, opContext)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (a *Aggregator[T]) postActionHandler(ctx context.Context, globalOpContext *operation.OpContext, opContext *OpContext, opType operation.OpType) error {
+	err := a.dbCallbacks.Execute(ctx, globalOpContext, opType)
+	if err != nil {
+		return err
+	}
+	for _, afterHook := range a.afterHooks {
+		err = afterHook(ctx, opContext)
+		if err != nil {
+			return err
+		}
+	}
 	return nil
 }

aggregator/aggregator_e2e_test.go

@@ -20,6 +20,9 @@ import (
 	"context"
 	"testing"
 
+	"github.com/chenmingyong0423/go-mongox/v2/callback"
+	"github.com/chenmingyong0423/go-mongox/v2/field"
+
 	"github.com/chenmingyong0423/go-mongox/v2/bsonx"
 	"github.com/stretchr/testify/require"
 
@@ -47,14 +50,14 @@ func getCollection(t *testing.T) *mongo.Collection {
 func TestAggregator_e2e_New(t *testing.T) {
 	collection := getCollection(t)
 
-	result := NewAggregator[TestUser](collection)
+	result := NewAggregator[TestUser](collection, nil, nil)
 	require.NotNil(t, result, "Expected non-nil Aggregator")
 	require.Equal(t, collection, result.collection, "Expected collection field to be initialized correctly")
 }
 
 func TestAggregator_e2e_Aggregation(t *testing.T) {
 	collection := getCollection(t)
-	aggregator := NewAggregator[TestUser](collection)
+	aggregator := NewAggregator[TestUser](collection, callback.InitializeCallbacks(), field.ParseFields(TestUser{}))
 
 	testCases := []struct {
 		name   string
@@ -223,7 +226,7 @@ func TestAggregator_e2e_Aggregation(t *testing.T) {
 
 func TestAggregator_e2e_AggregateWithParse(t *testing.T) {
 	collection := getCollection(t)
-	aggregator := NewAggregator[TestUser](collection)
+	aggregator := NewAggregator[TestUser](collection, callback.InitializeCallbacks(), field.ParseFields(TestUser{}))
 
 	type User struct {
 		Id           string `bson:"_id"`

aggregator/aggregator_test.go

@@ -71,7 +71,7 @@ type UserName struct {
 
 func TestAggregator_New(t *testing.T) {
 	mongoCollection := &mongo.Collection{}
-	aggregator := NewAggregator[any](mongoCollection)
+	aggregator := NewAggregator[any](mongoCollection, nil, nil)
 
 	assert.NotNil(t, aggregator)
 	assert.Equal(t, mongoCollection, aggregator.collection)

aggregator/types.go

@@ -0,0 +1,91 @@
+// Generated by [optioner] command-line tool; DO NOT EDIT
+// If you have any questions, please create issues and submit contributions at:
+// https://github.com/chenmingyong0423/go-optioner
+
+// Copyright 2025 chenmingyong0423
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package aggregator
+
+import (
+	"context"
+	"time"
+
+	"github.com/chenmingyong0423/go-mongox/v2/field"
+	"go.mongodb.org/mongo-driver/v2/mongo"
+)
+
+//go:generate optioner -type OpContext -output types.go -mode append
+type OpContext struct {
+	Col      *mongo.Collection `opt:"-"`
+	Pipeline any               `opt:"-"`
+
+	Fields []*field.Filed
+
+	MongoOptions any
+	ModelHook    any
+	StartTime    time.Time
+
+	Result any
+}
+
+type (
+	beforeHookFn func(ctx context.Context, opContext *OpContext, opts ...any) error
+	afterHookFn  func(ctx context.Context, opContext *OpContext, opts ...any) error
+)
+
+type OpContextOption func(*OpContext)
+
+func NewOpContext(col *mongo.Collection, pipeline any, opts ...OpContextOption) *OpContext {
+	opContext := &OpContext{
+		Col:      col,
+		Pipeline: pipeline,
+	}
+
+	for _, opt := range opts {
+		opt(opContext)
+	}
+
+	return opContext
+}
+
+func WithFields(fields []*field.Filed) OpContextOption {
+	return func(opContext *OpContext) {
+		opContext.Fields = fields
+	}
+}
+
+func WithMongoOptions(mongoOptions any) OpContextOption {
+	return func(opContext *OpContext) {
+		opContext.MongoOptions = mongoOptions
+	}
+}
+
+func WithModelHook(modelHook any) OpContextOption {
+	return func(opContext *OpContext) {
+		opContext.ModelHook = modelHook
+	}
+}
+
+func WithStartTime(startTime time.Time) OpContextOption {
+	return func(opContext *OpContext) {
+		opContext.StartTime = startTime
+	}
+}
+
+func WithResult(result any) OpContextOption {
+	return func(opContext *OpContext) {
+		opContext.Result = result
+	}
+}

callback/callback.go

@@ -17,23 +17,46 @@ package callback
 import (
 	"context"
 
+	"github.com/chenmingyong0423/go-mongox/v2/internal/hook/field"
+
 	"github.com/chenmingyong0423/go-mongox/v2/operation"
 )
 
 type CbFn func(ctx context.Context, opCtx *operation.OpContext, opts ...any) error
 
 func InitializeCallbacks() *Callback {
 	return &Callback{
-		beforeInsert: make([]callbackHandler, 0),
-		afterInsert:  make([]callbackHandler, 0),
-		beforeUpdate: make([]callbackHandler, 0),
+		beforeInsert: []callbackHandler{
+			{
+				name: "mongox:fieds",
+				fn: func(ctx context.Context, opCtx *operation.OpContext, opts ...any) error {
+					return field.Execute(ctx, opCtx, operation.OpTypeBeforeInsert, opts...)
+				},
+			},
+		},
+		afterInsert: make([]callbackHandler, 0),
+		beforeUpdate: []callbackHandler{
+			{
+				name: "mongox:fieds",
+				fn: func(ctx context.Context, opCtx *operation.OpContext, opts ...any) error {
+					return field.Execute(ctx, opCtx, operation.OpTypeBeforeUpdate, opts...)
+				},
+			},
+		},
 		afterUpdate:  make([]callbackHandler, 0),
 		beforeDelete: make([]callbackHandler, 0),
 		afterDelete:  make([]callbackHandler, 0),
-		beforeUpsert: make([]callbackHandler, 0),
-		afterUpsert:  make([]callbackHandler, 0),
-		beforeFind:   make([]callbackHandler, 0),
-		afterFind:    make([]callbackHandler, 0),
+		beforeUpsert: []callbackHandler{
+			{
+				name: "mongox:fieds",
+				fn: func(ctx context.Context, opCtx *operation.OpContext, opts ...any) error {
+					return field.Execute(ctx, opCtx, operation.OpTypeBeforeUpsert, opts...)
+				},
+			},
+		},
+		afterUpsert: make([]callbackHandler, 0),
+		beforeFind:  make([]callbackHandler, 0),
+		afterFind:   make([]callbackHandler, 0),
 	}
 }
 

collection.go

@@ -19,6 +19,7 @@ import (
 	"github.com/chenmingyong0423/go-mongox/v2/callback"
 	"github.com/chenmingyong0423/go-mongox/v2/creator"
 	"github.com/chenmingyong0423/go-mongox/v2/deleter"
+	"github.com/chenmingyong0423/go-mongox/v2/field"
 	"github.com/chenmingyong0423/go-mongox/v2/finder"
 	"github.com/chenmingyong0423/go-mongox/v2/updater"
 	"go.mongodb.org/mongo-driver/v2/mongo"
@@ -27,8 +28,9 @@ import (
 func NewCollection[T any](db *Database, collection string) *Collection[T] {
 	return &Collection[T]{
 		db:         db,
-		collection: db.database().Collection(collection),
+		collection: db.Database().Collection(collection),
 		callbacks:  db.callbacks,
+		fields:     field.ParseFields(new(T)),
 	}
 }
 
@@ -37,25 +39,27 @@ type Collection[T any] struct {
 	collection *mongo.Collection
 	// callbacks inherited from database
 	callbacks *callback.Callback
+
+	fields []*field.Filed
 }
 
 func (c *Collection[T]) Finder() *finder.Finder[T] {
-	return finder.NewFinder[T](c.collection, c.callbacks)
+	return finder.NewFinder[T](c.collection, c.callbacks, c.fields)
 }
 
 func (c *Collection[T]) Creator() *creator.Creator[T] {
-	return creator.NewCreator[T](c.collection, c.callbacks)
+	return creator.NewCreator[T](c.collection, c.callbacks, c.fields)
 }
 
 func (c *Collection[T]) Updater() *updater.Updater[T] {
-	return updater.NewUpdater[T](c.collection, c.callbacks)
+	return updater.NewUpdater[T](c.collection, c.callbacks, c.fields)
 }
 
 func (c *Collection[T]) Deleter() *deleter.Deleter[T] {
-	return deleter.NewDeleter[T](c.collection, c.callbacks)
+	return deleter.NewDeleter[T](c.collection, c.callbacks, c.fields)
 }
 func (c *Collection[T]) Aggregator() *aggregator.Aggregator[T] {
-	return aggregator.NewAggregator[T](c.collection)
+	return aggregator.NewAggregator[T](c.collection, c.callbacks, c.fields)
 }
 
 func (c *Collection[T]) Collection() *mongo.Collection {