@an5/orm 1.0.9 → 1.1.0

package/generator/src/golang-generator.ts

@@ -1,8 +1,13 @@
 import fs from 'fs';
 import path from 'path';
-import { Model, Field, Relation } from './types';
+import { Model, Field, Relation, bracketedTableName, dottedTableName } from './types';
+import { fieldKind } from './type-kinds';
+import { Provider } from './field-types';
 
 export class GolangGenerator {
+  /** The database being generated for; decides types like `TIMESTAMP`. */
+  private provider: Provider | undefined;
+
   constructor(private outputDir: string) {
     if (!fs.existsSync(this.outputDir)) {
       fs.mkdirSync(this.outputDir, { recursive: true });
@@ -10,8 +15,16 @@ export class GolangGenerator {
   }
 
   public generate(models: Model[]) {
-    // 1. Generate models.go  - entity structs
-    this.generateModelsGo(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);
@@ -25,22 +38,28 @@ export class GolangGenerator {
 
   // ─── Type mapping ──────────────────────────────────────────────────────────
 
-  private mapGoType(fieldType: string, isOptional: boolean): string {
-    let goType = 'string';
-    const lower = fieldType.toLowerCase();
-
-    if (['int', 'integer', 'smallint', 'tinyint'].includes(lower)) {
-      goType = 'int';
-    } else if (['bigint', 'long'].includes(lower)) {
-      goType = 'int64';
-    } else if (['float', 'real', 'double', 'decimal', 'numeric', 'money'].includes(lower)) {
-      goType = 'float64';
-    } else if (['bool', 'boolean', 'bit'].includes(lower)) {
-      goType = 'bool';
-    } else if (['datetime', 'datetime2', 'smalldatetime', 'date', 'datetimeoffset', 'timestamp'].includes(lower)) {
-      goType = 'time.Time';
-    } else if (['bytes', 'binary', 'varbinary'].includes(lower)) {
-      goType = '[]byte';
+  /**
+   * 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`.
+   */
+  private mapGoType(field: Field, isOptional: boolean): string {
+    const kind = fieldKind(field, this.provider);
+    let goType: string;
+    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') {
@@ -49,42 +68,56 @@ export class GolangGenerator {
     return goType;
   }
 
-  // ─── models.go ─────────────────────────────────────────────────────────────
+  // ─── <Model>.go (per-model file, like dotnet `<Model>.cs`) ────────────────
 
-  private generateModelsGo(models: Model[]) {
+  private generateModelFile(model: 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
 
-import (
+`;
+    if (needsTime) {
+      content += `import (
 \t"time"
 )
 
 `;
-    for (const model of models) {
-      if (model.description) {
-        content += `// ${model.name} - ${model.description}\n`;
-      }
-      content += `type ${model.name} struct {\n`;
+    }
+    content += this.generateModelStruct(model);
+    content += this.generateModelOrmTypes(model);
 
-      for (const field of model.fields) {
-        const goType = this.mapGoType(field.type, 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`;
-      }
+    fs.writeFileSync(path.join(this.outputDir, `${model.name}.go`), content);
+  }
 
-      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`;
-        }
-      }
+  private generateModelStruct(model: Model): string {
+    let content = '';
+    if (model.description) {
+      content += `// ${model.name} - ${model.description}\n`;
+    }
+    content += `type ${model.name} struct {\n`;
 
-      content += `}\n\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`;
+      }
     }
 
-    fs.writeFileSync(path.join(this.outputDir, 'models.go'), content);
+    content += `}\n\n`;
+    return content;
   }
 
   // ─── metadata.go ───────────────────────────────────────────────────────────
@@ -97,7 +130,7 @@ package an5client
 var ModelToTable = map[string]string{
 `;
     for (const model of models) {
-      const fullTable = `[${model.schemaName}].[${model.tableName}]`;
+      const fullTable = bracketedTableName(model);
       for (const prop of this.getAllPropertyVariations(model.name)) {
         content += `\t"${prop}": "${fullTable}",\n`;
       }
@@ -158,11 +191,7 @@ func GetDefaultConnectionString() string {
     content += this.generateVectorSearch();
     content += this.generateHelpers();
 
-    // Per-model ORM types (WhereInput, OrderByInput, Args structs)
-    for (const model of models) {
-      content += this.generateModelOrmTypes(model);
-    }
-
+    // NOTE: per-model ORM types live in each `<Model>.go` file.
     fs.writeFileSync(path.join(this.outputDir, 'client.go'), content);
   }
 
@@ -309,7 +338,7 @@ func NewAn5DbContextWithConnStr(db *sql.DB, connStr string) *An5DbContext {
 `;
     for (const model of models) {
       const name = this.capitalize(model.name);
-      content += `\tclient${name} := NewTableClient[${model.name}](db, "${model.schemaName}.${model.tableName}", d)\n`;
+      content += `\tclient${name} := NewTableClient[${model.name}](db, "${dottedTableName(model)}", d)\n`;
       content += `\tctx.${name}s = client${name}\n`;
       content += `\tctx.${name}  = client${name}\n`;
     }
@@ -1136,7 +1165,7 @@ var _ = time.Time{}
     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.type, field.isOptional || field.hasDefault);
+        const goType = this.mapGoType(field, field.isOptional || field.hasDefault);
         content += `\t${this.capitalize(field.name)} ${goType}\n`;
       }
     }
@@ -1146,7 +1175,7 @@ var _ = time.Time{}
     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.type, true); // always pointer so we can detect zero
+        const goType = this.mapGoType(field, true); // always pointer so we can detect zero
         content += `\t${this.capitalize(field.name)} ${goType}\n`;
       }
     }
@@ -1187,20 +1216,16 @@ var _ = time.Time{}
   }
 
   private getGoFilterType(field: Field): string {
-    const lower = field.type.toLowerCase();
-    if (['datetime', 'datetime2', 'smalldatetime', 'date', 'datetimeoffset', 'timestamp'].includes(lower)) {
-      return 'DateTimeFilter';
-    }
-    if (['bool', 'boolean', 'bit'].includes(lower)) {
-      return 'BoolFilter';
-    }
-    if (['int', 'integer', 'smallint', 'tinyint'].includes(lower)) {
-      return 'IntFilter';
-    }
-    if (['bigint', 'long', 'float', 'real', 'double', 'decimal', 'numeric', 'money'].includes(lower)) {
-      return 'NumberFilter';
+    // 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 (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';
     }
-    return 'StringFilter';
   }
 
   // ─── Utilities ─────────────────────────────────────────────────────────────

package/generator/src/index.ts

@@ -1,10 +1,13 @@
 import path from 'path';
+import { loadConfig, providerFromConfig, ConfigError, formatIssues } from './config';
+import { FieldTypeError, PROVIDER_LABELS } from './field-types';
 import { SchemaParser } from './parser';
 import { CodeGenerator } from './code-generator';
 import { MetadataGenerator } from './metadata-generator';
 import { PythonGenerator } from './python-generator';
 import { DotnetGenerator } from './dotnet-generator';
 import { GolangGenerator } from './golang-generator';
+import { RustGenerator } from './rust-generator';
 
 import fs from 'fs';
 
@@ -24,52 +27,69 @@ function clearGeneratedFiles(outputDir: string, extension: string) {
   }
 }
 
