@an5/orm 1.0.0 → 1.0.1

package/dist/an5Orm.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.an5Orm = exports.An5ORM = void 0;
 const mssql_1 = __importDefault(require("mssql"));
-const an5_adapters_1 = require("an5-adapters");
+const an5_adapters_1 = require("@an5/adapters");
 const crypto_1 = require("crypto");
 const logger_1 = require("@an5/lib/logger");
 const typescript_1 = require("an5-client/typescript");
@@ -1345,4 +1345,4 @@ class An5ORM {
 exports.An5ORM = An5ORM;
 exports.an5Orm = new An5ORM();
 exports.default = exports.an5Orm;
-//# sourceMappingURL=an5Orm.js.map
+//# sourceMappingURL=an5Orm.js.map

package/dist/cleanup.js

@@ -4,10 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 require("dotenv/config");
-const an5_adapters_1 = require("an5-adapters");
+const an5_adapters_1 = require("@an5/adapters");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const rootDir = path_1.default.join(__dirname, "../");
+const rootDir = process.cwd();
 let config = {};
 try {
     const configPath = path_1.default.join(rootDir, "an5Orm.config.js");
@@ -114,4 +114,4 @@ cleanup().catch(err => {
     console.error("❌ Cleanup failed:", err);
     process.exit(1);
 });
-//# sourceMappingURL=cleanup.js.map
+//# sourceMappingURL=cleanup.js.map

package/dist/cli.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const root = path.resolve(__dirname, '..');
+const command = process.argv[2];
+const args = process.argv.slice(3);
+
+const commands = {
+  generate: path.join(__dirname, 'generator', 'src', 'index.js'),
+  'db:generate': path.join(__dirname, 'generator', 'src', 'index.js'),
+  'db:push': path.join(__dirname, 'push.js'),
+  'db:pull': path.join(__dirname, 'pull.js'),
+  'db:seed': path.join(__dirname, 'seed.js'),
+  'db:cleanup': path.join(__dirname, 'cleanup.js'),
+  'db:migrate': path.join(__dirname, 'migrate.js'),
+};
+
+function help() {
+  console.log(`AN5 ORM CLI
+
+Usage:
+  an5 <command>
+  an5-orm <command>
+
+Commands:
+  generate       Generate clients from an5Schema
+  db:generate    Alias for generate
+  db:push        Push schema to database
+  db:pull        Pull schema from database
+  db:seed        Seed database
+  db:cleanup     Drop tables not in schema
+  db:migrate     Migration commands: diff, generate, status
+
+Examples:
+  npx an5 generate
+  npx an5 db:migrate diff
+`);
+}
+
+if (!command || command === '-h' || command === '--help' || command === 'help') {
+  help();
+  process.exit(0);
+}
+
+const script = commands[command];
+if (!script) {
+  console.error(`Unknown command: ${command}`);
+  help();
+  process.exit(1);
+}
+
+const result = spawnSync(process.execPath, [script, ...args], {
+  cwd: process.cwd(),
+  env: process.env,
+  stdio: 'inherit',
+});
+
+if (result.error) {
+  console.error(result.error.message);
+  process.exit(1);
+}
+
+process.exit(result.status ?? 0);

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

@@ -0,0 +1,13 @@
+import { Model } from './types';
+export declare class CodeGenerator {
+    private outputDir;
+    constructor(outputDir: string);
+    generate(models: Model[]): void;
+    private generateBaseTs;
+    private generateModelFile;
+    private generateIndexTs;
+    private getAllPropertyVariations;
+    private getFieldFilterType;
+    private normalizeType;
+    private toCamelCase;
+}

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

@@ -0,0 +1,225 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeGenerator = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class CodeGenerator {
+    constructor(outputDir) {
+        this.outputDir = outputDir;
+        if (!fs_1.default.existsSync(this.outputDir)) {
+            fs_1.default.mkdirSync(this.outputDir, { recursive: true });
+        }
+    }
+    generate(models) {
+        this.generateBaseTs();
+        for (const model of models) {
+            this.generateModelFile(model);
+        }
+        this.generateIndexTs(models);
+    }
+    generateBaseTs() {
+        const baseTs = `
+export namespace An5 {
+  export class An5ClientKnownRequestError extends Error {
+    code!: string;
+    meta?: any;
+    constructor(message: string, { code, clientVersion }: { code: string; clientVersion: string }) {
+      super(message);
+      this.code = code;
+    }
+  }
+  export type SortOrder = 'asc' | 'desc';
+  export type StringFilter = { equals?: string; in?: string[]; notIn?: string[]; lt?: string; lte?: string; gt?: string; gte?: string; contains?: string; startsWith?: string; endsWith?: string; not?: string | StringFilter; };
+  export type StringNullableFilter = { equals?: string | null; in?: (string | null)[]; notIn?: (string | null)[]; lt?: string; lte?: string; gt?: string; gte?: string; contains?: string; startsWith?: string; endsWith?: string; not?: string | StringNullableFilter | null; };
+  export type NumberFilter = { equals?: number; in?: number[]; notIn?: number[]; lt?: number; lte?: number; gt?: number; gte?: number; not?: number | NumberFilter; };
+  export type IntFieldUpdateOperationsInput = { set?: number; increment?: number; decrement?: number; multiply?: number; divide?: number; };
+  export type FloatFieldUpdateOperationsInput = { set?: number; increment?: number; decrement?: number; multiply?: number; divide?: number; };
+  export type NumberNullableFilter = { equals?: number | null; in?: (number | null)[]; notIn?: (number | null)[]; lt?: number; lte?: number; gt?: number; gte?: number; not?: number | NumberNullableFilter | null; };
+  export type BooleanFilter = { equals?: boolean; not?: boolean | BooleanFilter; };
+  export type BooleanNullableFilter = { equals?: boolean | null; not?: boolean | BooleanNullableFilter | null; };
+  export type DateTimeFilter = { equals?: Date; in?: Date[]; notIn?: Date[]; lt?: Date; lte?: Date; gt?: Date; gte?: Date; not?: Date | DateTimeFilter; };
+  export type DateTimeNullableFilter = { equals?: Date | null; in?: (Date | null)[]; notIn?: (Date | null)[]; lt?: Date; lte?: Date; gt?: Date; gte?: Date; not?: Date | DateTimeNullableFilter | null; };
+}
+
+export interface TableClient<T, WhereInput = any, Select = any, Include = any, CreateInput = any, UpdateInput = any, FindManyArgs = any, FindFirstArgs = any, FindUniqueArgs = any, CreateArgs = any, UpdateArgs = any, UpsertArgs = any, DeleteArgs = any> {
+  findMany(args?: FindManyArgs): Promise<T[]>;
+  vectorSearch(args: { vector: number[]; take?: number; where?: WhereInput; include?: Include; vectorField?: string; distanceMetric?: 'cosine' | 'euclidean' | 'dot'; }): Promise<(T & { distance: number })[]>;
+  findFirst(args?: FindFirstArgs): Promise<T | null>;
+  findUnique(args?: FindUniqueArgs): Promise<T | null>;
+  count(args?: { where?: WhereInput; }): Promise<number>;
+  create(args: CreateArgs): Promise<T>;
+  createMany(args: { data: CreateInput[]; skipDuplicates?: boolean; }): Promise<{ count: number }>;
+  update(args: UpdateArgs): Promise<T>;
+  updateMany(args: { where?: WhereInput; data: UpdateInput; }): Promise<{ count: number }>;
+  delete(args: DeleteArgs): Promise<T>;
+  deleteMany(args?: { where?: WhereInput; }): Promise<{ count: number }>;
+  aggregate(args: any): Promise<any>;
+  groupBy(args: any): Promise<any[]>;
+  upsert(args: UpsertArgs): Promise<T>;
+}
+`;
+        fs_1.default.writeFileSync(path_1.default.join(this.outputDir, 'base.ts'), baseTs);
+    }
+    generateModelFile(model) {
+        let content = `import { An5, TableClient } from './base';\n`;
+        const relModels = [...new Set(model.relations.map(r => r.type))];
+        for (const relModel of relModels) {
+            if (relModel !== model.name) {
+                content += `import { ${relModel}, ${relModel}WhereInput, ${relModel}FindManyArgs, ${relModel}CreateInput, ${relModel}UpdateInput } from './${relModel}';\n`;
+            }
+        }
+        content += `\nexport interface ${model.name} {\n`;
+        for (const field of model.fields) {
+            content += `  ${field.name}: ${this.normalizeType(field.type)}${field.isOptional ? ' | null' : ''};\n`;
+        }
+        for (const rel of model.relations) {
+            content += `  ${rel.name}?: ${rel.type}${rel.isArray ? '[]' : ''}${rel.isOptional ? ' | null' : ''};\n`;
+        }
+        if (model.relations.length > 0) {
+            content += `  _count?: { ${model.relations.map(r => `${r.name}: number`).join('; ')} };\n`;
+        }
+        content += `}\n\n`;
+        content += `export type ${model.name}WhereInput = {\n`;
+        content += `  AND?: ${model.name}WhereInput | ${model.name}WhereInput[];\n`;
+        content += `  OR?: ${model.name}WhereInput[];\n`;
+        content += `  NOT?: ${model.name}WhereInput | ${model.name}WhereInput[];\n`;
+        for (const field of model.fields) {
+            const filter = this.getFieldFilterType(field);
+            content += `  ${field.name}?: ${field.type} | ${filter}${field.isOptional ? ' | null' : ''};\n`;
+        }
+        for (const rel of model.relations) {
+            if (rel.isArray) {
+                content += `  ${rel.name}?: { some?: ${rel.type}WhereInput; none?: ${rel.type}WhereInput; every?: ${rel.type}WhereInput; };\n`;
+            }
+            else {
+                content += `  ${rel.name}?: ${rel.type}WhereInput${rel.isOptional ? ' | null' : ''};\n`;
+            }
+        }
+        if (model.compoundUniques) {
+            for (const compound of model.compoundUniques) {
+                const keyName = compound.join('_');
+                content += `  ${keyName}?: { ${compound.map(f => `${f}: ${model.fields.find(mf => mf.name === f)?.type || 'any'}`).join('; ')} };\n`;
+            }
+        }
+        content += `};\n\n`;
+        const selectFields = model.fields.map(f => `${f.name}?: boolean`);
+        const selectRels = model.relations.map(r => `${r.name}?: boolean | ${r.type}FindManyArgs`);
+        if (model.relations.length > 0) {
+            selectRels.push(`_count?: boolean | { select?: { ${model.relations.map(r => `${r.name}?: boolean`).join('; ')} } }`);
+        }
+        content += `export type ${model.name}Select = { ${[...selectFields, ...selectRels].join('; ')}${[...selectFields, ...selectRels].length > 0 ? ';' : ''} };\n`;
+        const includeRels = model.relations.map(r => `${r.name}?: boolean | ${r.type}FindManyArgs`);
+        if (model.relations.length > 0) {
+            includeRels.push(`_count?: boolean | { select?: { ${model.relations.map(r => `${r.name}?: boolean`).join('; ')} } }`);
+        }
+        content += `export type ${model.name}Include = { ${includeRels.join('; ')}${includeRels.length > 0 ? ';' : ''} };\n`;
+        content += `export type ${model.name}CreateInput = { ${model.fields.map(f => `${f.name}${f.isOptional || f.hasDefault ? '?' : ''}: ${f.type}${f.isOptional ? ' | null' : ''}`).join('; ')}; ${model.relations.map(r => `${r.name}?: { create?: ${r.type}CreateInput | ${r.type}CreateInput[]; connect?: ${r.type}WhereInput | ${r.type}WhereInput[]; }`).join('; ')} };\n`;
+        content += `export type ${model.name}UpdateInput = { ${model.fields.filter(f => !f.isId).map(f => `${f.name}?: ${f.type === 'number' ? 'number | An5.IntFieldUpdateOperationsInput' : f.type}${f.isOptional ? ' | null' : ''}`).join('; ')}; ${model.relations.map(r => `${r.name}?: { create?: ${r.type}CreateInput | ${r.type}CreateInput[]; connect?: ${r.type}WhereInput | ${r.type}WhereInput[]; set?: ${r.type}WhereInput | ${r.type}WhereInput[]; disconnect?: ${r.type}WhereInput | ${r.type}WhereInput[]; delete?: ${r.type}WhereInput | ${r.type}WhereInput[]; update?: { where: ${r.type}WhereInput; data: ${r.type}UpdateInput; } | { where: ${r.type}WhereInput; data: ${r.type}UpdateInput; }[]; upsert?: { where: ${r.type}WhereInput; create: ${r.type}CreateInput; update: ${r.type}UpdateInput; } | { where: ${r.type}WhereInput; create: ${r.type}CreateInput; update: ${r.type}UpdateInput; }[]; }`).join('; ')} };\n`;
+        content += `export type ${model.name}FindManyArgs = { where?: ${model.name}WhereInput; orderBy?: any; take?: number; skip?: number; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
+        content += `export type ${model.name}FindFirstArgs = { where?: ${model.name}WhereInput; orderBy?: any; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
+        content += `export type ${model.name}FindUniqueArgs = { where?: ${model.name}WhereInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
+        content += `export type ${model.name}CreateArgs = { data: ${model.name}CreateInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
+        content += `export type ${model.name}UpdateArgs = { where: ${model.name}WhereInput; data: ${model.name}UpdateInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
+        content += `export type ${model.name}UpsertArgs = { where: ${model.name}WhereInput; create: ${model.name}CreateInput; update: ${model.name}UpdateInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
+        content += `export type ${model.name}DeleteArgs = { where: ${model.name}WhereInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
+        content += `export type ${model.name}TableClient = TableClient<\n  ${model.name},\n  ${model.name}WhereInput,\n  ${model.name}Select,\n  ${model.name}Include,\n  ${model.name}CreateInput,\n  ${model.name}UpdateInput,\n  ${model.name}FindManyArgs,\n  ${model.name}FindFirstArgs,\n  ${model.name}FindUniqueArgs,\n  ${model.name}CreateArgs,\n  ${model.name}UpdateArgs,\n  ${model.name}UpsertArgs,\n  ${model.name}DeleteArgs\n>;\n`;
+        fs_1.default.writeFileSync(path_1.default.join(this.outputDir, `${model.name}.ts`), content);
+    }
+    generateIndexTs(models) {
+        let content = `export * from './base';\n`;
+        for (const model of models) {
+            content += `export * from './${model.name}';\n`;
+        }
+        content += `\nimport { An5 as BaseAn5 } from './base';\n`;
+        for (const model of models) {
+            content += `import * as ${model.name}Types from './${model.name}';\n`;
+        }
+        content += `\nexport namespace An5 {\n`;
+        content += `  export type SortOrder = BaseAn5.SortOrder;\n`;
+        content += `  export type StringFilter = BaseAn5.StringFilter;\n`;
+        content += `  export type StringNullableFilter = BaseAn5.StringNullableFilter;\n`;
+        content += `  export type NumberFilter = BaseAn5.NumberFilter;\n`;
+        content += `  export type NumberNullableFilter = BaseAn5.NumberNullableFilter;\n`;
+        content += `  export type BooleanFilter = BaseAn5.BooleanFilter;\n`;
+        content += `  export type BooleanNullableFilter = BaseAn5.BooleanNullableFilter;\n`;
+        content += `  export type DateTimeFilter = BaseAn5.DateTimeFilter;\n`;
+        content += `  export type DateTimeNullableFilter = BaseAn5.DateTimeNullableFilter;\n`;
+        content += `  export type IntFieldUpdateOperationsInput = BaseAn5.IntFieldUpdateOperationsInput;\n`;
+        content += `  export type FloatFieldUpdateOperationsInput = BaseAn5.FloatFieldUpdateOperationsInput;\n`;
+        content += `  export const An5ClientKnownRequestError = BaseAn5.An5ClientKnownRequestError;\n`;
+        for (const model of models) {
+            content += `  export type ${model.name} = ${model.name}Types.${model.name};\n`;
+            content += `  export type ${model.name}WhereInput = ${model.name}Types.${model.name}WhereInput;\n`;
+            content += `  export type ${model.name}Select = ${model.name}Types.${model.name}Select;\n`;
+            content += `  export type ${model.name}Include = ${model.name}Types.${model.name}Include;\n`;
+            content += `  export type ${model.name}CreateInput = ${model.name}Types.${model.name}CreateInput;\n`;
+            content += `  export type ${model.name}UpdateInput = ${model.name}Types.${model.name}UpdateInput;\n`;
+        }
+        content += `}\n`;
+        content += `\nexport class An5Client {\n  $connect(): Promise<void> { return Promise.resolve(); }\n  $disconnect(): Promise<void> { return Promise.resolve(); }\n  $transaction<R>(fn: (tx: An5Client) => Promise<R>, options?: { timeout?: number }): Promise<R>;\n  $transaction<R>(list: Promise<R>[]): Promise<R[]>;\n  $transaction(fn: any, options?: any): Promise<any> { return typeof fn === 'function' ? fn(this) : Promise.all(fn); }\n  $queryRaw<T = any>(queryParts: TemplateStringsArray | string, ...values: any[]): Promise<T> { return Promise.resolve([] as any); }\n  $queryRawUnsafe<R = any>(query: string, ...values: any[]): Promise<R> { return Promise.resolve([] as any); }\n  $executeRaw<T = any>(queryParts: TemplateStringsArray | string, ...values: any[]): Promise<any> { return Promise.resolve(0 as any); }\n  $executeRawUnsafe(query: string, ...values: any[]): Promise<number> { return Promise.resolve(0); }\n`;
+        const addedProps = new Set();
+        for (const model of models) {
+            const props = this.getAllPropertyVariations(model.name);
+            for (const prop of props) {
+                if (!addedProps.has(prop)) {
+                    content += `  ${prop}!: ${model.name}Types.${model.name}TableClient;\n`;
+                    addedProps.add(prop);
+                }
+            }
+        }
+        content += `}\n`;
+        fs_1.default.writeFileSync(path_1.default.join(this.outputDir, 'index.ts'), content);
+    }
+    getAllPropertyVariations(modelName) {
+        const variations = new Set();
+        variations.add(this.toCamelCase(modelName));
+        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));
+            }
+        }
+        return Array.from(variations);
+    }
+    getFieldFilterType(field) {
+        const normalizedType = this.normalizeType(field.type);
+        if (normalizedType === 'string')
+            return field.isOptional ? 'An5.StringNullableFilter' : 'An5.StringFilter';
+        if (normalizedType === 'number')
+            return field.isOptional ? 'An5.NumberNullableFilter' : 'An5.NumberFilter';
+        if (normalizedType === 'boolean')
+            return field.isOptional ? 'An5.BooleanNullableFilter' : 'An5.BooleanFilter';
+        if (normalizedType === 'Date')
+            return field.isOptional ? 'An5.DateTimeNullableFilter' : 'An5.DateTimeFilter';
+        return 'any';
+    }
+    normalizeType(type) {
+        const lowerType = type.toLowerCase();
+        if (['string', 'varchar', 'nvarchar', 'char', 'nchar', 'text', 'ntext', 'xml', 'guid', 'uuid', 'uniqueidentifier', 'sysname', 'hierarchyid', 'geography', 'geometry', 'sql_variant', 'sqlvariant', 'rowversion', 'variant'].includes(lowerType)) {
+            return 'string';
+        }
+        if (['int', 'integer', 'smallint', 'tinyint', 'bigint', 'long', 'number', 'decimal', 'numeric', 'money', 'smallmoney', 'float', 'real', 'double'].includes(lowerType)) {
+            return 'number';
+        }
+        if (['bool', 'boolean', 'bit'].includes(lowerType)) {
+            return 'boolean';
+        }
+        if (['datetime', 'datetime2', 'datetimeoffset', 'smalldatetime', 'date', 'time', 'timestamp'].includes(lowerType)) {
+            return 'Date';
+        }
+        if (['bytes', 'binary', 'varbinary', 'image'].includes(lowerType)) {
+            return 'string';
+        }
+        return 'any';
+    }
+    toCamelCase(str) {
+        if (!str)
+            return '';
+        return str[0].toLowerCase() + str.slice(1);
+    }
+}
+exports.CodeGenerator = CodeGenerator;

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

@@ -0,0 +1,11 @@
+import { Model } from './types';
+export declare class DotnetGenerator {
+    private outputDir;
+    constructor(outputDir: string);
+    generate(models: Model[]): void;
+    private generateConfigClass;
+    private mapType;
+    private generateEntityClass;
+    private generateDbContext;
+    private capitalize;
+}