testmodels

var AuditProductMeta = drel.ModelMeta[AuditProduct]{
	Table:    "a_products",
	Columns:  []string{"id", "name", "price", "created_by", "updated_by", "created_at", "updated_at"},
	PKColumn: "id",
	HasAudit: true,
	AuditSetCreate: func(p *AuditProduct, actor string) {
		createdByPtr, updatedByPtr := p.AuditPtrs()
		*createdByPtr = actor
		*updatedByPtr = actor
	},
	AuditSetUpdate: func(p *AuditProduct, actor string) {
		_, updatedByPtr := p.AuditPtrs()
		*updatedByPtr = actor
	},
	Scan: func(row drel.Row) (*AuditProduct, error) {
		p := &AuditProduct{}
		idPtr, createdAtPtr, updatedAtPtr := p.ScanPtrs()
		createdByPtr, updatedByPtr := p.AuditPtrs()
		err := row.Scan(idPtr, &p.name, &p.price, createdByPtr, updatedByPtr, createdAtPtr, updatedAtPtr)
		if err != nil {
			return nil, err
		}
		return p, nil
	},
	Snapshot: func(p *AuditProduct) any {
		return apSnapshot{name: p.name, price: p.price}
	},
	Diff: func(p *AuditProduct, snap any) []drel.FieldChange {
		s := snap.(apSnapshot)
		var changes []drel.FieldChange
		if p.name != s.name {
			changes = append(changes, drel.FieldChange{Column: "name", Value: p.name})
		}
		if p.price != s.price {
			changes = append(changes, drel.FieldChange{Column: "price", Value: p.price})
		}
		return changes
	},
	PKValue: func(p *AuditProduct) any { return p.ID() },
	InsertColumns: func(p *AuditProduct) ([]string, []any) {
		return []string{"name", "price", "created_by", "updated_by"}, []any{p.name, p.price, p.CreatedBy(), p.UpdatedBy()}
	},
	ScanReturning: func(p *AuditProduct, row drel.Row) error {
		idPtr, createdAtPtr, updatedAtPtr := p.ScanPtrs()
		return row.Scan(idPtr, createdAtPtr, updatedAtPtr)
	},
}

var EventUserMeta = drel.ModelMeta[EventUser]{
	Table:    "event_users",
	Columns:  []string{"id", "name", "email", "created_at", "updated_at"},
	PKColumn: "id",
	Scan: func(row drel.Row) (*EventUser, error) {
		u := &EventUser{}
		idPtr, createdAtPtr, updatedAtPtr := u.ScanPtrs()
		err := row.Scan(idPtr, &u.name, &u.email, createdAtPtr, updatedAtPtr)
		if err != nil {
			return nil, err
		}
		return u, nil
	},
	Snapshot: func(u *EventUser) any {
		return eventUserSnapshot{name: u.name, email: u.email}
	},
	Diff: func(u *EventUser, snap any) []drel.FieldChange {
		s := snap.(eventUserSnapshot)
		var changes []drel.FieldChange
		if u.name != s.name {
			changes = append(changes, drel.FieldChange{Column: "name", Value: u.name})
		}
		if u.email != s.email {
			changes = append(changes, drel.FieldChange{Column: "email", Value: u.email})
		}
		return changes
	},
	PKValue: func(u *EventUser) any {
		return u.ID()
	},
	InsertColumns: func(u *EventUser) ([]string, []any) {
		return []string{"name", "email"}, []any{u.name, u.email}
	},
	ScanReturning: func(u *EventUser, row drel.Row) error {
		idPtr, createdAtPtr, updatedAtPtr := u.ScanPtrs()
		return row.Scan(idPtr, createdAtPtr, updatedAtPtr)
	},
}

