@an5/orm 1.0.8 → 1.1.0

package/dist/provider-support.d.ts

@@ -0,0 +1,27 @@
+import { Provider } from './generator/src/field-types';
+/**
+ * Which commands can only run against SQL Server.
+ *
+ * `db:push` is not among them: it goes through the dialect layer in
+ * `./generator/src/dialect`, so it writes the DDL each provider understands. These
+ * three do not — they read `sys.tables`/`sys.columns`/`sys.foreign_keys`, quote
+ * identifiers with brackets, and emit T-SQL. Running them against another database
+ * fails on the first catalog query with a driver error that says nothing about the
+ * real problem, or worse, half-applies a change before it does. So the provider is
+ * checked up front, where the message can name it.
+ *
+ * Not a reason to narrow the type tables though: the tables describe what each
+ * provider accepts, which is what the generated client and the schema files must
+ * stay within, whoever runs the commands.
+ */
+export declare const SQL_SERVER_ONLY_COMMANDS: Record<string, string>;
+/**
+ * Why a command cannot run against this provider, or null when it can.
+ *
+ * Returns the message instead of printing it and exiting, so this stays a plain
+ * function: it is shared by four command files, and a module that calls
+ * `process.exit` cannot be imported outside a Node CLI — nor unit tested for the
+ * thing it exists to say.
+ */
+export declare function sqlServerOnlyError(provider: Provider, command: string): string | null;
+//# sourceMappingURL=provider-support.d.ts.map

package/dist/provider-support.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQL_SERVER_ONLY_COMMANDS = void 0;
+exports.sqlServerOnlyError = sqlServerOnlyError;
+const field_types_1 = require("./generator/src/field-types");
+/**
+ * Which commands can only run against SQL Server.
+ *
+ * `db:push` is not among them: it goes through the dialect layer in
+ * `./generator/src/dialect`, so it writes the DDL each provider understands. These
+ * three do not — they read `sys.tables`/`sys.columns`/`sys.foreign_keys`, quote
+ * identifiers with brackets, and emit T-SQL. Running them against another database
+ * fails on the first catalog query with a driver error that says nothing about the
+ * real problem, or worse, half-applies a change before it does. So the provider is
+ * checked up front, where the message can name it.
+ *
+ * Not a reason to narrow the type tables though: the tables describe what each
+ * provider accepts, which is what the generated client and the schema files must
+ * stay within, whoever runs the commands.
+ */
+exports.SQL_SERVER_ONLY_COMMANDS = {
+    'db:pull': 'read the catalog and write schema files',
+    'db:migrate': 'diff the schema against the database and apply migrations',
+    'db:migrate:diff': 'diff the schema against the database',
+    'db:migrate:generate': 'write a migration file from the schema files',
+    'db:migrate:apply': 'apply pending migrations',
+    'db:migrate:rollback': 'roll a migration back',
+    'db:migrate:status': 'list schema models, database tables and migration state',
+    'db:cleanup': 'drop tables and foreign keys that are no longer in the schema',
+};
+/**
+ * Why a command cannot run against this provider, or null when it can.
+ *
+ * Returns the message instead of printing it and exiting, so this stays a plain
+ * function: it is shared by four command files, and a module that calls
+ * `process.exit` cannot be imported outside a Node CLI — nor unit tested for the
+ * thing it exists to say.
+ */
+function sqlServerOnlyError(provider, command) {
+    if (provider === 'mssql')
+        return null;
+    const what = exports.SQL_SERVER_ONLY_COMMANDS[command] ?? 'run';
+    return (`❌ ${command} only supports SQL Server, but the connection string selects ` +
+        `${field_types_1.PROVIDER_LABELS[provider]}.\n` +
+        `   ${command} ${what} using sys.* catalog views and T-SQL, so pointing it at ` +
+        `${field_types_1.PROVIDER_LABELS[provider]} would run the wrong SQL.\n` +
+        '   Use a SQL Server connection string, or generate and apply the schema with ' +
+        `${field_types_1.PROVIDER_LABELS[provider]}'s own tooling.`);
+}
+//# sourceMappingURL=provider-support.js.map