+function clearGeneratedPythonFiles(outputDir: string) {
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+    return;
+  }
+
+  // Delete generated .py files but preserve hand-maintained adapter.
+  const preserve = new Set(['an5_adapter.py']);
+  for (const entry of fs.readdirSync(outputDir)) {
+    const fullPath = path.join(outputDir, entry);
+    const stat = fs.statSync(fullPath);
+    if (stat.isDirectory()) continue;
+    if (entry.endsWith('.py') && !preserve.has(entry)) {
+      fs.unlinkSync(fullPath);
+    }
+  }
+}
+
 async function main() {
-  let rootDir = process.cwd();
-  let config: any = {};
-  
+  // Loaded through the validating loader, so a mistyped key or a wrong type
+  // stops here instead of quietly generating somewhere else.
+  let config: ReturnType<typeof loadConfig>;
   try {
-    let configPath = path.join(rootDir, 'an5Orm.config.js');
-    if (!fs.existsSync(configPath)) {
-      configPath = path.join(rootDir, 'an5Orm.config.cjs');
-    }
-    if (!fs.existsSync(configPath)) {
-      configPath = path.join(rootDir, '..', 'an5Orm.config.js');
-    }
-    if (!fs.existsSync(configPath)) {
-      configPath = path.join(rootDir, '..', 'an5Orm.config.cjs');
-    }
-    if (fs.existsSync(configPath)) {
-      config = require(configPath);
-      rootDir = path.dirname(configPath);
-    } else if (fs.existsSync(path.join(rootDir, '..', 'an5Schema'))) {
-      rootDir = path.resolve(rootDir, '..');
-    }
+    config = loadConfig();
   } catch (err) {
+    if (err instanceof ConfigError) {
+      console.error(`❌ ${err.message}:`);
+      console.error(formatIssues(err.issues));
+      process.exit(1);
+    }
     console.warn('⚠️ Could not load an5Orm.config.js/.cjs, using defaults.', err);
+    config = loadConfig(path.join(process.cwd(), 'no-such-dir'));
   }
 
-  const schemaDir = path.resolve(rootDir, config.schemaDir || 'an5Schema');
-  const outputTypesDir = path.resolve(rootDir, config.outputs?.typescript?.outputDir || 'an5Client/typescript');
-  const outputMetadataPath = path.resolve(rootDir, config.outputs?.typescript?.metadataFile || 'an5Client/typescript/an5Metadata.ts');
-  const outputPythonMetadataPath = path.resolve(rootDir, config.outputs?.python?.metadataFile || 'an5Client/python/an5_metadata.py');
-  const outputDotnetDir = path.resolve(rootDir, config.outputs?.dotnet?.outputDir || 'an5Client/dotnet');
-  const outputGolangDir = path.resolve(rootDir, config.outputs?.golang?.outputDir || 'an5Client/golang');
+  const { rootDir } = config;
+  const schemaDir = config.outputs.schemaDir;
+  const outputTypesDir = config.outputs.typescriptDir;
+  const outputMetadataPath = config.outputs.typescriptMetadataFile;
+  const outputPythonMetadataPath = config.outputs.pythonMetadataFile;
+  const outputDotnetDir = config.outputs.dotnetDir;
+  const outputGolangDir = config.outputs.golangDir;
+  const outputRustDir = config.outputs.rustDir;
+  const generateMetadata = config.config.generation.generateMetadata;
 
   console.log('🚀 Starting ORM generation...');
 
+  // The target provider comes from the connection string: both the allowed
+  // field types and the SQL follow it, instead of one shared list.
+  const provider = providerFromConfig(config.config, process.env);
+  console.log(`🗄️  Provider: ${PROVIDER_LABELS[provider]} (${provider})`);
+
   try {
     clearGeneratedFiles(outputTypesDir, '.ts');
     clearGeneratedFiles(outputDotnetDir, '.cs');
     clearGeneratedFiles(outputGolangDir, '.go');
-    if (fs.existsSync(outputMetadataPath)) {
+    clearGeneratedFiles(path.join(outputRustDir, 'src'), '.rs');
+    const pythonDirEarly = path.dirname(outputPythonMetadataPath);
+    clearGeneratedPythonFiles(pythonDirEarly);
+    if (config.config.generation.generateMetadata && fs.existsSync(outputMetadataPath)) {
       fs.unlinkSync(outputMetadataPath);
     }
-    if (fs.existsSync(outputPythonMetadataPath)) {
-      fs.unlinkSync(outputPythonMetadataPath);
-    }
 
-    const parser = new SchemaParser(schemaDir);
+    const parser = new SchemaParser(schemaDir, provider);
     const models = await parser.parse();
     console.log(`📦 Parsed ${models.length} models from schema.`);
 
@@ -77,13 +97,17 @@ async function main() {
     codeGen.generate(models);
     console.log(`✨ Generated modular types in ${outputTypesDir}`);
 
-    const metadataDir = path.dirname(outputMetadataPath);
-    if (!fs.existsSync(metadataDir)) {
-      fs.mkdirSync(metadataDir, { recursive: true });
+    if (generateMetadata) {
+      const metadataDir = path.dirname(outputMetadataPath);
+      if (!fs.existsSync(metadataDir)) {
+        fs.mkdirSync(metadataDir, { recursive: true });
+      }
+      const metadataGen = new MetadataGenerator(outputMetadataPath);
+      metadataGen.generate(models);
+      console.log(`✨ Generated metadata in ${outputMetadataPath}`);
+    } else {
+      console.log('⏭ Skipping metadata (generation.generateMetadata is false)');
     }
-    const metadataGen = new MetadataGenerator(outputMetadataPath);
-    metadataGen.generate(models);
-    console.log(`✨ Generated metadata in ${outputMetadataPath}`);
 
     const pythonDir = path.dirname(outputPythonMetadataPath);
     if (!fs.existsSync(pythonDir)) {
@@ -101,8 +125,19 @@ async function main() {
     golangGen.generate(models);
     console.log(`✨ Generated Golang models in ${outputGolangDir}`);
 
+    const rustGen = new RustGenerator(outputRustDir);
+    rustGen.generate(models);
+    console.log(`✨ Generated Rust client in ${outputRustDir}`);
+
     console.log('✅ ORM generation completed successfully.');
   } catch (error) {
+    // Print every bad field type with its provider, instead of the parser's
+    // nested error object.
+    if (error instanceof FieldTypeError) {
+      console.error(`❌ ${error.message}:`);
+      console.error(formatIssues(error.issues));
+      process.exit(1);
+    }
     console.error('❌ ORM generation failed:', error);
     process.exit(1);
   }

package/generator/src/metadata-generator.ts

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { Model } from './types';
+import { Model, bracketedTableName } from './types';
 
 export class MetadataGenerator {
   constructor(
@@ -15,7 +15,7 @@ export class MetadataGenerator {
     metaContent += 'export const modelToTable: Record<string, string> = {\n';
     for (const model of models) {
       const props = this.getAllPropertyVariations(model.name);
-      const fullTableName = `[${model.schemaName}].[${model.tableName}]`;
+      const fullTableName = bracketedTableName(model);
       for (const prop of props) {
         metaContent += `  ${prop}: "${fullTableName}",\n`;
       }