@an5/orm 1.0.8 → 1.1.0

package/dist/generator/src/index.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/dist/generator/src/index.js

@@ -1,88 +1,137 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = __importDefault(require("path"));
-const parser_1 = require("./parser");
-const code_generator_1 = require("./code-generator");
-const metadata_generator_1 = require("./metadata-generator");
-const python_generator_1 = require("./python-generator");
-const dotnet_generator_1 = require("./dotnet-generator");
-const fs_1 = __importDefault(require("fs"));
-function clearGeneratedFiles(outputDir, extension) {
-    if (!fs_1.default.existsSync(outputDir)) {
-        fs_1.default.mkdirSync(outputDir, { recursive: true });
-        return;
-    }
-    for (const entry of fs_1.default.readdirSync(outputDir)) {
-        const fullPath = path_1.default.join(outputDir, entry);
-        const stat = fs_1.default.statSync(fullPath);
-        if (stat.isDirectory())
-            continue;
-        if (entry.endsWith(extension)) {
-            fs_1.default.unlinkSync(fullPath);
-        }
-    }
-}
-async function main() {
-    const rootDir = process.cwd();
-    let config = {};
-    try {
-        let configPath = path_1.default.join(rootDir, 'an5Orm.config.js');
-        if (!fs_1.default.existsSync(configPath)) {
-            configPath = path_1.default.join(rootDir, 'an5Orm.config.cjs');
-        }
-        if (fs_1.default.existsSync(configPath)) {
-            config = require(configPath);
-        }
-    }
-    catch (err) {
-        console.warn('⚠️ Could not load an5Orm.config.js/.cjs, using defaults.', err);
-    }
-    const schemaDir = path_1.default.resolve(rootDir, config.schemaDir || 'an5Schema');
-    const outputTypesDir = path_1.default.resolve(rootDir, config.outputs?.typescript?.outputDir || 'an5Client/typescript');
-    const outputMetadataPath = path_1.default.resolve(rootDir, config.outputs?.typescript?.metadataFile || 'an5Client/typescript/an5Metadata.ts');
-    const outputPythonMetadataPath = path_1.default.resolve(rootDir, config.outputs?.python?.metadataFile || 'an5Client/python/an5_metadata.py');
-    const outputDotnetDir = path_1.default.resolve(rootDir, config.outputs?.dotnet?.outputDir || 'an5Client/dotnet');
-    console.log('🚀 Starting ORM generation...');
-    try {
-        clearGeneratedFiles(outputTypesDir, '.ts');
-        clearGeneratedFiles(outputDotnetDir, '.cs');
-        if (fs_1.default.existsSync(outputMetadataPath)) {
-            fs_1.default.unlinkSync(outputMetadataPath);
-        }
-        if (fs_1.default.existsSync(outputPythonMetadataPath)) {
-            fs_1.default.unlinkSync(outputPythonMetadataPath);
-        }
-        const parser = new parser_1.SchemaParser(schemaDir);
-        const models = await parser.parse();
-        console.log(`📦 Parsed ${models.length} models from schema.`);
-        const codeGen = new code_generator_1.CodeGenerator(outputTypesDir);
-        codeGen.generate(models);
-        console.log(`✨ Generated modular types in ${outputTypesDir}`);
-        const metadataDir = path_1.default.dirname(outputMetadataPath);
-        if (!fs_1.default.existsSync(metadataDir)) {
-            fs_1.default.mkdirSync(metadataDir, { recursive: true });
-        }
-        const metadataGen = new metadata_generator_1.MetadataGenerator(outputMetadataPath);
-        metadataGen.generate(models);
-        console.log(`✨ Generated metadata in ${outputMetadataPath}`);
-        const pythonDir = path_1.default.dirname(outputPythonMetadataPath);
-        if (!fs_1.default.existsSync(pythonDir)) {
-            fs_1.default.mkdirSync(pythonDir, { recursive: true });
-        }
-        const pythonGen = new python_generator_1.PythonGenerator(outputPythonMetadataPath);
-        pythonGen.generate(models);
-        console.log(`✨ Generated Python metadata in ${outputPythonMetadataPath}`);
-        const dotnetGen = new dotnet_generator_1.DotnetGenerator(outputDotnetDir);
-        dotnetGen.generate(models);
-        console.log(`✨ Generated .NET models in ${outputDotnetDir}`);
-        console.log('✅ ORM generation completed successfully.');
-    }
-    catch (error) {
-        console.error('❌ ORM generation failed:', error);
-        process.exit(1);
-    }
-}
-main();
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const config_1 = require("./config");
+const field_types_1 = require("./field-types");
+const parser_1 = require("./parser");
+const code_generator_1 = require("./code-generator");
+const metadata_generator_1 = require("./metadata-generator");
+const python_generator_1 = require("./python-generator");
+const dotnet_generator_1 = require("./dotnet-generator");
+const golang_generator_1 = require("./golang-generator");
+const rust_generator_1 = require("./rust-generator");
+const fs_1 = __importDefault(require("fs"));
+function clearGeneratedFiles(outputDir, extension) {
+    if (!fs_1.default.existsSync(outputDir)) {
+        fs_1.default.mkdirSync(outputDir, { recursive: true });
+        return;
+    }
+    for (const entry of fs_1.default.readdirSync(outputDir)) {
+        const fullPath = path_1.default.join(outputDir, entry);
+        const stat = fs_1.default.statSync(fullPath);
+        if (stat.isDirectory())
+            continue;
+        if (entry.endsWith(extension)) {
+            fs_1.default.unlinkSync(fullPath);
+        }
+    }
+}
+function clearGeneratedPythonFiles(outputDir) {
+    if (!fs_1.default.existsSync(outputDir)) {
+        fs_1.default.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_1.default.readdirSync(outputDir)) {
+        const fullPath = path_1.default.join(outputDir, entry);
+        const stat = fs_1.default.statSync(fullPath);
+        if (stat.isDirectory())
+            continue;
+        if (entry.endsWith('.py') && !preserve.has(entry)) {
+            fs_1.default.unlinkSync(fullPath);
+        }
+    }
+}
+async function main() {
+    // Loaded through the validating loader, so a mistyped key or a wrong type
+    // stops here instead of quietly generating somewhere else.
+    let config;
+    try {
+        config = (0, config_1.loadConfig)();
+    }
+    catch (err) {
+        if (err instanceof config_1.ConfigError) {
+            console.error(`❌ ${err.message}:`);
+            console.error((0, config_1.formatIssues)(err.issues));
+            process.exit(1);
+        }
+        console.warn('⚠️ Could not load an5Orm.config.js/.cjs, using defaults.', err);
+        config = (0, config_1.loadConfig)(path_1.default.join(process.cwd(), 'no-such-dir'));
+    }
+    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 = (0, config_1.providerFromConfig)(config.config, process.env);
+    console.log(`🗄️  Provider: ${field_types_1.PROVIDER_LABELS[provider]} (${provider})`);
+    try {
+        clearGeneratedFiles(outputTypesDir, '.ts');
+        clearGeneratedFiles(outputDotnetDir, '.cs');
+        clearGeneratedFiles(outputGolangDir, '.go');
+        clearGeneratedFiles(path_1.default.join(outputRustDir, 'src'), '.rs');
+        const pythonDirEarly = path_1.default.dirname(outputPythonMetadataPath);
+        clearGeneratedPythonFiles(pythonDirEarly);
+        if (config.config.generation.generateMetadata && fs_1.default.existsSync(outputMetadataPath)) {
+            fs_1.default.unlinkSync(outputMetadataPath);
+        }
+        const parser = new parser_1.SchemaParser(schemaDir, provider);
+        const models = await parser.parse();
+        console.log(`📦 Parsed ${models.length} models from schema.`);
+        const codeGen = new code_generator_1.CodeGenerator(outputTypesDir);
+        codeGen.generate(models);
+        console.log(`✨ Generated modular types in ${outputTypesDir}`);
+        if (generateMetadata) {
+            const metadataDir = path_1.default.dirname(outputMetadataPath);
+            if (!fs_1.default.existsSync(metadataDir)) {
+                fs_1.default.mkdirSync(metadataDir, { recursive: true });
+            }
+            const metadataGen = new metadata_generator_1.MetadataGenerator(outputMetadataPath);
+            metadataGen.generate(models);
+            console.log(`✨ Generated metadata in ${outputMetadataPath}`);
+        }
+        else {
+            console.log('⏭ Skipping metadata (generation.generateMetadata is false)');
+        }
+        const pythonDir = path_1.default.dirname(outputPythonMetadataPath);
+        if (!fs_1.default.existsSync(pythonDir)) {
+            fs_1.default.mkdirSync(pythonDir, { recursive: true });
+        }
+        const pythonGen = new python_generator_1.PythonGenerator(outputPythonMetadataPath);
+        pythonGen.generate(models);
+        console.log(`✨ Generated Python metadata and client models in ${pythonDir}`);
+        const dotnetGen = new dotnet_generator_1.DotnetGenerator(outputDotnetDir);
+        dotnetGen.generate(models);
+        console.log(`✨ Generated .NET models in ${outputDotnetDir}`);
+        const golangGen = new golang_generator_1.GolangGenerator(outputGolangDir);
+        golangGen.generate(models);
+        console.log(`✨ Generated Golang models in ${outputGolangDir}`);
+        const rustGen = new rust_generator_1.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 field_types_1.FieldTypeError) {
+            console.error(`❌ ${error.message}:`);
+            console.error((0, config_1.formatIssues)(error.issues));
+            process.exit(1);
+        }
+        console.error('❌ ORM generation failed:', error);
+        process.exit(1);
+    }
+}
+main();