var JSONDocMeta = drel.ModelMeta[JSONDoc]{
	Table:    "json_docs",
	Columns:  []string{"id", "tags", "meta", "created_at", "updated_at"},
	PKColumn: "id",
	Scan: func(row drel.Row) (*JSONDoc, error) {
		p := &JSONDoc{}
		idPtr, createdAtPtr, updatedAtPtr := p.ScanPtrs()
		err := row.Scan(idPtr, drel.JSON[[]string]{V: &p.Tags}, drel.JSON[map[string]string]{V: &p.Meta}, createdAtPtr, updatedAtPtr)
		if err != nil {
			return nil, err
		}
		return p, nil
	},
	Snapshot: func(p *JSONDoc) any { return jsonDocSnapshot{Tags: p.Tags, Meta: p.Meta} },
	Diff: func(p *JSONDoc, snap any) []drel.FieldChange {
		s := snap.(jsonDocSnapshot)
		var changes []drel.FieldChange
		if !slicesEqual(p.Tags, s.Tags) {
			changes = append(changes, drel.FieldChange{Column: "tags", Value: drel.JSON[[]string]{V: &p.Tags}})
		}
		if !mapsEqual(p.Meta, s.Meta) {
			changes = append(changes, drel.FieldChange{Column: "meta", Value: drel.JSON[map[string]string]{V: &p.Meta}})
		}
		return changes
	},
	PKValue: func(p *JSONDoc) any { return p.ID() },
	InsertColumns: func(p *JSONDoc) ([]string, []any) {
		return []string{"tags", "meta"}, []any{drel.JSON[[]string]{V: &p.Tags}, drel.JSON[map[string]string]{V: &p.Meta}}
	},
	ScanReturning: func(p *JSONDoc, row drel.Row) error {
		idPtr, createdAtPtr, updatedAtPtr := p.ScanPtrs()
		return row.Scan(idPtr, createdAtPtr, updatedAtPtr)
	},
	ColumnValue: func(p *JSONDoc, idx int) any {
		switch idx {
		case 0:
			return p.ID()
		case 1:
			return drel.JSON[[]string]{V: &p.Tags}
		case 2:
			return drel.JSON[map[string]string]{V: &p.Meta}
		case 3:
			return p.CreatedAt()
		case 4:
			return p.UpdatedAt()
		}
		return nil
	},
	NormalizeKey: func(v any) any { return drel.NormalizeIntKey(v) },
}

var ProductMeta = drel.ModelMeta[Product]{
	Table:    "products",
	Columns:  []string{"id", "name", "price", "in_stock", "created_at", "updated_at"},
	PKColumn: "id",
	Scan: func(row drel.Row) (*Product, error) {
		p := &Product{}
		err := row.Scan(&p.ID, &p.Name, &p.Price, &p.InStock, &p.CreatedAt, &p.UpdatedAt)
		if err != nil {
			return nil, err
		}
		return p, nil
	},
	Snapshot: func(p *Product) any {
		return productSnapshot{Name: p.Name, Price: p.Price, InStock: p.InStock}
	},
	Diff: func(p *Product, snap any) []drel.FieldChange {
		s := snap.(productSnapshot)
		var changes []drel.FieldChange
		if p.Name != s.Name {
			changes = append(changes, drel.FieldChange{Column: "name", Value: p.Name})
		}
		if p.Price != s.Price {
			changes = append(changes, drel.FieldChange{Column: "price", Value: p.Price})
		}
		if p.InStock != s.InStock {
			changes = append(changes, drel.FieldChange{Column: "in_stock", Value: p.InStock})
		}
		return changes
	},
	PKValue: func(p *Product) any {
		return p.ID
	},
	ColumnValue: func(p *Product, idx int) any {
		switch idx {
		case 0:
			return p.ID
		case 1:
			return p.Name
		case 2:
			return p.Price
		case 3:
			return p.InStock
		case 4:
			return p.CreatedAt
		case 5:
			return p.UpdatedAt
		}
		return nil
	},
	InsertColumns: func(p *Product) ([]string, []any) {
		return []string{"name", "price", "in_stock"}, []any{p.Name, p.Price, p.InStock}
	},
	ScanReturning: func(p *Product, row drel.Row) error {
		return row.Scan(&p.ID, &p.CreatedAt, &p.UpdatedAt)
	},
}

var Products = struct {
	ID        drel.OrderedColumn[int]
	Name      drel.StringColumn
	Price     drel.OrderedColumn[int]
	InStock   drel.BoolColumn
	CreatedAt drel.TimeColumn
	UpdatedAt drel.TimeColumn
}{
	ID:        drel.NewOrderedCol[int]("id"),
	Name:      drel.NewStringCol("name"),
	Price:     drel.NewOrderedCol[int]("price"),
	InStock:   drel.NewBoolCol("in_stock"),
	CreatedAt: drel.NewTimeCol("created_at"),
	UpdatedAt: drel.NewTimeCol("updated_at"),
}