package/dist/scripts/release-cli.d.ts

@@ -1,3 +1,3 @@
-#!/usr/bin/env tsx
-export {};
+#!/usr/bin/env tsx
+export {};
 //# sourceMappingURL=release-cli.d.ts.map

package/dist/scripts/release-cli.js

@@ -1,116 +1,116 @@
-#!/usr/bin/env tsx
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const child_process_1 = require("child_process");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-function run(cmd, allowFail = false) {
-    try {
-        return (0, child_process_1.execSync)(cmd, { encoding: 'utf8' }).trim();
-    }
-    catch (error) {
-        if (allowFail)
-            return error.stdout?.toString()?.trim() || '';
-        throw error;
-    }
-}
-function inferComponent(file) {
-    const normalized = file.replace('\\', '/').toLowerCase();
-    if (normalized.includes('/generator/'))
-        return 'generator';
-    if (normalized.includes('/an5client/'))
-        return 'client';
-    if (normalized.includes('/an5schema/'))
-        return 'schema';
-    if (normalized.includes('/.github/'))
-        return 'ci';
-    if (normalized.includes('package.json') || normalized.includes('tsconfig'))
-        return 'build';
-    if (normalized.includes('.md'))
-        return 'docs';
-    return 'misc';
-}
-function collectChanges() {
-    const status = run('git status --porcelain');
-    const files = status
-        .split('\n')
-        .map(l => l.trim())
-        .filter(Boolean)
-        .map(l => l.slice(3).trim())
-        .filter(Boolean);
-    const groups = new Map();
-    for (const file of files) {
-        const component = inferComponent(file);
-        if (!groups.has(component)) {
-            groups.set(component, { component, files: [], summary: '' });
-        }
-        groups.get(component).files.push(file);
-    }
-    return Array.from(groups.values()).map(group => ({
-        ...group,
-        summary: `${group.component} updates`
-    }));
-}
-function generateChangelog(groups) {
-    const lines = ['# Changelog', ''];
-    for (const group of groups) {
-        lines.push(`## ${group.component}`);
-        lines.push(`- ${group.summary}`);
-        for (const file of group.files) {
-            lines.push(`  - ${file}`);
-        }
-        lines.push('');
-    }
-    return lines.join('\n').trim();
-}
-async function maybeUseLLM(summary) {
-    let apiKey = '';
-    try {
-        const configPath = require('path').join(__dirname, '..', '..', 'an5Adapters', 'typescript', 'config');
-        const mod = require(configPath);
-        if (mod?.getLlmConfig) {
-            const db = await mod.getLlmConfig();
-            if (db)
-                apiKey = db.apiKey;
-        }
-    }
-    catch { }
-    if (!apiKey)
-        return summary;
-    try {
-        const prompt = `Summarize these changes into one concise release note in English:\n${summary}`;
-        const payload = JSON.stringify({ model: 'gpt-4o-mini', messages: [{ role: 'system', content: 'You are a helpful release note writer.' }, { role: 'user', content: prompt }] });
-        const response = run(`curl -s https://api.openai.com/v1/chat/completions -H "Authorization: Bearer ${apiKey}" -H "Content-Type: application/json" -d '${payload}'`, true);
-        const parsed = JSON.parse(response);
-        return parsed.choices?.[0]?.message?.content?.trim() || summary;
-    }
-    catch {
-        return summary;
-    }
-}
-async function main() {
-    const groups = collectChanges();
-    if (groups.length === 0) {
-        console.log('No modified files detected.');
-        process.exit(0);
-    }
-    const changelog = generateChangelog(groups);
-    const outputPath = path_1.default.resolve(process.cwd(), 'CHANGELOG.md');
-    fs_1.default.writeFileSync(outputPath, changelog + '\n');
-    const summary = groups.map(g => `${g.component}: ${g.files.join(', ')}`).join('\n');
-    const llmSummary = await maybeUseLLM(summary);
-    console.log('\nGenerated changelog:\n');
-    console.log(changelog);
-    console.log('\nLLM summary:\n');
-    console.log(llmSummary);
-    const message = groups.map(g => g.component).join(', ');
-    const commitMessage = `chore: update ${message}`;
-    run(`git add -A`);
-    run(`git commit -m "${commitMessage}"`, true);
-    console.log(`\nCommitted with: ${commitMessage}`);
-}
-main().catch(console.error);
+#!/usr/bin/env tsx
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function run(cmd, allowFail = false) {
+    try {
+        return (0, child_process_1.execSync)(cmd, { encoding: 'utf8' }).trim();
+    }
+    catch (error) {
+        if (allowFail)
+            return error.stdout?.toString()?.trim() || '';
+        throw error;
+    }
+}
+function inferComponent(file) {
+    const normalized = file.replace('\\', '/').toLowerCase();
+    if (normalized.includes('/generator/'))
+        return 'generator';
+    if (normalized.includes('/an5client/'))
+        return 'client';
+    if (normalized.includes('/an5schema/'))
+        return 'schema';
+    if (normalized.includes('/.github/'))
+        return 'ci';
+    if (normalized.includes('package.json') || normalized.includes('tsconfig'))
+        return 'build';
+    if (normalized.includes('.md'))
+        return 'docs';
+    return 'misc';
+}
+function collectChanges() {
+    const status = run('git status --porcelain');
+    const files = status
+        .split('\n')
+        .map(l => l.trim())
+        .filter(Boolean)
+        .map(l => l.slice(3).trim())
+        .filter(Boolean);
+    const groups = new Map();
+    for (const file of files) {
+        const component = inferComponent(file);
+        if (!groups.has(component)) {
+            groups.set(component, { component, files: [], summary: '' });
+        }
+        groups.get(component).files.push(file);
+    }
+    return Array.from(groups.values()).map(group => ({
+        ...group,
+        summary: `${group.component} updates`
+    }));
+}
+function generateChangelog(groups) {
+    const lines = ['# Changelog', ''];
+    for (const group of groups) {
+        lines.push(`## ${group.component}`);
+        lines.push(`- ${group.summary}`);
+        for (const file of group.files) {
+            lines.push(`  - ${file}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n').trim();
+}
+async function maybeUseLLM(summary) {
+    let apiKey = '';
+    try {
+        const configPath = require('path').join(__dirname, '..', '..', 'an5Adapters', 'typescript', 'config');
+        const mod = require(configPath);
+        if (mod?.getLlmConfig) {
+            const db = await mod.getLlmConfig();
+            if (db)
+                apiKey = db.apiKey;
+        }
+    }
+    catch { }
+    if (!apiKey)
+        return summary;
+    try {
+        const prompt = `Summarize these changes into one concise release note in English:\n${summary}`;
+        const payload = JSON.stringify({ model: 'gpt-4o-mini', messages: [{ role: 'system', content: 'You are a helpful release note writer.' }, { role: 'user', content: prompt }] });
+        const response = run(`curl -s https://api.openai.com/v1/chat/completions -H "Authorization: Bearer ${apiKey}" -H "Content-Type: application/json" -d '${payload}'`, true);
+        const parsed = JSON.parse(response);
+        return parsed.choices?.[0]?.message?.content?.trim() || summary;
+    }
+    catch {
+        return summary;
+    }
+}
+async function main() {
+    const groups = collectChanges();
+    if (groups.length === 0) {
+        console.log('No modified files detected.');
+        process.exit(0);
+    }
+    const changelog = generateChangelog(groups);
+    const outputPath = path_1.default.resolve(process.cwd(), 'CHANGELOG.md');
+    fs_1.default.writeFileSync(outputPath, changelog + '\n');
+    const summary = groups.map(g => `${g.component}: ${g.files.join(', ')}`).join('\n');
+    const llmSummary = await maybeUseLLM(summary);
+    console.log('\nGenerated changelog:\n');
+    console.log(changelog);
+    console.log('\nLLM summary:\n');
+    console.log(llmSummary);
+    const message = groups.map(g => g.component).join(', ');
+    const commitMessage = `chore: update ${message}`;
+    run(`git add -A`);
+    run(`git commit -m "${commitMessage}"`, true);
+    console.log(`\nCommitted with: ${commitMessage}`);
+}
+main().catch(console.error);
 //# sourceMappingURL=release-cli.js.map

package/dist/sql-utils.d.ts

@@ -8,6 +8,8 @@ import type { RelationDef } from "./metadata";
  * user-supplied column / alias names.
  */
 export declare function quoteIdentifier(name: string): string;
+/** Quotes one-part or multipart SQL Server table identifiers safely. */
+export declare function quoteTableIdentifier(name: string): string;
 /** Sanitizes a parameter name to a safe T-SQL identifier fragment. */
 export declare function sanitizeParamName(name: string): string;
 /** Validates a direction token, defaulting to ASC. */
@@ -20,7 +22,7 @@ export interface QueryContext {
 }
 export declare function buildOrderBy(orderBy: any): string;
 /**
- * Recursively builds a WHERE clause from a Prisma-style filter object.
+ * Recursively builds a WHERE clause from a structured filter object.
  *
  * Values are always bound as parameters (`@name`); only identifiers are
  * interpolated directly, and they are run through {@link quoteIdentifier}.

package/dist/sql-utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.quoteIdentifier = quoteIdentifier;
+exports.quoteTableIdentifier = quoteTableIdentifier;
 exports.sanitizeParamName = sanitizeParamName;
 exports.normalizeSortDirection = normalizeSortDirection;
 exports.toNonNegativeInt = toNonNegativeInt;
@@ -18,6 +19,48 @@ function quoteIdentifier(name) {
     const s = String(name);
     return `[${s.replace(/\]/g, "]]")}]`;
 }
+function unquoteBracketIdentifier(part) {
+    const trimmed = String(part).trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        return trimmed.slice(1, -1).replace(/\]\]/g, "]");
+    }
+    return trimmed;
+}
+function splitMultipartIdentifier(name) {
+    const parts = [];
+    let current = "";
+    let inBracket = false;
+    const input = String(name).trim();
+    for (let i = 0; i < input.length; i += 1) {
+        const ch = input[i];
+        if (ch === "[")
+            inBracket = true;
+        if (ch === "]") {
+            if (input[i + 1] === "]") {
+                current += "]]";
+                i += 1;
+                continue;
+            }
+            inBracket = false;
+        }
+        if (ch === "." && !inBracket) {
+            if (current.trim())
+                parts.push(current.trim());
+            current = "";
+            continue;
+        }
+        current += ch;
+    }
+    if (current.trim())
+        parts.push(current.trim());
+    return parts.length > 0 ? parts : [input];
+}
+/** Quotes one-part or multipart SQL Server table identifiers safely. */
+function quoteTableIdentifier(name) {
+    return splitMultipartIdentifier(name)
+        .map(part => quoteIdentifier(unquoteBracketIdentifier(part)))
+        .join(".");
+}
 /** Sanitizes a parameter name to a safe T-SQL identifier fragment. */
 function sanitizeParamName(name) {
     const s = String(name);
@@ -34,7 +77,7 @@ function toNonNegativeInt(value, fallback = 0) {
     const n = Number.parseInt(String(value), 10);
     return Number.isFinite(n) && n >= 0 ? n : fallback;
 }
-const OPERATOR_KEYS = ["in", "notIn", "contains", "startsWith", "endsWith", "not", "gte", "lte", "gt", "lt"];
+const OPERATOR_KEYS = ["equals", "in", "notIn", "contains", "startsWith", "endsWith", "not", "gte", "lte", "gt", "lt"];
 function isOperatorValue(value) {
     if (!value || typeof value !== "object" || value instanceof Date)
         return false;
@@ -55,7 +98,7 @@ function buildOrderBy(orderBy) {
     return orderClauses.length > 0 ? ` ORDER BY ${orderClauses.join(", ")}` : "";
 }
 /**
- * Recursively builds a WHERE clause from a Prisma-style filter object.
+ * Recursively builds a WHERE clause from a structured filter object.
  *
  * Values are always bound as parameters (`@name`); only identifiers are
  * interpolated directly, and they are run through {@link quoteIdentifier}.
@@ -83,18 +126,27 @@ function parseWhere(modelName, where, params, prefix = "", ctx = {}) {
                 conditions.push(`(${filtered.join(" OR ")})`);
             }
         }
-        else if (key === "AND" && Array.isArray(value)) {
-            const andConditions = value.map((subWhere, idx) => parseWhere(modelName, subWhere, params, `${prefix}and_${idx}_`, ctx));
+        else if (key === "AND") {
+            const andItems = Array.isArray(value) ? value : [value];
+            const andConditions = andItems.map((subWhere, idx) => parseWhere(modelName, subWhere, params, `${prefix}and_${idx}_`, ctx));
             const filtered = andConditions.filter(Boolean);
             if (filtered.length > 0) {
                 conditions.push(`(${filtered.join(" AND ")})`);
             }
         }
+        else if (key === "NOT") {
+            const notItems = Array.isArray(value) ? value : [value];
+            const notConditions = notItems.map((subWhere, idx) => parseWhere(modelName, subWhere, params, `${prefix}not_${idx}_`, ctx));
+            const filtered = notConditions.filter(Boolean);
+            if (filtered.length > 0) {
+                conditions.push(`NOT (${filtered.join(" AND ")})`);
+            }
+        }
         else {
             const modelRelations = relationMap[modelName];
             const relation = modelRelations?.[key];
             if (relation) {
-                const relationTable = modelToTable[relation.modelName] || relation.modelName;
+                const relationTable = quoteTableIdentifier(modelToTable[relation.modelName] || relation.modelName);
                 const subParams = {};
                 let subWhere = value;
                 let op = "some";
@@ -114,26 +166,23 @@ function parseWhere(modelName, where, params, prefix = "", ctx = {}) {
                 }
                 const subWhereSql = parseWhere(relation.modelName, subWhere, subParams, `${prefix}${key}_`, ctx);
                 Object.assign(params, subParams);
-                if (subWhereSql) {
-                    const fk = quoteIdentifier(relation.foreignKey);
-                    const lk = quoteIdentifier(relation.localKey);
-                    if (relation.relationType === "one") {
-                        if (op === "none") {
-                            conditions.push(`${fk} NOT IN (SELECT ${lk} FROM ${relationTable} WITH (NOLOCK) WHERE ${subWhereSql})`);
-                        }
-                        else {
-                            conditions.push(`${fk} IN (SELECT ${lk} FROM ${relationTable} WITH (NOLOCK) WHERE ${subWhereSql})`);
-                        }
+                const fk = quoteIdentifier(relation.foreignKey);
+                const lk = quoteIdentifier(relation.localKey);
+                const outerKey = relation.relationType === "one" ? fk : lk;
+                const innerKey = relation.relationType === "one" ? lk : fk;
+                if (op === "every") {
+                    if (subWhereSql) {
+                        conditions.push(`${outerKey} NOT IN (SELECT ${innerKey} FROM ${relationTable} WITH (NOLOCK) WHERE NOT (${subWhereSql}))`);
                     }
                     else {
-                        if (op === "none") {
-                            conditions.push(`${lk} NOT IN (SELECT ${fk} FROM ${relationTable} WITH (NOLOCK) WHERE ${subWhereSql})`);
-                        }
-                        else {
-                            conditions.push(`${lk} IN (SELECT ${fk} FROM ${relationTable} WITH (NOLOCK) WHERE ${subWhereSql})`);
-                        }
+                        conditions.push("1 = 1");
                     }
                 }
+                else {
+                    const relationPredicate = subWhereSql ? ` WHERE ${subWhereSql}` : "";
+                    const operator = op === "none" ? "NOT IN" : "IN";
+                    conditions.push(`${outerKey} ${operator} (SELECT ${innerKey} FROM ${relationTable} WITH (NOLOCK)${relationPredicate})`);
+                }
             }
             else {
                 const col = quoteIdentifier(key);
@@ -141,7 +190,16 @@ function parseWhere(modelName, where, params, prefix = "", ctx = {}) {
                 if (value && typeof value === "object" && !(value instanceof Date)) {
                     const ops = Object.entries(value);
                     for (const [op, opVal] of ops) {
-                        if (op === "in" && Array.isArray(opVal)) {
+                        if (op === "equals") {
+                            if (opVal === null) {
+                                conditions.push(`${col} IS NULL`);
+                            }
+                            else {
+                                conditions.push(`${col} = @${paramName}_equals`);
+                                params[`${paramName}_equals`] = opVal;
+                            }
+                        }
+                        else if (op === "in" && Array.isArray(opVal)) {
                             if (opVal.length === 0) {
                                 conditions.push("1 = 0");
                             }
@@ -182,8 +240,20 @@ function parseWhere(modelName, where, params, prefix = "", ctx = {}) {
                             params[`${paramName}_endsWith`] = `%${opVal}`;
                         }
                         else if (op === "not") {
-                            conditions.push(`${col} <> @${paramName}_not`);
-                            params[`${paramName}_not`] = opVal;
+                            if (opVal === null) {
+                                conditions.push(`${col} IS NOT NULL`);
+                            }
+                            else if (opVal && typeof opVal === "object" && !(opVal instanceof Date) && !Array.isArray(opVal)) {
+                                const nestedParams = {};
+                                const nestedSql = parseWhere(modelName, { [key]: opVal }, nestedParams, `${prefix}${key}_not_`, ctx);
+                                Object.assign(params, nestedParams);
+                                if (nestedSql)
+                                    conditions.push(`NOT (${nestedSql})`);
+                            }
+                            else {
+                                conditions.push(`${col} <> @${paramName}_not`);
+                                params[`${paramName}_not`] = opVal;
+                            }
                         }
                         else if (op === "gte") {
                             conditions.push(`${col} >= @${paramName}_gte`);

package/generator/src/api.ts

@@ -0,0 +1,45 @@
+/**
+ * Side-effect-free entrypoint for programmatic use of the code generator.
+ *
+ * Importing `./index` runs the CLI (`main()`), so tooling that wants to drive
+ * the generator in-process — such as the an5Agent `generateClientCode` tool —
+ * imports this module instead.
+ *
+ * The provider is optional and defaults to SQL Server. Pass one derived from
+ * the connection string when the schema targets another database, so field
+ * types are checked against that database's types — `providerForProject` reads
+ * it from the config file for callers that only know the project directory:
+ *
+ * ```ts
+ * import { SchemaParser, RustGenerator, providerForProject } from '@an5/orm/generator';
+ *
+ * const provider = providerForProject(__dirname);
+ * const models = await new SchemaParser('an5Schema', provider).parse();
+ * new RustGenerator('an5Client/rust').generate(models);
+ * ```
+ */
+export { SchemaParser, sqlTypeToTs } from './parser';
+export { CodeGenerator } from './code-generator';
+export { MetadataGenerator } from './metadata-generator';
+export { PythonGenerator } from './python-generator';
+export { DotnetGenerator } from './dotnet-generator';
+export { GolangGenerator } from './golang-generator';
+export { RustGenerator } from './rust-generator';
+export { detectProvider, providerFromConfig, providerForProject } from './config';
+export { dialectFor, defaultClause, sqlLiteral } from './dialect';
+export { fieldKind } from './type-kinds';
+export type { FieldKind } from './type-kinds';
+export type { ColumnSpec, PushDialect } from './dialect';
+export {
+  DEFAULT_PROVIDER,
+  FieldTypeError,
+  PROVIDERS,
+  PROVIDER_FIELD_TYPES,
+  PROVIDER_LABELS,
+  defaultSqlTypeForTs,
+  fieldTypesFor,
+  resolveFieldType,
+  unknownFieldTypeMessage,
+} from './field-types';
+export type { FieldTypeIssue, Provider, TsType } from './field-types';
+export type { Model, Field, Relation } from './types';