package/dist/generator/src/metadata-generator.d.ts

@@ -1,8 +1,11 @@
-import { Model } from './types';
-export declare class MetadataGenerator {
-    private outputPath;
-    constructor(outputPath: string);
-    generate(models: Model[]): void;
-    private getAllPropertyVariations;
-    private toCamelCase;
-}
+import { Model } from './types';
+export declare class MetadataGenerator {
+    private outputPath;
+    private relationImport;
+    constructor(outputPath: string, relationImport?: string);
+    generate(models: Model[]): void;
+    private getAllPropertyVariations;
+    private toSnakeCase;
+    private formatFieldMetadata;
+    private toCamelCase;
+}

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

@@ -1,90 +1,105 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataGenerator = void 0;
-const fs_1 = __importDefault(require("fs"));
-class MetadataGenerator {
-    constructor(outputPath) {
-        this.outputPath = outputPath;
-    }
-    generate(models) {
-        let metaContent = '// This file is auto-generated. Do not edit directly.\n\n';
-        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}]`;
-            for (const prop of props) {
-                metaContent += `  ${prop}: "${fullTableName}",\n`;
-            }
-        }
-        metaContent += '};\n\n';
-        metaContent += 'export const modelDescriptions: Record<string, string | undefined> = {\n';
-        for (const model of models) {
-            const props = this.getAllPropertyVariations(model.name);
-            for (const prop of props) {
-                metaContent += `  ${prop}: ${model.description ? JSON.stringify(model.description) : 'undefined'},\n`;
-            }
-        }
-        metaContent += '};\n\n';
-        metaContent += 'export const modelFields: Record<string, Record<string, { ts: string; sql: string; description?: string }>> = {\n';
-        for (const model of models) {
-            const props = this.getAllPropertyVariations(model.name);
-            const fieldsStr = `{ ${model.fields.map(f => `${f.name}: ${this.formatFieldMetadata(f)}`).join(', ')} }`;
-            for (const prop of props) {
-                metaContent += `  ${prop}: ${fieldsStr},\n`;
-            }
-        }
-        metaContent += '};\n\n';
-        metaContent += 'export interface RelationDef {\n  modelName: string;\n  relationType: "many" | "one";\n  foreignKey: string;\n  localKey: string;\n}\n\n';
-        metaContent += 'export const relationMap: Record<string, Record<string, RelationDef>> = {\n';
-        for (const model of models) {
-            const props = this.getAllPropertyVariations(model.name);
-            let relationsContent = `  {\n`;
-            for (const rel of model.relations) {
-                relationsContent += `    ${rel.name}: { modelName: "${this.toCamelCase(rel.type)}", relationType: "${rel.isArray ? 'many' : 'one'}", foreignKey: "${rel.foreignKey || 'id'}", localKey: "${rel.localKey || 'id'}" },\n`;
-            }
-            relationsContent += `  }`;
-            for (const prop of props) {
-                metaContent += `  ${prop}: ${relationsContent},\n`;
-            }
-        }
-        metaContent += '};\n';
-        fs_1.default.writeFileSync(this.outputPath, metaContent);
-    }
-    getAllPropertyVariations(modelName) {
-        const variations = new Set();
-        // 1. Standard camelCase (e.g. User -> user, McpServer -> mcpServer)
-        variations.add(this.toCamelCase(modelName));
-        // 2. Handle known acronyms at start (e.g. LLMProvider -> lLMProvider)
-        // This is already handled by toCamelCase if it only lowercases the first letter.
-        // But we might want 'llmProvider' as well.
-        const acronyms = ['LLM', 'AI', 'MCP', 'IT', 'QC', 'HR', 'MR', 'WH', 'SSIS', 'API', 'URL', 'ID', 'JSON'];
-        for (const acronym of acronyms) {
-            if (modelName.startsWith(acronym)) {
-                // e.g. LLMProvider -> llmProvider
-                variations.add(acronym.toLowerCase() + modelName.slice(acronym.length));
-                // e.g. LLMProvider -> lLMProvider (Prisma style)
-                variations.add(acronym[0].toLowerCase() + acronym.slice(1) + modelName.slice(acronym.length));
-            }
-        }
-        return Array.from(variations);
-    }
-    formatFieldMetadata(field) {
-        const entries = [
-            `ts: ${JSON.stringify(`${field.type}${field.isOptional ? '?' : ''}`)}`,
-            `sql: ${JSON.stringify(field.sqlType)}`,
-        ];
-        if (field.description) {
-            entries.push(`description: ${JSON.stringify(field.description)}`);
-        }
-        return `{ ${entries.join(', ')} }`;
-    }
-    toCamelCase(str) {
-        if (!str)
-            return '';
-        return str[0].toLowerCase() + str.slice(1);
-    }
-}
-exports.MetadataGenerator = MetadataGenerator;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataGenerator = void 0;
+const fs_1 = __importDefault(require("fs"));
+const types_1 = require("./types");
+class MetadataGenerator {
+    constructor(outputPath, relationImport = 'import type { RelationDef } from "@an5/orm";') {
+        this.outputPath = outputPath;
+        this.relationImport = relationImport;
+    }
+    generate(models) {
+        let metaContent = '// This file is auto-generated. Do not edit directly.\n\n';
+        metaContent += `${this.relationImport}\n\n`;
+        metaContent += 'export const modelToTable: Record<string, string> = {\n';
+        for (const model of models) {
+            const props = this.getAllPropertyVariations(model.name);
+            const fullTableName = (0, types_1.bracketedTableName)(model);
+            for (const prop of props) {
+                metaContent += `  ${prop}: "${fullTableName}",\n`;
+            }
+        }
+        metaContent += '};\n\n';
+        metaContent += 'export const modelDescriptions: Record<string, string | undefined> = {\n';
+        for (const model of models) {
+            const props = this.getAllPropertyVariations(model.name);
+            for (const prop of props) {
+                metaContent += `  ${prop}: ${model.description ? JSON.stringify(model.description) : 'undefined'},\n`;
+            }
+        }
+        metaContent += '};\n\n';
+        metaContent += 'export const modelFields: Record<string, Record<string, { ts: string; sql: string; description?: string }>> = {\n';
+        for (const model of models) {
+            const props = this.getAllPropertyVariations(model.name);
+            const fieldsStr = `{ ${model.fields.map(f => `${f.name}: ${this.formatFieldMetadata(f)}`).join(', ')} }`;
+            for (const prop of props) {
+                metaContent += `  ${prop}: ${fieldsStr},\n`;
+            }
+        }
+        metaContent += '};\n\n';
+        metaContent += 'export const relationMap: Record<string, Record<string, RelationDef>> = {\n';
+        for (const model of models) {
+            const props = this.getAllPropertyVariations(model.name);
+            let relationsContent = `  {\n`;
+            for (const rel of model.relations) {
+                relationsContent += `    ${rel.name}: { modelName: "${this.toCamelCase(rel.type)}", relationType: "${rel.isArray ? 'many' : 'one'}", foreignKey: "${rel.foreignKey || 'id'}", localKey: "${rel.localKey || 'id'}" },\n`;
+            }
+            relationsContent += `  }`;
+            for (const prop of props) {
+                metaContent += `  ${prop}: ${relationsContent},\n`;
+            }
+        }
+        metaContent += '};\n';
+        fs_1.default.writeFileSync(this.outputPath, metaContent);
+    }
+    getAllPropertyVariations(modelName) {
+        const variations = new Set();
+        // 1. PascalCase (User)
+        variations.add(modelName);
+        // 2. camelCase (user)
+        variations.add(this.toCamelCase(modelName));
+        // 3. Plural PascalCase (Users)
+        variations.add(modelName + 's');
+        // 4. Plural camelCase (users)
+        variations.add(this.toCamelCase(modelName) + 's');
+        // 5. snake_case (user, mc_server)
+        variations.add(this.toSnakeCase(modelName));
+        variations.add(this.toSnakeCase(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);
+    }
+    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();
+    }
+    formatFieldMetadata(field) {
+        const entries = [
+            `ts: ${JSON.stringify(`${field.type}${field.isOptional ? '?' : ''}`)}`,
+            `sql: ${JSON.stringify(field.sqlType)}`,
+        ];
+        if (field.description) {
+            entries.push(`description: ${JSON.stringify(field.description)}`);
+        }
+        return `{ ${entries.join(', ')} }`;
+    }
+    toCamelCase(str) {
+        if (!str)
+            return '';
+        return str[0].toLowerCase() + str.slice(1);
+    }
+}
+exports.MetadataGenerator = MetadataGenerator;

package/dist/generator/src/parser.d.ts

@@ -1,11 +1,37 @@
-import { Model } from './types';
-export declare function sqlTypeToTs(sqlType: string): string;
-export declare class SchemaParser {
-    private schemaDir;
-    private schemaText;
-    constructor(schemaDir: string);
-    parse(): Promise<Model[]>;
-    private loadSchema;
-    private parseModelLine;
-    private postProcessRelations;
-}
+import { Model } from './types';
+import { Provider } from './field-types';
+/**
+ * Maps a column type of a provider to its TypeScript type.
+ *
+ * `provider` defaults to SQL Server so existing callers keep their behaviour;
+ * the generator passes the provider derived from the connection string.
+ */
+export declare function sqlTypeToTs(sqlType: string, provider?: Provider): string;
+export declare class SchemaParser {
+    private schemaDir;
+    private provider;
+    private schemaText;
+    private issues;
+    private modelRefs;
+    private models;
+    /**
+     * @param schemaDir directory holding the `.an5` files
+     * @param provider target database; decides which field types are valid
+     */
+    constructor(schemaDir: string, provider?: Provider);
+    parse(): Promise<Model[]>;
+    private loadSchema;
+    private parseModelLine;
+    /**
+     * Settles the fields that matched no type: a name matching a model in the
+     * schema is a relation, anything else is a bad type — reported with the
+     * provider name and a suggestion.
+     *
+     * The decision has to wait for the whole schema, because a relation may point
+     * at a model declared later. Every upper-case token used to count as a
+     * relation, so `INTEGER` written for SQL Server became a relation to a model
+     * named `INTEGER` and nothing ever complained.
+     */
+    private resolveModelRefs;
+    private postProcessRelations;
+}