@an5/orm 1.0.8 → 1.1.0

package/dist/generator/src/golang-generator.js

@@ -0,0 +1,1229 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GolangGenerator = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const types_1 = require("./types");
+const type_kinds_1 = require("./type-kinds");
+class GolangGenerator {
+    constructor(outputDir) {
+        this.outputDir = outputDir;
+        if (!fs_1.default.existsSync(this.outputDir)) {
+            fs_1.default.mkdirSync(this.outputDir, { recursive: true });
+        }
+    }
+    generate(models) {
+        // Remembered for the type mapping: `TIMESTAMP` is a rowversion on SQL Server and
+        // a point in time on every other provider.
+        this.provider = models[0]?.provider;
+        // 1. Generate per-model files like dotnet (<Model>.go) -
+        //    entity struct + that model's WhereInput/OrderByInput/Args types.
+        //    Same Go package, so no re-export shim is needed.
+        for (const model of models) {
+            this.generateModelFile(model);
+        }
+        // 2. Generate client.go  - ORM DbContext + TableClient with full type-safe API
+        this.generateClientGo(models);
+        // 3. Generate config.go  - connection string helpers
+        this.generateConfigGo();
+        // 4. Generate metadata.go - model-to-table mapping
+        this.generateMetadataGo(models);
+    }
+    // ─── Type mapping ──────────────────────────────────────────────────────────
+    /**
+     * The Go type for a field.
+     *
+     * Driven by the declared type, not the generated TypeScript one: that collapses
+     * `INT`, `FLOAT` and `DECIMAL` into `number`, which matched none of the branches
+     * below and made every numeric column a `string`.
+     */
+    mapGoType(field, isOptional) {
+        const kind = (0, type_kinds_1.fieldKind)(field, this.provider);
+        let goType;
+        switch (kind) {
+            case 'int':
+                goType = 'int';
+                break;
+            case 'bigint':
+                goType = 'int64';
+                break;
+            case 'float':
+                goType = 'float64';
+                break;
+            case 'bool':
+                goType = 'bool';
+                break;
+            case 'date':
+                goType = 'time.Time';
+                break;
+            case 'bytes':
+                goType = '[]byte';
+                break;
+            case 'vector':
+                goType = '[]float32';
+                break;
+            // A JSON column holds whatever the row put in it; string keeps any value
+            // representable, and json.RawMessage would need the import everywhere.
+            case 'json':
+                goType = 'string';
+                break;
+            default:
+                goType = 'string';
+                break;
+        }
+        if (isOptional && goType !== '[]byte') {
+            goType = '*' + goType;
+        }
+        return goType;
+    }
+    // ─── <Model>.go (per-model file, like dotnet `<Model>.cs`) ────────────────
+    generateModelFile(model) {
+        // Single-model file: entity struct + its WhereInput/OrderByInput/Args
+        // types. All files share `package an5client`, so callers keep using
+        // `an5client.User` etc. regardless of file layout.
+        // NOTE: Go rejects unused imports, so `time` is only imported when a
+        // field actually maps to `time.Time`.
+        const needsTime = model.fields.some(f => this.mapGoType(f, false).includes('time.Time'));
+        let content = `// Code generated by an5ORM. DO NOT EDIT.
+package an5client
+
+`;
+        if (needsTime) {
+            content += `import (
+\t"time"
+)
+
+`;
+        }
+        content += this.generateModelStruct(model);
+        content += this.generateModelOrmTypes(model);
+        fs_1.default.writeFileSync(path_1.default.join(this.outputDir, `${model.name}.go`), content);
+    }
+    generateModelStruct(model) {
+        let content = '';
+        if (model.description) {
+            content += `// ${model.name} - ${model.description}\n`;
+        }
+        content += `type ${model.name} struct {\n`;
+        for (const field of model.fields) {
+            const goType = this.mapGoType(field, field.isOptional);
+            const jsonTag = field.isOptional ? `${this.toCamelCase(field.name)},omitempty` : this.toCamelCase(field.name);
+            const dbTag = this.toSnakeCase(field.name);
+            content += `\t${this.capitalize(field.name)} ${goType} \`json:"${jsonTag}" db:"${dbTag}"\`\n`;
+        }
+        if (model.relations.length > 0) {
+            content += `\n\t// Relations\n`;
+            for (const rel of model.relations) {
+                const relType = rel.isArray ? `[]${rel.type}` : `*${rel.type}`;
+                content += `\t${this.capitalize(rel.name)} ${relType} \`json:"${this.toCamelCase(rel.name)},omitempty"\`\n`;
+            }
+        }
+        content += `}\n\n`;
+        return content;
+    }
+    // ─── metadata.go ───────────────────────────────────────────────────────────
+    generateMetadataGo(models) {
+        let content = `// Code generated by an5ORM. DO NOT EDIT.
+package an5client
+
+// ModelToTable maps model name variations to fully-qualified SQL table names.
+var ModelToTable = map[string]string{
+`;
+        for (const model of models) {
+            const fullTable = (0, types_1.bracketedTableName)(model);
+            for (const prop of this.getAllPropertyVariations(model.name)) {
+                content += `\t"${prop}": "${fullTable}",\n`;
+            }
+        }
+        content += `}\n\n`;
+        content += `// ModelPrimaryKeys maps model names to their primary key column name.\nvar ModelPrimaryKeys = map[string]string{\n`;
+        for (const model of models) {
+            const idField = model.fields.find(f => f.isId) ?? model.fields[0];
+            const pkCol = idField ? this.toSnakeCase(idField.name) : 'id';
+            for (const prop of this.getAllPropertyVariations(model.name)) {
+                content += `\t"${prop}": "${pkCol}",\n`;
+            }
+        }
+        content += `}\n`;
+        fs_1.default.writeFileSync(path_1.default.join(this.outputDir, 'metadata.go'), content);
+    }
+    // ─── config.go ─────────────────────────────────────────────────────────────
+    generateConfigGo() {
+        const content = `// Code generated by an5ORM. DO NOT EDIT.
+package an5client
+
+import (
+\t"os"
+)
+
+// An5Config holds database configuration options for Golang client.
+type An5Config struct {
+\tConnectionString string
+\tDriverName       string
+}
+
+// GetDefaultConnectionString retrieves DATABASE_URL or fallback string.
+func GetDefaultConnectionString() string {
+\tconnStr := os.Getenv("DATABASE_URL")
+\tif connStr == "" {
+\t\tconnStr = "Server=localhost;Database=master;Trusted_Connection=True;TrustServerCertificate=True;"
+\t}
+\treturn connStr
+}
+`;
+        fs_1.default.writeFileSync(path_1.default.join(this.outputDir, 'config.go'), content);
+    }
+    // ─── client.go ─────────────────────────────────────────────────────────────
+    generateClientGo(models) {
+        let content = this.generateClientHeader(models);
+        content += this.generateBaseOrmTypes();
+        content += this.generateDbContext(models);
+        content += this.generateTableClientStruct();
+        content += this.generateQueryAndScan();
+        content += this.generateWhereBuilder();
+        content += this.generateCrudMethods();
+        content += this.generateVectorSearch();
+        content += this.generateHelpers();
+        // NOTE: per-model ORM types live in each `<Model>.go` file.
+        fs_1.default.writeFileSync(path_1.default.join(this.outputDir, 'client.go'), content);
+    }
+    generateClientHeader(models) {
+        return `// Code generated by an5ORM. DO NOT EDIT.
+package an5client
+
+import (
+\t"context"
+\t"database/sql"
+\t"encoding/json"
+\t"fmt"
+\t"math"
+\t"reflect"
+\t"sort"
+\t"strings"
+\t"time"
+)
+
+`;
+    }
+    // ─── Base ORM types (shared filters, sort order) ───────────────────────────
+    generateBaseOrmTypes() {
+        return `// SortOrder represents ascending or descending sort direction.
+type SortOrder string
+
+const (
+\tSortOrderAsc  SortOrder = "ASC"
+\tSortOrderDesc SortOrder = "DESC"
+)
+
+// StringFilter provides type-safe string field filtering options.
+type StringFilter struct {
+\tEquals     *string
+\tNot        *string
+\tIn         []string
+\tNotIn      []string
+\tContains   *string
+\tStartsWith *string
+\tEndsWith   *string
+\tGt         *string
+\tGte        *string
+\tLt         *string
+\tLte        *string
+}
+
+// NumberFilter provides type-safe numeric field filtering options.
+type NumberFilter struct {
+\tEquals *float64
+\tNot    *float64
+\tIn     []float64
+\tNotIn  []float64
+\tGt     *float64
+\tGte    *float64
+\tLt     *float64
+\tLte    *float64
+}
+
+// IntFilter provides type-safe integer field filtering options.
+type IntFilter struct {
+\tEquals *int
+\tNot    *int
+\tIn     []int
+\tNotIn  []int
+\tGt     *int
+\tGte    *int
+\tLt     *int
+\tLte    *int
+}
+
+// BoolFilter provides type-safe boolean field filtering options.
+type BoolFilter struct {
+\tEquals *bool
+}
+
+// DateTimeFilter provides type-safe datetime field filtering options.
+type DateTimeFilter struct {
+\tEquals *time.Time
+\tNot    *time.Time
+\tIn     []time.Time
+\tNotIn  []time.Time
+\tGt     *time.Time
+\tGte    *time.Time
+\tLt     *time.Time
+\tLte    *time.Time
+}
+
+// Dialect identifies the database engine in use.
+type Dialect string
+
+const (
+\tDialectMssql    Dialect = "mssql"
+\tDialectPostgres Dialect = "postgres"
+\tDialectSqlite   Dialect = "sqlite"
+)
+
+// detectDialect infers dialect from a connection string.
+func detectDialect(connStr string) Dialect {
+\tl := strings.ToLower(strings.TrimSpace(connStr))
+\tif strings.HasPrefix(l, "postgres://") || strings.HasPrefix(l, "postgresql://") || strings.Contains(l, "port=5432") {
+\t\treturn DialectPostgres
+\t}
+\tif strings.HasPrefix(l, "sqlite://") || strings.HasPrefix(l, "sqlite:") || strings.HasPrefix(l, "file:") || strings.HasSuffix(l, ".db") || strings.HasSuffix(l, ".sqlite") || strings.HasSuffix(l, ".sqlite3") || l == ":memory:" {
+\t\treturn DialectSqlite
+\t}
+\treturn DialectMssql
+}
+
+// Pointer helpers
+func StringPtr(s string) *string   { return &s }
+func IntPtr(i int) *int            { return &i }
+func Int64Ptr(i int64) *int64      { return &i }
+func Float64Ptr(f float64) *float64 { return &f }
+func BoolPtr(b bool) *bool         { return &b }
+func SortOrderPtr(s SortOrder) *SortOrder { return &s }
+
+`;
+    }
+    // ─── An5DbContext ──────────────────────────────────────────────────────────
+    generateDbContext(models) {
+        let content = `// An5DbContext represents the main ORM database context.\ntype An5DbContext struct {\n\tDB      *sql.DB\n\tDialect Dialect\n`;
+        for (const model of models) {
+            const name = this.capitalize(model.name);
+            content += `\t${name}s *TableClient[${model.name}]\n`;
+            content += `\t${name}  *TableClient[${model.name}]\n`;
+        }
+        content += `}
+
+// NewAn5DbContext initializes the ORM context (defaults to MSSQL dialect).
+func NewAn5DbContext(db *sql.DB) *An5DbContext {
+\treturn NewAn5DbContextWithConnStr(db, "")
+}
+
+// NewAn5DbContextWithConnStr initializes the ORM context with dialect detection.
+func NewAn5DbContextWithConnStr(db *sql.DB, connStr string) *An5DbContext {
+\td := detectDialect(connStr)
+\tctx := &An5DbContext{DB: db, Dialect: d}
+`;
+        for (const model of models) {
+            const name = this.capitalize(model.name);
+            content += `\tclient${name} := NewTableClient[${model.name}](db, "${(0, types_1.dottedTableName)(model)}", d)\n`;
+            content += `\tctx.${name}s = client${name}\n`;
+            content += `\tctx.${name}  = client${name}\n`;
+        }
+        content += `\treturn ctx\n}\n\n`;
+        return content;
+    }
+    // ─── TableClient struct ────────────────────────────────────────────────────
+    generateTableClientStruct() {
+        return `// TableClient provides generic type-safe ORM operations for model T.
+type TableClient[T any] struct {
+\tDB        *sql.DB
+\tDialect   Dialect
+\tTableName string
+}
+
+// NewTableClient creates a typed table client.
+func NewTableClient[T any](db *sql.DB, tableName string, dialect Dialect) *TableClient[T] {
+\treturn &TableClient[T]{
+\t\tDB:        db,
+\t\tDialect:   dialect,
+\t\tTableName: tableName,
+\t}
+}
+
+// quoteName quotes a column/identifier for the dialect.
+func (c *TableClient[T]) quoteName(name string) string {
+\tif c.Dialect == DialectPostgres || c.Dialect == DialectSqlite {
+\t\treturn \`"\` + strings.ReplaceAll(name, \`"\`, \`""\`) + \`"\`
+\t}
+\treturn "[" + strings.ReplaceAll(name, "]", "]]") + "]"
+}
+
+// quoteTable quotes a schema.table name for the dialect.
+func (c *TableClient[T]) quoteTable() string {
+\tparts := strings.Split(c.TableName, ".")
+\tquoted := make([]string, len(parts))
+\tfor i, p := range parts {
+\t\tquoted[i] = c.quoteName(p)
+\t}
+\treturn strings.Join(quoted, ".")
+}
+
+// ph returns a positional placeholder - ? for MSSQL, $N for Postgres.
+func (c *TableClient[T]) ph(n int) string {
+\tif c.Dialect == DialectPostgres {
+\t\treturn fmt.Sprintf("$%d", n)
+\t}
+\treturn "?"
+}
+
+`;
+    }
+    // ─── queryAndScan ──────────────────────────────────────────────────────────
+    generateQueryAndScan() {
+        return `// queryAndScan executes a raw SELECT and scans results into []T via db struct tags.
+func (c *TableClient[T]) queryAndScan(ctx context.Context, query string, args ...interface{}) ([]T, error) {
+\trows, err := c.DB.QueryContext(ctx, query, args...)
+\tif err != nil {
+\t\treturn nil, err
+\t}
+\tdefer rows.Close()
+
+\tvar results []T
+\tcols, err := rows.Columns()
+\tif err != nil {
+\t\treturn nil, err
+\t}
+
+\tfor rows.Next() {
+\t\tvar item T
+\t\tval := reflect.ValueOf(&item).Elem()
+\t\tscanArgs := make([]interface{}, len(cols))
+\t\tfor i, colName := range cols {
+\t\t\tfieldVal := findFieldByDbTag(val, colName)
+\t\t\tif fieldVal.IsValid() && fieldVal.CanSet() {
+\t\t\t\tscanArgs[i] = fieldVal.Addr().Interface()
+\t\t\t} else {
+\t\t\t\tvar unused interface{}
+\t\t\t\tscanArgs[i] = &unused
+\t\t\t}
+\t\t}
+\t\tif err := rows.Scan(scanArgs...); err != nil {
+\t\t\treturn nil, err
+\t\t}
+\t\tresults = append(results, item)
+\t}
+\tif err := rows.Err(); err != nil {
+\t\treturn nil, err
+\t}
+\treturn results, nil
+}
+
+`;
+    }
+    // ─── WHERE builder ─────────────────────────────────────────────────────────
+    generateWhereBuilder() {
+        return `// whereResult holds the SQL WHERE clause and its bound arguments.
+type whereResult struct {
+\tClause string
+\tArgs   []interface{}
+}
+
+// buildStringFilter converts a StringFilter to SQL fragments.
+func buildStringFilter(col string, f *StringFilter, args []interface{}, ph func(int) string) (string, []interface{}) {
+\tif f == nil {
+\t\treturn "", args
+\t}
+\tvar parts []string
+\tif f.Equals != nil {
+\t\targs = append(args, *f.Equals)
+\t\tparts = append(parts, col+" = "+ph(len(args)))
+\t}
+\tif f.Not != nil {
+\t\targs = append(args, *f.Not)
+\t\tparts = append(parts, col+" <> "+ph(len(args)))
+\t}
+\tif f.Contains != nil {
+\t\targs = append(args, "%"+*f.Contains+"%")
+\t\tparts = append(parts, col+" LIKE "+ph(len(args)))
+\t}
+\tif f.StartsWith != nil {
+\t\targs = append(args, *f.StartsWith+"%")
+\t\tparts = append(parts, col+" LIKE "+ph(len(args)))
+\t}
+\tif f.EndsWith != nil {
+\t\targs = append(args, "%"+*f.EndsWith)
+\t\tparts = append(parts, col+" LIKE "+ph(len(args)))
+\t}
+\tif f.Gt != nil {
+\t\targs = append(args, *f.Gt)
+\t\tparts = append(parts, col+" > "+ph(len(args)))
+\t}
+\tif f.Gte != nil {
+\t\targs = append(args, *f.Gte)
+\t\tparts = append(parts, col+" >= "+ph(len(args)))
+\t}
+\tif f.Lt != nil {
+\t\targs = append(args, *f.Lt)
+\t\tparts = append(parts, col+" < "+ph(len(args)))
+\t}
+\tif f.Lte != nil {
+\t\targs = append(args, *f.Lte)
+\t\tparts = append(parts, col+" <= "+ph(len(args)))
+\t}
+\tif len(f.In) > 0 {
+\t\tphs := make([]string, len(f.In))
+\t\tfor i, v := range f.In {
+\t\t\targs = append(args, v)
+\t\t\tphs[i] = ph(len(args))
+\t\t}
+\t\tparts = append(parts, col+" IN ("+strings.Join(phs, ", ")+")")
+\t}
+\treturn strings.Join(parts, " AND "), args
+}
+
+// buildNumberFilter converts a NumberFilter to SQL fragments.
+func buildNumberFilter(col string, f *NumberFilter, args []interface{}, ph func(int) string) (string, []interface{}) {
+\tif f == nil {
+\t\treturn "", args
+\t}
+\tvar parts []string
+\tif f.Equals != nil { args = append(args, *f.Equals); parts = append(parts, col+" = "+ph(len(args))) }
+\tif f.Not != nil    { args = append(args, *f.Not);    parts = append(parts, col+" <> "+ph(len(args))) }
+\tif f.Gt != nil     { args = append(args, *f.Gt);     parts = append(parts, col+" > "+ph(len(args))) }
+\tif f.Gte != nil    { args = append(args, *f.Gte);    parts = append(parts, col+" >= "+ph(len(args))) }
+\tif f.Lt != nil     { args = append(args, *f.Lt);     parts = append(parts, col+" < "+ph(len(args))) }
+\tif f.Lte != nil    { args = append(args, *f.Lte);    parts = append(parts, col+" <= "+ph(len(args))) }
+\tif len(f.In) > 0 {
+\t\tphs := make([]string, len(f.In))
+\t\tfor i, v := range f.In { args = append(args, v); phs[i] = ph(len(args)) }
+\t\tparts = append(parts, col+" IN ("+strings.Join(phs, ", ")+")")
+\t}
+\treturn strings.Join(parts, " AND "), args
+}
+
+// buildIntFilter converts an IntFilter to SQL fragments.
+func buildIntFilter(col string, f *IntFilter, args []interface{}, ph func(int) string) (string, []interface{}) {
+\tif f == nil {
+\t\treturn "", args
+\t}
+\tvar parts []string
+\tif f.Equals != nil { args = append(args, *f.Equals); parts = append(parts, col+" = "+ph(len(args))) }
+\tif f.Not != nil    { args = append(args, *f.Not);    parts = append(parts, col+" <> "+ph(len(args))) }
+\tif f.Gt != nil     { args = append(args, *f.Gt);     parts = append(parts, col+" > "+ph(len(args))) }
+\tif f.Gte != nil    { args = append(args, *f.Gte);    parts = append(parts, col+" >= "+ph(len(args))) }
+\tif f.Lt != nil     { args = append(args, *f.Lt);     parts = append(parts, col+" < "+ph(len(args))) }
+\tif f.Lte != nil    { args = append(args, *f.Lte);    parts = append(parts, col+" <= "+ph(len(args))) }
+\tif len(f.In) > 0 {
+\t\tphs := make([]string, len(f.In))
+\t\tfor i, v := range f.In { args = append(args, v); phs[i] = ph(len(args)) }
+\t\tparts = append(parts, col+" IN ("+strings.Join(phs, ", ")+")")
+\t}
+\treturn strings.Join(parts, " AND "), args
+}
+
+// buildDateTimeFilter converts a DateTimeFilter to SQL fragments.
+func buildDateTimeFilter(col string, f *DateTimeFilter, args []interface{}, ph func(int) string) (string, []interface{}) {
+\tif f == nil {
+\t\treturn "", args
+\t}
+\tvar parts []string
+\tif f.Equals != nil { args = append(args, *f.Equals); parts = append(parts, col+" = "+ph(len(args))) }
+\tif f.Not != nil    { args = append(args, *f.Not);    parts = append(parts, col+" <> "+ph(len(args))) }
+\tif f.Gt != nil     { args = append(args, *f.Gt);     parts = append(parts, col+" > "+ph(len(args))) }
+\tif f.Gte != nil    { args = append(args, *f.Gte);    parts = append(parts, col+" >= "+ph(len(args))) }
+\tif f.Lt != nil     { args = append(args, *f.Lt);     parts = append(parts, col+" < "+ph(len(args))) }
+\tif f.Lte != nil    { args = append(args, *f.Lte);    parts = append(parts, col+" <= "+ph(len(args))) }
+\treturn strings.Join(parts, " AND "), args
+}
+
+`;
+    }
+    // ─── CRUD methods ──────────────────────────────────────────────────────────
+    generateCrudMethods() {
+        return `// FindMany returns multiple records. Use model-specific FindManyArgs for type-safe filtering.
+// Example: db.User.FindMany(ctx, &UserFindManyArgs{ Where: &UserWhereInput{ Name: &StringFilter{Contains: "Jo"} } })
+func (c *TableClient[T]) FindMany(ctx context.Context, args interface{}) ([]T, error) {
+	clause, orderBy, take, skip, selectCols, queryArgs := c.parseArgs(args)
+	table := c.quoteTable()
+	var query string
+	if len(selectCols) > 0 {
+		quoted := make([]string, len(selectCols))
+		for i, col := range selectCols {
+			quoted[i] = c.quoteName(col)
+		}
+		query = "SELECT " + strings.Join(quoted, ", ") + " FROM " + table
+	} else {
+		query = "SELECT * FROM " + table
+	}
+	if clause != "" {
+		query += " WHERE " + clause
+	}
+	if orderBy != "" {
+		query += " " + orderBy
+	}
+	if c.Dialect == DialectPostgres || c.Dialect == DialectSqlite {
+		if take > 0 {
+			query += fmt.Sprintf(" LIMIT %d", take)
+		}
+		if skip > 0 {
+			query += fmt.Sprintf(" OFFSET %d", skip)
+		}
+	} else {
+		if skip > 0 {
+			query += fmt.Sprintf(" OFFSET %d ROWS", skip)
+			if take > 0 {
+				query += fmt.Sprintf(" FETCH NEXT %d ROWS ONLY", take)
+			}
+		} else if take > 0 {
+			// rewrite SELECT to SELECT TOP
+			query = strings.Replace(query, "SELECT *", fmt.Sprintf("SELECT TOP (%d) *", take), 1)
+			query = strings.Replace(query, "SELECT "+strings.Join(func() []string {
+				if len(selectCols) == 0 { return []string{"*"} }
+				return selectCols
+			}(), ", "), fmt.Sprintf("SELECT TOP (%d) *", take), 1)
+		}
+	}
+	return c.queryAndScan(ctx, query, queryArgs...)
+}
+
+// FindFirst returns first record matching criteria.
+func (c *TableClient[T]) FindFirst(ctx context.Context, args interface{}) (*T, error) {
+	rows, err := c.FindMany(ctx, args)
+	if err != nil {
+		return nil, err
+	}
+	if len(rows) == 0 {
+		return nil, nil
+	}
+	return &rows[0], nil
+}
+
+// FindUnique fetches a single record by primary key.
+// The where input should uniquely identify one record.
+func (c *TableClient[T]) FindUnique(ctx context.Context, args interface{}) (*T, error) {
+\treturn c.FindFirst(ctx, args)
+}
+
+// Count returns total records matching criteria.
+func (c *TableClient[T]) Count(ctx context.Context, args interface{}) (int64, error) {
+\tclause, _, _, _, _, queryArgs := c.parseArgs(args)
+\tquery := fmt.Sprintf("SELECT COUNT(*) FROM %s", c.quoteTable())
+\tif clause != "" {
+\t\tquery += " WHERE " + clause
+\t}
+\tvar cnt int64
+\terr := c.DB.QueryRowContext(ctx, query, queryArgs...).Scan(&cnt)
+\treturn cnt, err
+}
+
+// Create inserts a new record and returns it.
+func (c *TableClient[T]) Create(ctx context.Context, entity *T) (*T, error) {
+\tval := reflect.ValueOf(entity).Elem()
+\ttyp := val.Type()
+
+\tvar cols []string
+\tvar phs []string
+\tvar args []interface{}
+
+\tfor i := 0; i < typ.NumField(); i++ {
+\t\tfield := typ.Field(i)
+\t\tdbTag := field.Tag.Get("db")
+\t\tif dbTag == "" || dbTag == "-" {
+\t\t\tcontinue
+\t\t}
+\t\tfieldVal := val.Field(i)
+\t\tif !fieldVal.IsZero() {
+\t\t\tcols = append(cols, c.quoteName(dbTag))
+\t\t\targs = append(args, fieldVal.Interface())
+\t\t\tphs = append(phs, c.ph(len(args)))
+\t\t}
+\t}
+
+\tquery := fmt.Sprintf("INSERT INTO %s (%s) VALUES (%s)", c.quoteTable(), strings.Join(cols, ", "), strings.Join(phs, ", "))
+\t_, err := c.DB.ExecContext(ctx, query, args...)
+\tif err != nil {
+\t\treturn nil, err
+\t}
+\treturn entity, nil
+}
+
+// CreateMany inserts multiple records and returns count.
+func (c *TableClient[T]) CreateMany(ctx context.Context, entities []*T) (int64, error) {
+\tvar count int64
+\tfor _, e := range entities {
+\t\t_, err := c.Create(ctx, e)
+\t\tif err != nil {
+\t\t\treturn count, err
+\t\t}
+\t\tcount++
+\t}
+\treturn count, nil
+}
+
+// Update updates an existing record identified by its primary key field (isId tag or "id" column).
+func (c *TableClient[T]) Update(ctx context.Context, entity *T) (*T, error) {
+\tval := reflect.ValueOf(entity).Elem()
+\ttyp := val.Type()
+
+\tvar sets []string
+\tvar args []interface{}
+\tvar idVal interface{}
+\tvar idCol string
+
+\tfor i := 0; i < typ.NumField(); i++ {
+\t\tfield := typ.Field(i)
+\t\tdbTag := field.Tag.Get("db")
+\t\tif dbTag == "" || dbTag == "-" {
+\t\t\tcontinue
+\t\t}
+\t\tfieldVal := val.Field(i)
+\t\tif strings.EqualFold(dbTag, "id") || field.Tag.Get("pk") == "true" {
+\t\t\tidVal = fieldVal.Interface()
+\t\t\tidCol = dbTag
+\t\t} else if !fieldVal.IsZero() {
+\t\t\targs = append(args, fieldVal.Interface())
+\t\t\tsets = append(sets, c.quoteName(dbTag)+" = "+c.ph(len(args)))
+\t\t}
+\t}
+
+\tif idVal == nil {
+\t\treturn nil, fmt.Errorf("cannot update entity without primary key")
+\t}
+
+\targs = append(args, idVal)
+\tquery := fmt.Sprintf("UPDATE %s SET %s WHERE %s = %s",
+\t\tc.quoteTable(), strings.Join(sets, ", "), c.quoteName(idCol), c.ph(len(args)))
+\t_, err := c.DB.ExecContext(ctx, query, args...)
+\tif err != nil {
+\t\treturn nil, err
+\t}
+\treturn entity, nil
+}
+
+// UpdateMany updates multiple records matching where criteria with given data fields.
+func (c *TableClient[T]) UpdateMany(ctx context.Context, whereArgs interface{}, data map[string]interface{}) (int64, error) {
+\tvar sets []string
+\tvar execArgs []interface{}
+
+\tfor col, v := range data {
+\t\texecArgs = append(execArgs, v)
+\t\tsets = append(sets, c.quoteName(col)+" = "+c.ph(len(execArgs)))
+\t}
+
+\tclause, _, _, _, _, whereQueryArgs := c.parseArgs(whereArgs)
+\texecArgs = append(execArgs, whereQueryArgs...)
+\tquery := fmt.Sprintf("UPDATE %s SET %s", c.quoteTable(), strings.Join(sets, ", "))
+\tif clause != "" {
+\t\tquery += " WHERE " + clause
+\t}
+
+\tres, err := c.DB.ExecContext(ctx, query, execArgs...)
+\tif err != nil {
+\t\treturn 0, err
+\t}
+\treturn res.RowsAffected()
+}
+
+// Delete removes a record by primary key value.
+func (c *TableClient[T]) Delete(ctx context.Context, id interface{}) (bool, error) {
+\tquery := fmt.Sprintf("DELETE FROM %s WHERE %s = %s", c.quoteTable(), c.quoteName("id"), c.ph(1))
+\tres, err := c.DB.ExecContext(ctx, query, id)
+\tif err != nil {
+\t\treturn false, err
+\t}
+\tn, _ := res.RowsAffected()
+\treturn n > 0, nil
+}
+
+// DeleteMany removes records matching where criteria.
+func (c *TableClient[T]) DeleteMany(ctx context.Context, args interface{}) (int64, error) {
+\tclause, _, _, _, _, queryArgs := c.parseArgs(args)
+\tquery := fmt.Sprintf("DELETE FROM %s", c.quoteTable())
+\tif clause != "" {
+\t\tquery += " WHERE " + clause
+\t}
+\tres, err := c.DB.ExecContext(ctx, query, queryArgs...)
+\tif err != nil {
+\t\treturn 0, err
+\t}
+\treturn res.RowsAffected()
+}
+
+// Upsert creates or updates entity based on its primary key.
+func (c *TableClient[T]) Upsert(ctx context.Context, entity *T) (*T, error) {
+\tval := reflect.ValueOf(entity).Elem()
+\tidField := findFieldByDbTag(val, "id")
+\tif idField.IsValid() && !idField.IsZero() {
+\t\texisting, err := c.FindUnique(ctx, nil)
+\t\tif err == nil && existing != nil {
+\t\t\treturn c.Update(ctx, entity)
+\t\t}
+\t}
+\treturn c.Create(ctx, entity)
+}
+
+// QueryRaw executes a raw SQL SELECT and returns rows as typed slice.
+func (c *TableClient[T]) QueryRaw(ctx context.Context, query string, args ...interface{}) ([]T, error) {
+\treturn c.queryAndScan(ctx, query, args...)
+}
+
+// ExecuteRaw executes a non-SELECT raw SQL and returns affected rows count.
+func (c *TableClient[T]) ExecuteRaw(ctx context.Context, query string, args ...interface{}) (int64, error) {
+\tres, err := c.DB.ExecContext(ctx, query, args...)
+\tif err != nil {
+\t\treturn 0, err
+\t}
+\treturn res.RowsAffected()
+}
+
+// Transaction executes fn within a database transaction, rolling back on error.
+func (c *TableClient[T]) Transaction(ctx context.Context, fn func(tx *sql.Tx) error) error {
+\ttx, err := c.DB.BeginTx(ctx, nil)
+\tif err != nil {
+\t\treturn err
+\t}
+\tdefer func() {
+\t\tif p := recover(); p != nil {
+\t\t\t_ = tx.Rollback()
+\t\t\tpanic(p)
+\t\t}
+\t}()
+\tif err := fn(tx); err != nil {
+\t\t_ = tx.Rollback()
+\t\treturn err
+\t}
+\treturn tx.Commit()
+}
+
+// parseArgs is the generic where/orderBy/take/skip extractor.
+// It uses reflection to read WhereClause, OrderBy, Take, Skip, Select from any args struct.
+func (c *TableClient[T]) parseArgs(args interface{}) (whereClause string, orderBy string, take int, skip int, selectCols []string, queryArgs []interface{}) {
+\tif args == nil {
+\t\treturn
+\t}
+\tv := reflect.ValueOf(args)
+\tif v.Kind() == reflect.Ptr {
+\t\tif v.IsNil() {
+\t\t\treturn
+\t\t}
+\t\tv = v.Elem()
+\t}
+\tif v.Kind() != reflect.Struct {
+\t\treturn
+\t}
+
+\t// Where
+\twhereField := v.FieldByName("Where")
+\tif whereField.IsValid() && !whereField.IsNil() {
+\t\t// where is a pointer to a model-specific WhereInput struct
+\t\t// Delegate to buildWhereFromStruct
+\t\twc, wa := c.buildWhereFromStruct(whereField.Elem(), 1)
+\t\twhereClause = wc
+\t\tqueryArgs = wa
+\t}
+
+\t// OrderBy
+\torderByField := v.FieldByName("OrderBy")
+\tif orderByField.IsValid() && !orderByField.IsNil() {
+\t\tobv := orderByField.Elem()
+\t\ttyp := obv.Type()
+\t\tvar parts []string
+\t\tfor i := 0; i < obv.NumField(); i++ {
+\t\t\tfv := obv.Field(i)
+\t\t\tif fv.IsNil() {
+\t\t\t\tcontinue
+\t\t\t}
+\t\t\tcol := c.quoteName(c.toSnakeCase(typ.Field(i).Name))
+\t\t\tdirection := strings.ToUpper(fv.Elem().String())
+\t\t\tif direction != "DESC" {
+\t\t\t\tdirection = "ASC"
+\t\t\t}
+\t\t\tparts = append(parts, col+" "+direction)
+\t\t}
+\t\tif len(parts) > 0 {
+\t\t\torderBy = "ORDER BY " + strings.Join(parts, ", ")
+\t\t}
+\t}
+
+\t// Take
+\ttakeField := v.FieldByName("Take")
+\tif takeField.IsValid() && !takeField.IsNil() {
+\t\ttake = int(takeField.Elem().Int())
+\t}
+
+\t// Skip
+\tskipField := v.FieldByName("Skip")
+\tif skipField.IsValid() && !skipField.IsNil() {
+\t\tskip = int(skipField.Elem().Int())
+\t}
+
+\t// Select
+\tselectField := v.FieldByName("Select")
+\tif selectField.IsValid() && selectField.Kind() == reflect.Slice && !selectField.IsNil() {
+\t\tfor i := 0; i < selectField.Len(); i++ {
+\t\t\tselectCols = append(selectCols, selectField.Index(i).String())
+\t\t}
+\t}
+
+\treturn
+}
+
+// buildWhereFromStruct converts a WhereInput struct to SQL clause + args.
+// It processes exported pointer fields using their type to detect StringFilter, NumberFilter, etc.
+func (c *TableClient[T]) buildWhereFromStruct(v reflect.Value, argOffset int) (string, []interface{}) {
+\ttyp := v.Type()
+\tvar parts []string
+\tvar args []interface{}
+
+\tpHFunc := func(n int) string { return c.ph(n) }
+
+\tfor i := 0; i < v.NumField(); i++ {
+\t\tfield := typ.Field(i)
+\t\tfv := v.Field(i)
+\t\tname := field.Name
+
+\t\t// AND / OR / NOT handling
+\t\tif name == "AND" && fv.Kind() == reflect.Slice && !fv.IsNil() {
+\t\t\tvar subParts []string
+\t\t\tfor j := 0; j < fv.Len(); j++ {
+\t\t\t\tsub, subArgs := c.buildWhereFromStruct(fv.Index(j), argOffset+len(args))
+\t\t\t\tif sub != "" { subParts = append(subParts, sub); args = append(args, subArgs...) }
+\t\t\t}
+\t\t\tif len(subParts) > 0 { parts = append(parts, "("+strings.Join(subParts, " AND ")+")") }
+\t\t\tcontinue
+\t\t}
+\t\tif name == "OR" && fv.Kind() == reflect.Slice && !fv.IsNil() {
+\t\t\tvar subParts []string
+\t\t\tfor j := 0; j < fv.Len(); j++ {
+\t\t\t\tsub, subArgs := c.buildWhereFromStruct(fv.Index(j), argOffset+len(args))
+\t\t\t\tif sub != "" { subParts = append(subParts, sub); args = append(args, subArgs...) }
+\t\t\t}
+\t\t\tif len(subParts) > 0 { parts = append(parts, "("+strings.Join(subParts, " OR ")+")") }
+\t\t\tcontinue
+\t\t}
+\t\tif name == "NOT" && fv.Kind() == reflect.Ptr && !fv.IsNil() {
+\t\t\tsub, subArgs := c.buildWhereFromStruct(fv.Elem(), argOffset+len(args))
+\t\t\tif sub != "" { parts = append(parts, "NOT ("+sub+")"); args = append(args, subArgs...) }
+\t\t\tcontinue
+\t\t}
+
+\t\tif fv.Kind() != reflect.Ptr || fv.IsNil() {
+\t\t\tcontinue
+\t\t}
+
+\t\tcol := c.quoteName(c.toSnakeCase(name))
+\t\telem := fv.Elem()
+\t\ttypeName := field.Type.Elem().Name()
+
+\t\tswitch typeName {
+\t\tcase "StringFilter":
+\t\t\tfilter := elem.Interface().(StringFilter)\n\t\t\tclause, newArgs := buildStringFilter(col, &filter, args, pHFunc)\n\t\t\tif clause != "" { parts = append(parts, clause) }\n\t\t\targs = newArgs
+\t\tcase "NumberFilter":
+\t\t\tfilter := elem.Interface().(NumberFilter)\n\t\t\tclause, newArgs := buildNumberFilter(col, &filter, args, pHFunc)\n\t\t\tif clause != "" { parts = append(parts, clause) }\n\t\t\targs = newArgs
+\t\tcase "IntFilter":
+\t\t\tfilter := elem.Interface().(IntFilter)\n\t\t\tclause, newArgs := buildIntFilter(col, &filter, args, pHFunc)\n\t\t\tif clause != "" { parts = append(parts, clause) }\n\t\t\targs = newArgs
+\t\tcase "DateTimeFilter":
+\t\t\tfilter := elem.Interface().(DateTimeFilter)\n\t\t\tclause, newArgs := buildDateTimeFilter(col, &filter, args, pHFunc)\n\t\t\tif clause != "" { parts = append(parts, clause) }\n\t\t\targs = newArgs
+\t\tcase "bool":
+\t\t\targs = append(args, elem.Bool())
+\t\t\tparts = append(parts, col+" = "+c.ph(argOffset+len(args)))
+\t\tcase "string":
+\t\t\targs = append(args, elem.String())
+\t\t\tparts = append(parts, col+" = "+c.ph(argOffset+len(args)))
+\t\tcase "int", "int64":
+\t\t\targs = append(args, elem.Int())
+\t\t\tparts = append(parts, col+" = "+c.ph(argOffset+len(args)))
+\t\tcase "float64":
+\t\t\targs = append(args, elem.Float())
+\t\t\tparts = append(parts, col+" = "+c.ph(argOffset+len(args)))
+\t\t}
+\t}
+
+\treturn strings.Join(parts, " AND "), args
+}
+
+`;
+    }
+    // ─── VectorSearch ──────────────────────────────────────────────────────────
+    generateVectorSearch() {
+        return `// VectorSearchOptions contains options for vector similarity queries.
+type VectorSearchOptions struct {
+\tTake           int
+\tWhere          interface{}
+\tVectorField    string
+\tDistanceMetric string // "cosine" | "euclidean" | "dot"
+}
+
+// VectorSearch performs native SQL vector similarity search with in-memory fallback.
+// Primary: SQL Server VECTOR_DISTANCE (MSSQL) or pgvector operators (Postgres).
+// Fallback: in-memory cosine/euclidean/dot similarity if DB lacks native extensions.
+func (c *TableClient[T]) VectorSearch(ctx context.Context, vector []float64, opts ...VectorSearchOptions) ([]T, error) {
+\ttake := 10
+\tvectorField := "embedding"
+\tdistanceMetric := "cosine"
+\tvar whereArgs interface{}
+
+\tif len(opts) > 0 {
+\t\tif opts[0].Take > 0 { take = opts[0].Take }
+\t\tif opts[0].VectorField != "" { vectorField = opts[0].VectorField }
+\t\tif opts[0].DistanceMetric != "" { distanceMetric = opts[0].DistanceMetric }
+\t\twhereArgs = opts[0].Where
+\t}
+
+\twhereCl, _, _, _, _, whereQueryArgs := c.parseArgs(whereArgs)
+\tdim := len(vector)
+\tvecBytes, _ := json.Marshal(vector)
+\tvecStr := string(vecBytes)
+
+\t// 1. Primary path: dialect-aware native SQL vector query
+\tvar sqlQuery string
+\tqueryArgs := append([]interface{}{vecStr}, whereQueryArgs...)
+\tif c.Dialect == DialectPostgres {
+\t\top := "<=>"
+\t\tif strings.EqualFold(distanceMetric, "euclidean") { op = "<->" }
+\t\tif strings.EqualFold(distanceMetric, "dot") { op = "<#>" }
+\t\tvcol := c.quoteName(vectorField)
+\t\tsqlQuery = fmt.Sprintf("SELECT *, (%s %s $1::vector) AS distance FROM %s", vcol, op, c.quoteTable())
+\t\tif whereCl != "" {
+\t\t\tsqlQuery += fmt.Sprintf(" WHERE %s IS NOT NULL AND (%s)", vcol, whereCl)
+\t\t} else {
+\t\t\tsqlQuery += fmt.Sprintf(" WHERE %s IS NOT NULL", vcol)
+\t\t}
+\t\tsqlQuery += fmt.Sprintf(" ORDER BY distance ASC LIMIT %d", take)
+\t} else {
+\t\tvcol := c.quoteName(vectorField)
+\t\tsqlQuery = fmt.Sprintf(
+\t\t\t"SELECT TOP (%d) *, VECTOR_DISTANCE('%s', CAST(%s AS VECTOR(%d, float32)), CAST(? AS VECTOR(%d, float32))) AS distance FROM %s WITH (NOLOCK)",
+\t\t\ttake, distanceMetric, vcol, dim, dim, c.quoteTable(),
+\t\t)
+\t\tif whereCl != "" {
+\t\t\tsqlQuery += fmt.Sprintf(" WHERE %s IS NOT NULL AND (%s)", vcol, whereCl)
+\t\t} else {
+\t\t\tsqlQuery += fmt.Sprintf(" WHERE %s IS NOT NULL", vcol)
+\t\t}
+\t\tsqlQuery += " ORDER BY distance ASC"
+\t}
+
+\tnativeRows, nativeErr := c.queryAndScan(ctx, sqlQuery, queryArgs...)
+\tif nativeErr == nil {
+\t\treturn nativeRows, nil
+\t}
+
+\t// 2. Fallback: in-memory similarity
+\trows, err := c.FindMany(ctx, whereArgs)
+\tif err != nil {
+\t\treturn nil, err
+\t}
+
+\ttype scoredItem struct {
+\t\titem     T
+\t\tdistance float64
+\t}
+\tvar scored []scoredItem
+
+\tfor _, item := range rows {
+\t\tval := reflect.ValueOf(item)
+\t\tfieldVal := findFieldByDbTag(val, vectorField)
+\t\tif !fieldVal.IsValid() || fieldVal.IsZero() {
+\t\t\tcontinue
+\t\t}
+
+\t\tvar rowVec []float64
+\t\tif fieldVal.Kind() == reflect.String {
+\t\t\t_ = json.Unmarshal([]byte(fieldVal.String()), &rowVec)
+\t\t} else if fieldVal.Kind() == reflect.Slice {
+\t\t\tfor i := 0; i < fieldVal.Len(); i++ {
+\t\t\t\trowVec = append(rowVec, fieldVal.Index(i).Float())
+\t\t\t}
+\t\t}
+\t\tif len(rowVec) != len(vector) {
+\t\t\tcontinue
+\t\t}
+
+\t\tvar dist float64
+\t\tswitch strings.ToLower(distanceMetric) {
+\t\tcase "euclidean":
+\t\t\tvar sum float64
+\t\t\tfor i := range vector { d := vector[i] - rowVec[i]; sum += d * d }
+\t\t\tdist = math.Sqrt(sum)
+\t\tcase "dot":
+\t\t\tvar dot float64
+\t\t\tfor i := range vector { dot += vector[i] * rowVec[i] }
+\t\t\tdist = -dot
+\t\tdefault: // cosine
+\t\t\tvar dot, m1, m2 float64
+\t\t\tfor i := range vector { dot += vector[i] * rowVec[i]; m1 += vector[i] * vector[i]; m2 += rowVec[i] * rowVec[i] }
+\t\t\tif m1 > 0 && m2 > 0 { dist = 1.0 - dot/(math.Sqrt(m1)*math.Sqrt(m2)) } else { dist = 1.0 }
+\t\t}
+
+\t\tscored = append(scored, scoredItem{item: item, distance: dist})
+\t}
+
+\tsort.Slice(scored, func(i, j int) bool { return scored[i].distance < scored[j].distance })
+
+\tvar result []T
+\tlimit := take
+\tif limit > len(scored) { limit = len(scored) }
+\tfor i := 0; i < limit; i++ {
+\t\tresult = append(result, scored[i].item)
+\t}
+\treturn result, nil
+}
+
+`;
+    }
+    // ─── Helpers ───────────────────────────────────────────────────────────────
+    generateHelpers() {
+        return `// findFieldByDbTag looks up a struct field by its "db" tag (case-insensitive).
+func findFieldByDbTag(val reflect.Value, dbTag string) reflect.Value {
+\tif val.Kind() == reflect.Ptr {
+\t\tval = val.Elem()
+\t}
+\tif val.Kind() != reflect.Struct {
+\t\treturn reflect.Value{}
+\t}
+\ttyp := val.Type()
+\tfor i := 0; i < typ.NumField(); i++ {
+\t\ttag := typ.Field(i).Tag.Get("db")
+\t\tif strings.EqualFold(tag, dbTag) || strings.EqualFold(typ.Field(i).Name, dbTag) {
+\t\t\treturn val.Field(i)
+\t\t}
+\t}
+\treturn reflect.Value{}
+}
+
+// toSnakeCase converts CamelCase to snake_case for column name resolution.
+func (c *TableClient[T]) toSnakeCase(s string) string {
+\tvar res []rune
+\tfor i, r := range s {
+\t\tif i > 0 && r >= 'A' && r <= 'Z' {
+\t\t\tres = append(res, '_')
+\t\t}
+\t\tres = append(res, []rune(strings.ToLower(string(r)))...)
+\t}
+\treturn string(res)
+}
+
+// Ensure unused imports are referenced
+var _ = sort.Slice
+var _ = time.Time{}
+
+`;
+    }
+    // ─── Per-model ORM types ───────────────────────────────────────────────────
+    generateModelOrmTypes(model) {
+        const name = this.capitalize(model.name);
+        let content = `// ─── ${name} ORM Types ──────────────────────────────────────────────────────────\n\n`;
+        // WhereInput
+        content += `// ${name}WhereInput provides type-safe filtering for ${name} queries.\ntype ${name}WhereInput struct {\n`;
+        content += `\tAND []${name}WhereInput\n`;
+        content += `\tOR  []${name}WhereInput\n`;
+        content += `\tNOT *${name}WhereInput\n`;
+        for (const field of model.fields) {
+            const filterType = this.getGoFilterType(field);
+            content += `\t${this.capitalize(field.name)} *${filterType}\n`;
+        }
+        content += `}\n\n`;
+        // OrderByInput
+        content += `// ${name}OrderByInput provides type-safe ordering for ${name} queries.\ntype ${name}OrderByInput struct {\n`;
+        for (const field of model.fields) {
+            content += `\t${this.capitalize(field.name)} *SortOrder\n`;
+        }
+        content += `}\n\n`;
+        // CreateInput
+        content += `// ${name}CreateInput holds data for creating a new ${name} record.\ntype ${name}CreateInput struct {\n`;
+        for (const field of model.fields) {
+            if (!field.isId) {
+                const goType = this.mapGoType(field, field.isOptional || field.hasDefault);
+                content += `\t${this.capitalize(field.name)} ${goType}\n`;
+            }
+        }
+        content += `}\n\n`;
+        // UpdateInput
+        content += `// ${name}UpdateInput holds data for updating an existing ${name} record.\ntype ${name}UpdateInput struct {\n`;
+        for (const field of model.fields) {
+            if (!field.isId) {
+                const goType = this.mapGoType(field, true); // always pointer so we can detect zero
+                content += `\t${this.capitalize(field.name)} ${goType}\n`;
+            }
+        }
+        content += `}\n\n`;
+        // FindManyArgs
+        content += `// ${name}FindManyArgs provides ORM-style args for FindMany queries on ${name}.\ntype ${name}FindManyArgs struct {\n`;
+        content += `\tWhere   *${name}WhereInput\n`;
+        content += `\tOrderBy *${name}OrderByInput\n`;
+        content += `\tTake    *int\n`;
+        content += `\tSkip    *int\n`;
+        content += `\tSelect  []string\n`;
+        content += `}\n\n`;
+        // FindFirstArgs
+        content += `// ${name}FindFirstArgs provides ORM-style args for FindFirst queries on ${name}.\ntype ${name}FindFirstArgs struct {\n`;
+        content += `\tWhere   *${name}WhereInput\n`;
+        content += `\tOrderBy *${name}OrderByInput\n`;
+        content += `\tSelect  []string\n`;
+        content += `}\n\n`;
+        // FindUniqueArgs
+        content += `// ${name}FindUniqueArgs provides ORM-style args for FindUnique queries on ${name}.\ntype ${name}FindUniqueArgs struct {\n`;
+        content += `\tWhere *${name}WhereInput\n`;
+        content += `}\n\n`;
+        // DeleteManyArgs
+        content += `// ${name}DeleteManyArgs provides ORM-style args for DeleteMany queries on ${name}.\ntype ${name}DeleteManyArgs struct {\n`;
+        content += `\tWhere *${name}WhereInput\n`;
+        content += `}\n\n`;
+        // CountArgs
+        content += `// ${name}CountArgs provides ORM-style args for Count queries on ${name}.\ntype ${name}CountArgs struct {\n`;
+        content += `\tWhere *${name}WhereInput\n`;
+        content += `}\n\n`;
+        return content;
+    }
+    getGoFilterType(field) {
+        // From the declared type, so a DECIMAL column gets the number filter and an INT
+        // column the integer one; both used to arrive as `number` and pick the first.
+        switch ((0, type_kinds_1.fieldKind)(field, this.provider)) {
+            case 'date': return 'DateTimeFilter';
+            case 'bool': return 'BoolFilter';
+            case 'int':
+            case 'bigint': return 'IntFilter';
+            case 'float': return 'NumberFilter';
+            default: return 'StringFilter';
+        }
+    }
+    // ─── Utilities ─────────────────────────────────────────────────────────────
+    getAllPropertyVariations(modelName) {
+        const variations = new Set();
+        variations.add(modelName);
+        variations.add(this.toCamelCase(modelName));
+        variations.add(modelName + 's');
+        variations.add(this.toCamelCase(modelName) + 's');
+        const acronyms = ['LLM', 'AI', 'MCP', 'IT', 'QC', 'HR', 'MR', 'WH', 'SSIS', 'API', 'URL', 'ID', 'JSON'];
+        for (const acronym of acronyms) {
+            if (modelName.startsWith(acronym)) {
+                variations.add(acronym.toLowerCase() + modelName.slice(acronym.length));
+                variations.add(acronym[0].toLowerCase() + acronym.slice(1) + modelName.slice(acronym.length));
+                variations.add(acronym.toLowerCase() + modelName.slice(acronym.length) + 's');
+            }
+        }
+        return Array.from(variations);
+    }
+    capitalize(str) {
+        if (!str)
+            return '';
+        return str[0].toUpperCase() + str.slice(1);
+    }
+    toCamelCase(str) {
+        if (!str)
+            return '';
+        return str[0].toLowerCase() + str.slice(1);
+    }
+    toSnakeCase(str) {
+        if (!str)
+            return '';
+        return str
+            .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+            .replace(/([a-z\d])([A-Z])/g, '$1_$2')
+            .toLowerCase();
+    }
+}
+exports.GolangGenerator = GolangGenerator;