var SoftDeleteProductMeta = drel.ModelMeta[SoftDeleteProduct]{
	Table:         "sd_products",
	Columns:       []string{"id", "name", "price", "deleted_at", "created_at", "updated_at"},
	PKColumn:      "id",
	HasSoftDelete: true,
	Filters: []drel.NamedFilter{
		{Name: "soft_delete", Clause: ast.WhereClause{
			Comparison: &ast.ComparisonNode{Column: "deleted_at", Op: ast.OpIsNull},
		}},
	},
	Scan: func(row drel.Row) (*SoftDeleteProduct, error) {
		p := &SoftDeleteProduct{}
		idPtr, createdAtPtr, updatedAtPtr := p.ScanPtrs()
		err := row.Scan(idPtr, &p.name, &p.price, p.DeletedAtPtr(), createdAtPtr, updatedAtPtr)
		if err != nil {
			return nil, err
		}
		return p, nil
	},
	Snapshot: func(p *SoftDeleteProduct) any {
		return sdProductSnapshot{name: p.name, price: p.price}
	},
	Diff: func(p *SoftDeleteProduct, snap any) []drel.FieldChange {
		s := snap.(sdProductSnapshot)
		var changes []drel.FieldChange
		if p.name != s.name {
			changes = append(changes, drel.FieldChange{Column: "name", Value: p.name})
		}
		if p.price != s.price {
			changes = append(changes, drel.FieldChange{Column: "price", Value: p.price})
		}
		return changes
	},
	PKValue: func(p *SoftDeleteProduct) any { return p.ID() },
	InsertColumns: func(p *SoftDeleteProduct) ([]string, []any) {
		return []string{"name", "price"}, []any{p.name, p.price}
	},
	ScanReturning: func(p *SoftDeleteProduct, row drel.Row) error {
		idPtr, createdAtPtr, updatedAtPtr := p.ScanPtrs()
		return row.Scan(idPtr, createdAtPtr, updatedAtPtr)
	},
}

var SoftDeleteProducts = struct {
	ID        drel.OrderedColumn[int]
	Name      drel.StringColumn
	Price     drel.OrderedColumn[int]
	DeletedAt drel.ComparableColumn[*time.Time]
}{
	ID:        drel.NewOrderedCol[int]("id"),
	Name:      drel.NewStringCol("name"),
	Price:     drel.NewOrderedCol[int]("price"),
	DeletedAt: drel.NewComparableCol[*time.Time]("deleted_at"),
}

var VersionedProductMeta = drel.ModelMeta[VersionedProduct]{
	Table:        "v_products",
	Columns:      []string{"id", "name", "price", "version", "created_at", "updated_at"},
	PKColumn:     "id",
	HasVersioned: true,
	VersionValue: func(p *VersionedProduct) int { return p.Version() },
	SetVersion:   func(p *VersionedProduct, v int) { *p.VersionPtr() = v },
	Scan: func(row drel.Row) (*VersionedProduct, error) {
		p := &VersionedProduct{}
		idPtr, createdAtPtr, updatedAtPtr := p.ScanPtrs()
		err := row.Scan(idPtr, &p.name, &p.price, p.VersionPtr(), createdAtPtr, updatedAtPtr)
		if err != nil {
			return nil, err
		}
		return p, nil
	},
	Snapshot: func(p *VersionedProduct) any {
		return vpSnapshot{name: p.name, price: p.price}
	},
	Diff: func(p *VersionedProduct, snap any) []drel.FieldChange {
		s := snap.(vpSnapshot)
		var changes []drel.FieldChange
		if p.name != s.name {
			changes = append(changes, drel.FieldChange{Column: "name", Value: p.name})
		}
		if p.price != s.price {
			changes = append(changes, drel.FieldChange{Column: "price", Value: p.price})
		}
		return changes
	},
	PKValue: func(p *VersionedProduct) any { return p.ID() },
	InsertColumns: func(p *VersionedProduct) ([]string, []any) {
		return []string{"name", "price"}, []any{p.name, p.price}
	},
	ScanReturning: func(p *VersionedProduct, row drel.Row) error {
		idPtr, createdAtPtr, updatedAtPtr := p.ScanPtrs()
		return row.Scan(idPtr, createdAtPtr, updatedAtPtr)
	},
}