ormbridge 0.3.0 → 0.5.0

package/dist/parsers/drizzle.js

@@ -0,0 +1,2040 @@
+import { basename } from 'node:path';
+import { singularize, toCamelCase, toPascalCase, toSnakeCase, } from '../naming.js';
+import { err, ok } from '../result.js';
+import { evaluateNode, getTypeScriptParser, } from './typescriptSyntax.js';
+/** Table builders that start a table definition, by dialect. */
+const TABLE_FUNCTIONS = {
+    pgTable: 'pg',
+    mysqlTable: 'mysql',
+    sqliteTable: 'sqlite',
+};
+/** Table creators (`pgTableCreator((name) => ...)`), by dialect. */
+const TABLE_CREATORS = {
+    pgTableCreator: 'pg',
+    mysqlTableCreator: 'mysql',
+    sqliteTableCreator: 'sqlite',
+};
+/** Schema builders (`pgSchema('auth')`), by dialect. */
+const SCHEMA_FUNCTIONS = {
+    pgSchema: 'pg',
+    mysqlSchema: 'mysql',
+};
+/** Table builders of Drizzle dialects this parser does not read. */
+const UNSUPPORTED_DIALECT_TABLES = {
+    singlestoreTable: 'SingleStore',
+    gelTable: 'Gel',
+    mssqlTable: 'SQL Server',
+    cockroachTable: 'CockroachDB',
+};
+/** Top-level definitions that exist in the database but have no equivalent in the shared model. */
+const UNSUPPORTED_DEFINITIONS = {
+    pgView: 'views',
+    pgMaterializedView: 'materialized views',
+    mysqlView: 'views',
+    sqliteView: 'views',
+    pgSequence: 'sequences',
+    pgRole: 'roles',
+    pgPolicy: 'row level security policies',
+};
+/** PostgreSQL builders that map straight to one IR type. */
+const PG_SIMPLE_TYPES = {
+    serial: 'int',
+    smallserial: 'int',
+    bigserial: 'bigInt',
+    integer: 'int',
+    smallint: 'int',
+    bigint: 'bigInt',
+    real: 'float',
+    doublePrecision: 'float',
+    boolean: 'boolean',
+    text: 'text',
+    uuid: 'uuid',
+    json: 'json',
+    jsonb: 'json',
+    date: 'date',
+    time: 'time',
+    timestamp: 'dateTime',
+    interval: 'duration',
+    inet: 'ipAddress',
+    bytea: 'bytes',
+};
+/** PostgreSQL builders that are auto-incrementing, implicitly NOT NULL columns. */
+const PG_SERIAL_TYPES = new Set([
+    'serial',
+    'smallserial',
+    'bigserial',
+]);
+/** PostgreSQL builders with no IR type, mapped to the SQL type they create. */
+const PG_UNSUPPORTED_TYPES = {
+    point: 'point',
+    line: 'line',
+    macaddr: 'macaddr',
+    macaddr8: 'macaddr8',
+    cidr: 'cidr',
+    geometry: 'geometry',
+    vector: 'vector',
+    halfvec: 'halfvec',
+    sparsevec: 'sparsevec',
+    bit: 'bit',
+};
+const MYSQL_SIMPLE_TYPES = {
+    int: 'int',
+    tinyint: 'int',
+    smallint: 'int',
+    mediumint: 'int',
+    bigint: 'bigInt',
+    float: 'float',
+    double: 'float',
+    real: 'float',
+    boolean: 'boolean',
+    text: 'text',
+    tinytext: 'text',
+    mediumtext: 'text',
+    longtext: 'text',
+    date: 'date',
+    datetime: 'dateTime',
+    timestamp: 'dateTime',
+    time: 'time',
+    year: 'int',
+    json: 'json',
+};
+const SQLITE_SIMPLE_TYPES = {
+    real: 'float',
+};
+const ON_ACTION_MAP = {
+    cascade: 'cascade',
+    'set null': 'setNull',
+    restrict: 'restrict',
+    'no action': 'noAction',
+    'set default': 'setDefault',
+};
+/** Index access methods Prisma knows, spelled the way the IR stores them. */
+const INDEX_METHODS = {
+    btree: 'BTree',
+    hash: 'Hash',
+    gin: 'Gin',
+    gist: 'Gist',
+    spgist: 'SpGist',
+    brin: 'BRIN',
+};
+const NOW_SQL = /^\(?(now\(\)|current_timestamp(\(\d*\))?|localtimestamp(\(\d*\))?|transaction_timestamp\(\)|unixepoch\(\)|datetime\('now'\)|strftime\(.*'now'.*\)|\(unixepoch\(\)\)|\(datetime\('now'\)\))\)?$/i;
+const UUID_SQL = /^(uuid_generate_v[14]\(\)|gen_random_uuid\(\)|uuid\(\)|newid\(\))$/i;
+const QUOTED_SQL = /^'((?:[^']|'')*)'(::[\w\s]+)?$/;
+/** Wrappers that change nothing about the value an expression evaluates to. */
+const TRANSPARENT_NODES = new Set([
+    'parenthesized_expression',
+    'as_expression',
+    'satisfies_expression',
+    'non_null_expression',
+    'type_assertion',
+]);
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+/** Parses Drizzle ORM schema files into the shared IR using tree-sitter (no Node project required). */
+export async function parseDrizzle(sources, options) {
+    const parserResult = await getTypeScriptParser();
+    if (!parserResult.ok) {
+        return parserResult;
+    }
+    const parser = parserResult.value;
+    const project = {
+        files: [],
+        declarators: [],
+        schemas: new Map(),
+        creators: new Map(),
+        helpers: new Map(),
+        enums: new Map(),
+        tables: [],
+        relationDefs: [],
+        warnings: [],
+    };
+    // The trees are kept alive until the schema is built: the syntax nodes below point into them.
+    const trees = [];
+    for (const source of sources) {
+        const tree = parser.parse(source.text);
+        trees.push(tree);
+        const file = describeFile(source.path, tree.rootNode);
+        project.files.push(file);
+        if (tree.rootNode.hasError) {
+            project.warnings.push(`${file.label}: the file contains TypeScript syntax errors; some tables or columns may be missing from the output.`);
+        }
+        project.declarators.push(...topLevelDeclarators(file, tree.rootNode));
+    }
+    collectDeclarations(project);
+    const schema = buildSchema(project, options);
+    if (schema.models.length === 0) {
+        const checkedPaths = sources
+            .map((source) => source.path)
+            .join(', ');
+        return err('NO_MODELS_FOUND', `No Drizzle tables were found in: ${checkedPaths}. A table is a top-level \`export const users = pgTable('users', { ... })\` ` +
+            `(or mysqlTable, sqliteTable, or a table of a pgSchema/mysqlSchema); relations and enums alone do not make a schema.`);
+    }
+    return ok(schema);
+}
+// ---------------------------------------------------------------------------
+// Syntax helpers
+// ---------------------------------------------------------------------------
+function describeFile(path, root) {
+    const aliases = new Map();
+    const namespaces = new Set();
+    for (const statement of root.namedChildren) {
+        if (statement.type !== 'import_statement') {
+            continue;
+        }
+        const stack = [...statement.namedChildren];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (node === undefined) {
+                break;
+            }
+            if (node.type === 'import_specifier') {
+                const nameNode = node.childForFieldName('name');
+                const aliasNode = node.childForFieldName('alias');
+                if (nameNode !== null && aliasNode !== null) {
+                    aliases.set(aliasNode.text, nameNode.text);
+                }
+            }
+            else if (node.type === 'namespace_import') {
+                const nameNode = node.namedChildren[0];
+                if (nameNode !== undefined) {
+                    namespaces.add(nameNode.text);
+                }
+            }
+            else {
+                stack.push(...node.namedChildren);
+            }
+        }
+    }
+    return { path, label: basename(path), aliases, namespaces };
+}
+/** The variable declarators at the top level of a file, including exported ones. */
+function topLevelDeclarators(file, root) {
+    const declarators = [];
+    for (const statement of root.namedChildren) {
+        const declaration = statement.type === 'export_statement'
+            ? (statement.childForFieldName('declaration') ?? statement)
+            : statement;
+        if (declaration.type !== 'lexical_declaration' &&
+            declaration.type !== 'variable_declaration') {
+            continue;
+        }
+        for (const declarator of declaration.namedChildren) {
+            if (declarator.type !== 'variable_declarator') {
+                continue;
+            }
+            const nameNode = declarator.childForFieldName('name');
+            const valueNode = declarator.childForFieldName('value');
+            if (nameNode !== null && valueNode !== null) {
+                declarators.push({ file, name: nameNode.text, node: valueNode });
+            }
+        }
+    }
+    return declarators;
+}
+function stripWrappers(node) {
+    let current = node;
+    while (TRANSPARENT_NODES.has(current.type)) {
+        const inner = current.namedChildren[0];
+        if (inner === undefined) {
+            break;
+        }
+        current = inner;
+    }
+    return current;
+}
+function isFunctionNode(node) {
+    return (node.type === 'arrow_function' ||
+        node.type === 'function_expression' ||
+        node.type === 'function');
+}
+/** The expression a function returns (the body of an arrow, or the sole `return` of a block). */
+function functionResult(fn) {
+    const body = fn.childForFieldName('body');
+    if (body === null) {
+        return undefined;
+    }
+    if (body.type === 'statement_block') {
+        const returned = body.namedChildren.find((statement) => statement.type === 'return_statement');
+        return returned?.namedChildren.find((child) => child.type !== 'comment');
+    }
+    return stripWrappers(body);
+}
+/** The name of the first parameter of a function (`t` in `(t) => [...]`). */
+function functionParameter(fn) {
+    const single = fn.childForFieldName('parameter');
+    if (single !== null) {
+        return single.text;
+    }
+    const parameters = fn.childForFieldName('parameters');
+    const first = parameters?.namedChildren[0];
+    if (first === undefined) {
+        return undefined;
+    }
+    const pattern = first.childForFieldName('pattern');
+    return (pattern ?? first).text;
+}
+function argumentsOf(call) {
+    const argumentsNode = call.childForFieldName('arguments');
+    if (argumentsNode === null) {
+        return [];
+    }
+    // A tagged template (sql`now()`) has the template itself as its arguments node.
+    if (argumentsNode.type === 'template_string') {
+        return [argumentsNode];
+    }
+    return argumentsNode.namedChildren.filter((child) => child.type !== 'comment');
+}
+/**
+ * Splits `a('x').b().c()` into the first call and the calls chained on it. Returns undefined when the
+ * expression is not a call chain at all.
+ */
+function unwindChain(node) {
+    const links = [];
+    let current = stripWrappers(node);
+    for (;;) {
+        if (current.type !== 'call_expression') {
+            return undefined;
+        }
+        const functionNode = current.childForFieldName('function');
+        if (functionNode === null) {
+            return undefined;
+        }
+        const args = argumentsOf(current);
+        if (functionNode.type === 'member_expression') {
+            const objectNode = functionNode.childForFieldName('object');
+            const propertyNode = functionNode.childForFieldName('property');
+            const inner = objectNode === null ? null : stripWrappers(objectNode);
+            if (inner !== null &&
+                propertyNode !== null &&
+                inner.type === 'call_expression' &&
+                !isTaggedTemplate(inner)) {
+                links.unshift({ name: propertyNode.text, args });
+                current = inner;
+                continue;
+            }
+        }
+        return {
+            baseCallee: functionNode.text.replace(/\s+/g, ''),
+            baseArgs: args,
+            links,
+        };
+    }
+}
+function isTaggedTemplate(call) {
+    return call.childForFieldName('arguments')?.type === 'template_string';
+}
+/** The text of an `sql\`...\`` template (or `sql.raw('...')`), or undefined when it is not one. */
+function sqlText(node) {
+    const call = stripWrappers(node);
+    if (call.type !== 'call_expression') {
+        return undefined;
+    }
+    const functionNode = call.childForFieldName('function');
+    const argumentsNode = call.childForFieldName('arguments');
+    if (functionNode === null || argumentsNode === null) {
+        return undefined;
+    }
+    if (functionNode.text === 'sql' && argumentsNode.type === 'template_string') {
+        return {
+            text: argumentsNode.text.slice(1, -1),
+            isDynamic: argumentsNode.namedChildren.some((child) => child.type === 'template_substitution'),
+        };
+    }
+    if (functionNode.text === 'sql.raw') {
+        const value = argumentsOf(call)
+            .map(evaluateNode)
+            .find((candidate) => candidate.kind === 'string');
+        if (value !== undefined && value.kind === 'string') {
+            return { text: value.value, isDynamic: false };
+        }
+    }
+    return undefined;
+}
+/** Reads `table.column` (with chained `.desc()`, `.asc()`, `.op('...')`) as a column reference. */
+function parseColumnRef(node) {
+    let current = stripWrappers(node);
+    let sort;
+    let ops;
+    while (current.type === 'call_expression') {
+        const functionNode = current.childForFieldName('function');
+        if (functionNode === null || functionNode.type !== 'member_expression') {
+            return undefined;
+        }
+        const propertyName = functionNode.childForFieldName('property')?.text ?? '';
+        if (propertyName === 'desc' || propertyName === 'asc') {
+            sort = propertyName;
+        }
+        else if (propertyName === 'op') {
+            const operatorClass = argumentsOf(current)
+                .map(evaluateNode)
+                .find((candidate) => candidate.kind === 'string');
+            if (operatorClass !== undefined && operatorClass.kind === 'string') {
+                ops = `raw("${operatorClass.value}")`;
+            }
+        }
+        const objectNode = functionNode.childForFieldName('object');
+        if (objectNode === null) {
+            return undefined;
+        }
+        current = stripWrappers(objectNode);
+    }
+    if (current.type !== 'member_expression') {
+        return undefined;
+    }
+    const parts = current.text.replace(/\s+/g, '').split('.');
+    const key = parts[parts.length - 1];
+    if (parts.length < 2 || key === undefined || key === '') {
+        return undefined;
+    }
+    return {
+        owner: parts[parts.length - 2],
+        key,
+        ...(sort === undefined ? {} : { sort }),
+        ...(ops === undefined ? {} : { ops }),
+    };
+}
+function columnRefs(node) {
+    if (node === undefined) {
+        return undefined;
+    }
+    const array = stripWrappers(node);
+    if (array.type !== 'array') {
+        return undefined;
+    }
+    const refs = [];
+    for (const item of array.namedChildren) {
+        if (item.type === 'comment') {
+            continue;
+        }
+        const ref = parseColumnRef(item);
+        if (ref === undefined) {
+            return undefined;
+        }
+        refs.push(ref);
+    }
+    return refs;
+}
+/** The value node of a property of an object literal, or undefined. */
+function objectProperty(node, name) {
+    if (node === undefined) {
+        return undefined;
+    }
+    const object = stripWrappers(node);
+    if (object.type !== 'object') {
+        return undefined;
+    }
+    for (const child of object.namedChildren) {
+        if (child.type !== 'pair') {
+            continue;
+        }
+        const keyNode = child.childForFieldName('key');
+        if (keyNode !== null && unquote(keyNode.text) === name) {
+            return child.childForFieldName('value') ?? undefined;
+        }
+    }
+    return undefined;
+}
+function unquote(text) {
+    return /^(["'`]).*\1$/s.test(text) ? text.slice(1, -1) : text;
+}
+function stringValue(node) {
+    if (node === undefined) {
+        return undefined;
+    }
+    const value = evaluateNode(node);
+    return value.kind === 'string' ? value.value : undefined;
+}
+function objectValue(node) {
+    if (node === undefined) {
+        return undefined;
+    }
+    const value = evaluateNode(node);
+    return value.kind === 'object' ? value : undefined;
+}
+function stringOption(options, key) {
+    const value = options?.properties[key];
+    return value !== undefined && value.kind === 'string'
+        ? value.value
+        : undefined;
+}
+function numberOption(options, key) {
+    const value = options?.properties[key];
+    return value !== undefined && value.kind === 'number'
+        ? value.value
+        : undefined;
+}
+function boolOption(options, key) {
+    const value = options?.properties[key];
+    return value !== undefined && value.kind === 'bool' ? value.value : undefined;
+}
+/** Local import aliases resolved to the imported name (`table` -> `pgTable`). */
+function canonicalName(file, name) {
+    return file.aliases.get(name) ?? name;
+}
+/** Splits a callee into an optional object (`mySchema`) and a name (`table`), resolving import aliases. */
+function parseCallee(file, callee) {
+    const parts = callee.split('.');
+    const name = canonicalName(file, parts[parts.length - 1] ?? callee);
+    if (parts.length === 1) {
+        return { object: undefined, name };
+    }
+    const object = parts.slice(0, -1).join('.');
+    return file.namespaces.has(object)
+        ? { object: undefined, name }
+        : { object: canonicalName(file, object), name };
+}
+/** Evaluates a value that may be written inline or kept in a top-level constant. */
+function resolveValue(node, project) {
+    const value = evaluateNode(node);
+    if (value.kind === 'name') {
+        const helper = project.helpers.get(value.value);
+        if (helper !== undefined) {
+            return evaluateNode(helper);
+        }
+    }
+    return value;
+}
+// ---------------------------------------------------------------------------
+// Declarations (first pass over every file)
+// ---------------------------------------------------------------------------
+/** Template literal `prefix_${name}` as a function of the name, or undefined when it has another shape. */
+function creatorTransform(node) {
+    if (node === undefined) {
+        return undefined;
+    }
+    const fn = stripWrappers(node);
+    if (!isFunctionNode(fn)) {
+        return undefined;
+    }
+    const parameter = functionParameter(fn);
+    const result = functionResult(fn);
+    if (parameter === undefined || result === undefined) {
+        return undefined;
+    }
+    if (result.type === 'identifier' && result.text === parameter) {
+        return (name) => name;
+    }
+    if (result.type !== 'template_string') {
+        return undefined;
+    }
+    let prefix = '';
+    let suffix = '';
+    let seenName = false;
+    for (const part of result.namedChildren) {
+        if (part.type === 'template_substitution') {
+            const expression = part.namedChildren[0];
+            if (seenName ||
+                expression === undefined ||
+                expression.text !== parameter) {
+                return undefined;
+            }
+            seenName = true;
+        }
+        else if (seenName) {
+            suffix += part.text;
+        }
+        else {
+            prefix += part.text;
+        }
+    }
+    return seenName
+        ? (name) => `${prefix}${name}${suffix}`
+        : undefined;
+}
+/** Sorts the top-level declarations into schemas, creators, enums, tables, relations and helpers. */
+function collectDeclarations(project) {
+    // Schemas, creators and helpers first: tables and enums can refer to them from any file.
+    for (const declarator of project.declarators) {
+        const node = stripWrappers(declarator.node);
+        if (node.type === 'object') {
+            project.helpers.set(declarator.name, node);
+            continue;
+        }
+        if (node.type === 'array') {
+            project.helpers.set(declarator.name, node);
+            continue;
+        }
+        if (isFunctionNode(node)) {
+            const result = functionResult(node);
+            if (result !== undefined) {
+                project.helpers.set(declarator.name, result);
+            }
+            continue;
+        }
+        const chain = unwindChain(node);
+        if (chain === undefined) {
+            continue;
+        }
+        const callee = parseCallee(declarator.file, chain.baseCallee);
+        if (callee.object !== undefined) {
+            continue;
+        }
+        const schemaDialect = SCHEMA_FUNCTIONS[callee.name];
+        if (schemaDialect !== undefined) {
+            const dbName = stringValue(chain.baseArgs[0]);
+            if (dbName === undefined) {
+                project.warnings.push(`${declarator.file.label}: the schema "${declarator.name}" has a name that is not a string literal; its tables were read without a schema.`);
+            }
+            else {
+                project.schemas.set(declarator.name, {
+                    dbName,
+                    dialect: schemaDialect,
+                });
+            }
+            continue;
+        }
+        const creatorDialect = TABLE_CREATORS[callee.name];
+        if (creatorDialect !== undefined) {
+            const transform = creatorTransform(chain.baseArgs[0]);
+            if (transform === undefined) {
+                project.warnings.push(`${declarator.file.label}: the table creator "${declarator.name}" does not map names with a plain template such as \`app_\${name}\`; ` +
+                    `the tables made with it keep the name they were given, without the prefix.`);
+            }
+            project.creators.set(declarator.name, {
+                dialect: creatorDialect,
+                transform,
+            });
+        }
+    }
+    for (const declarator of project.declarators) {
+        const chain = unwindChain(declarator.node);
+        if (chain === undefined) {
+            continue;
+        }
+        collectCall(project, declarator, chain);
+    }
+}
+function collectCall(project, declarator, chain) {
+    const file = declarator.file;
+    const callee = parseCallee(file, chain.baseCallee);
+    const schema = callee.object === undefined
+        ? undefined
+        : project.schemas.get(callee.object);
+    const creator = callee.object === undefined ? project.creators.get(callee.name) : undefined;
+    const tableDialect = callee.object === undefined
+        ? TABLE_FUNCTIONS[callee.name]
+        : callee.name === 'table' && schema !== undefined
+            ? schema.dialect
+            : undefined;
+    if (tableDialect !== undefined || creator !== undefined) {
+        const dialect = tableDialect ?? creator?.dialect;
+        if (dialect === undefined) {
+            return;
+        }
+        for (const link of chain.links) {
+            project.warnings.push(`${file.label}: table "${declarator.name}": the chained .${link.name}() call is not represented in the shared model and was ignored.`);
+        }
+        project.tables.push({
+            file,
+            varName: declarator.name,
+            dialect,
+            ...(schema === undefined ? {} : { schema: schema.dbName }),
+            ...(creator === undefined ? {} : { creator }),
+            nameNode: chain.baseArgs[0],
+            columnsNode: chain.baseArgs[1],
+            extraNode: chain.baseArgs[2],
+        });
+        return;
+    }
+    if (callee.object === undefined && callee.name === 'pgEnum') {
+        registerEnum(project, declarator, chain, undefined);
+        return;
+    }
+    if (callee.name === 'enum' && schema !== undefined) {
+        registerEnum(project, declarator, chain, schema.dbName);
+        return;
+    }
+    if (callee.object === undefined && callee.name === 'relations') {
+        registerRelations(project, declarator, chain);
+        return;
+    }
+    if (callee.object === undefined && callee.name === 'defineRelations') {
+        project.warnings.push(`${file.label}: defineRelations (Drizzle relational queries v2) is not supported; "${declarator.name}" was skipped, so the relation names and reverse sides it defines are not read. ` +
+            `Foreign keys declared with .references() or foreignKey() are still read.`);
+        return;
+    }
+    const unsupportedDialect = callee.object === undefined
+        ? UNSUPPORTED_DIALECT_TABLES[callee.name]
+        : undefined;
+    if (unsupportedDialect !== undefined) {
+        project.warnings.push(`${file.label}: table "${declarator.name}" uses the ${unsupportedDialect} dialect (${callee.name}), which is not supported; it was skipped.`);
+        return;
+    }
+    const unsupportedDefinition = callee.object === undefined
+        ? UNSUPPORTED_DEFINITIONS[callee.name]
+        : undefined;
+    if (unsupportedDefinition !== undefined) {
+        project.warnings.push(`${file.label}: "${declarator.name}" defines ${unsupportedDefinition} (${callee.name}), which the shared model cannot represent; it was skipped.`);
+    }
+    if (callee.object !== undefined &&
+        schema !== undefined &&
+        UNSUPPORTED_DEFINITIONS[`pg${toPascalCase(callee.name)}`] !== undefined) {
+        project.warnings.push(`${file.label}: "${declarator.name}" defines ${UNSUPPORTED_DEFINITIONS[`pg${toPascalCase(callee.name)}`] ?? 'objects'} (${callee.object}.${callee.name}), which the shared model cannot represent; it was skipped.`);
+    }
+}
+/** Derives an enum member name from a stored value, for example "in-progress" -> "IN_PROGRESS". */
+function enumMemberName(value) {
+    const snake = toSnakeCase(value).toUpperCase();
+    if (snake === '') {
+        return 'EMPTY';
+    }
+    return /^[0-9]/.test(snake) ? `V_${snake}` : snake;
+}
+function enumValuesOf(values, unique = true) {
+    const used = new Set();
+    return values.map((dbValue) => {
+        let name = enumMemberName(dbValue);
+        while (unique && used.has(name)) {
+            name = `${name}_`;
+        }
+        used.add(name);
+        return { name, dbValue };
+    });
+}
+function registerEnum(project, declarator, chain, schema) {
+    const label = declarator.file.label;
+    const dbName = stringValue(chain.baseArgs[0]);
+    const valuesNode = chain.baseArgs[1];
+    const values = valuesNode === undefined ? undefined : resolveValue(valuesNode, project);
+    if (dbName === undefined ||
+        values === undefined ||
+        values.kind !== 'array' ||
+        !values.items.every((item) => item.kind === 'string')) {
+        project.warnings.push(`${label}: the enum "${declarator.name}" is not defined with a string literal name and a literal list of strings; it was skipped.`);
+        return;
+    }
+    // Drizzle code conventionally names the constant `statusEnum`; the enum itself is `Status`. The
+    // emitter appends the suffix again, so stripping one `Enum` keeps the round trip stable.
+    const pascalName = toPascalCase(declarator.name);
+    const name = pascalName.length > 'Enum'.length && pascalName.endsWith('Enum')
+        ? pascalName.slice(0, -'Enum'.length)
+        : pascalName;
+    project.enums.set(declarator.name, {
+        varName: declarator.name,
+        ir: {
+            name,
+            values: enumValuesOf(values.items.flatMap((item) => item.kind === 'string' ? [item.value] : [])),
+            ...(dbName === name ? {} : { dbName }),
+            ...(schema === undefined ? {} : { schema }),
+        },
+    });
+}
+function registerRelations(project, declarator, chain) {
+    const file = declarator.file;
+    const tableRef = chain.baseArgs[0];
+    const callback = chain.baseArgs[1] === undefined
+        ? undefined
+        : stripWrappers(chain.baseArgs[1]);
+    if (tableRef === undefined || callback === undefined) {
+        return;
+    }
+    const tableVar = canonicalName(file, tableRef.text.split('.').pop() ?? tableRef.text);
+    const result = isFunctionNode(callback)
+        ? functionResult(callback)
+        : undefined;
+    if (result === undefined || result.type !== 'object') {
+        project.warnings.push(`${file.label}: the relations of "${tableVar}" are not defined by a callback returning an object literal; they were skipped.`);
+        return;
+    }
+    const entries = [];
+    for (const child of result.namedChildren) {
+        if (child.type === 'comment') {
+            continue;
+        }
+        if (child.type !== 'pair') {
+            project.warnings.push(`${file.label}: the relations of "${tableVar}" contain a spread or computed entry (${child.text}); it was skipped.`);
+            continue;
+        }
+        const keyNode = child.childForFieldName('key');
+        const valueNode = child.childForFieldName('value');
+        const call = valueNode === null ? undefined : unwindChain(valueNode);
+        const kindName = call?.baseCallee.split('.').pop();
+        if (keyNode === null ||
+            call === undefined ||
+            (kindName !== 'one' && kindName !== 'many')) {
+            project.warnings.push(`${file.label}: the relation "${tableVar}.${keyNode === null ? '?' : unquote(keyNode.text)}" is not written as one(...) or many(...); it was skipped.`);
+            continue;
+        }
+        const targetNode = call.baseArgs[0];
+        const config = call.baseArgs[1];
+        if (targetNode === undefined) {
+            continue;
+        }
+        const relationName = stringValue(objectProperty(config, 'relationName'));
+        entries.push({
+            key: unquote(keyNode.text),
+            kind: kindName,
+            targetVar: canonicalName(file, targetNode.text.split('.').pop() ?? targetNode.text),
+            fields: columnRefs(objectProperty(config, 'fields')),
+            references: columnRefs(objectProperty(config, 'references')),
+            relationName,
+        });
+    }
+    project.relationDefs.push({ file, tableVar, entries });
+}
+// ---------------------------------------------------------------------------
+// Tables and columns
+// ---------------------------------------------------------------------------
+function tableLabel(table) {
+    const decl = 'decl' in table ? table.decl : table;
+    return `${decl.file.label}: table "${decl.varName}"`;
+}
+/** A model name from the variable a table is assigned to: `blogPosts` -> `BlogPost`. */
+function modelNameOf(varName) {
+    return toPascalCase(singularize(toSnakeCase(varName)));
+}
+function buildSchema(project, options) {
+    const warnings = project.warnings;
+    const tables = [];
+    const usedModelNames = new Set();
+    const usedVars = new Set();
+    for (const decl of project.tables) {
+        if (usedVars.has(decl.varName)) {
+            warnings.push(`${tableLabel(decl)}: another table with the same variable name was already read; this one was skipped.`);
+            continue;
+        }
+        const tableName = stringValue(decl.nameNode);
+        if (tableName === undefined) {
+            warnings.push(`${tableLabel(decl)}: the table name is not a string literal, so the table was skipped.`);
+            continue;
+        }
+        usedVars.add(decl.varName);
+        let modelName = modelNameOf(decl.varName);
+        if (usedModelNames.has(modelName)) {
+            modelName = toPascalCase(decl.varName);
+        }
+        if (usedModelNames.has(modelName)) {
+            warnings.push(`${tableLabel(decl)}: the model name "${modelName}" is already taken by another table; this table was skipped.`);
+            continue;
+        }
+        usedModelNames.add(modelName);
+        let dbName = tableName;
+        if (decl.creator !== undefined && decl.creator.transform !== undefined) {
+            dbName = decl.creator.transform(tableName);
+        }
+        tables.push({
+            decl,
+            modelName,
+            dbName,
+            columns: [],
+            foreignKeys: [],
+            indexes: [],
+            primaryKey: undefined,
+        });
+    }
+    const enums = [...project.enums.values()].map((declared) => declared.ir);
+    for (const table of tables) {
+        buildColumns(table, project, enums);
+        parseExtras(table, project);
+    }
+    const byVar = new Map(tables.map((table) => [table.decl.varName, table]));
+    const owners = collectOwners(tables, byVar, project);
+    linkReverseSides(tables, byVar, owners, project);
+    const models = tables.map((table) => finalizeModel(table, byVar, owners, warnings, options));
+    addStubModels(models, warnings, options);
+    return { models, enums, warnings };
+}
+/** Reads the `{ key: column, ... }` object of a table, expanding spreads of shared column sets. */
+function columnEntries(node, table, project, seen = new Set()) {
+    if (node === undefined) {
+        return [];
+    }
+    const object = stripWrappers(node);
+    const label = tableLabel(table);
+    if (object.type === 'identifier') {
+        const helper = project.helpers.get(object.text);
+        if (helper === undefined || seen.has(object.text)) {
+            project.warnings.push(`${label}: the columns are not an object literal (${object.text}); the table has no columns.`);
+            return [];
+        }
+        return columnEntries(helper, table, project, new Set([...seen, object.text]));
+    }
+    if (object.type !== 'object') {
+        project.warnings.push(`${label}: the columns are not an object literal; the table has no columns.`);
+        return [];
+    }
+    const entries = [];
+    for (const child of object.namedChildren) {
+        if (child.type === 'comment') {
+            continue;
+        }
+        if (child.type === 'pair') {
+            const keyNode = child.childForFieldName('key');
+            const valueNode = child.childForFieldName('value');
+            if (keyNode !== null && valueNode !== null) {
+                entries.push({ key: unquote(keyNode.text), value: valueNode });
+            }
+        }
+        else if (child.type === 'spread_element') {
+            const spread = child.namedChildren[0];
+            const target = spread === undefined
+                ? undefined
+                : spread.type === 'call_expression'
+                    ? (spread.childForFieldName('function') ?? undefined)
+                    : spread;
+            const name = target?.text;
+            const helper = name === undefined ? undefined : project.helpers.get(name);
+            if (name === undefined || helper === undefined || seen.has(name)) {
+                project.warnings.push(`${label}: the spread "${child.text}" cannot be resolved to a column object defined in the input; its columns were skipped.`);
+                continue;
+            }
+            entries.push(...columnEntries(helper, table, project, new Set([...seen, name])));
+        }
+        else {
+            project.warnings.push(`${label}: the entry "${child.text}" is not a "name: column" pair and was skipped.`);
+        }
+    }
+    return entries;
+}
+function buildColumns(table, project, enums) {
+    const seenKeys = new Set();
+    for (const entry of columnEntries(table.decl.columnsNode, table, project)) {
+        if (seenKeys.has(entry.key)) {
+            continue;
+        }
+        seenKeys.add(entry.key);
+        const column = buildColumn(table, entry.key, entry.value, project, enums);
+        if (column !== undefined) {
+            table.columns.push(column);
+        }
+    }
+}
+/** Resolves the builder call of a column, following one level of user-written column helpers. */
+function resolveChain(table, node, project) {
+    const chain = unwindChain(node);
+    if (chain === undefined) {
+        return undefined;
+    }
+    const callee = parseCallee(table.decl.file, chain.baseCallee);
+    const helper = callee.object === undefined ? project.helpers.get(callee.name) : undefined;
+    if (helper === undefined || BUILTIN_BUILDERS.has(callee.name)) {
+        return { chain, fallbackName: undefined };
+    }
+    const inner = unwindChain(helper);
+    if (inner === undefined) {
+        return { chain, fallbackName: undefined };
+    }
+    return {
+        chain: {
+            baseCallee: inner.baseCallee,
+            baseArgs: inner.baseArgs,
+            links: [...inner.links, ...chain.links],
+        },
+        fallbackName: stringValue(chain.baseArgs[0]),
+    };
+}
+/** Every builder name this parser knows; a user helper never shadows one of them. */
+const BUILTIN_BUILDERS = new Set([
+    ...Object.keys(PG_SIMPLE_TYPES),
+    ...Object.keys(PG_UNSUPPORTED_TYPES),
+    ...Object.keys(MYSQL_SIMPLE_TYPES),
+    ...Object.keys(SQLITE_SIMPLE_TYPES),
+    'varchar',
+    'char',
+    'numeric',
+    'decimal',
+    'binary',
+    'varbinary',
+    'mysqlEnum',
+    'integer',
+    'text',
+    'blob',
+]);
+function buildColumn(table, key, node, project, enums) {
+    const label = `${tableLabel(table)}, column "${key}"`;
+    const resolved = resolveChain(table, node, project);
+    if (resolved === undefined) {
+        project.warnings.push(`${label}: the column is not written as a builder call such as integer('name'); it was skipped.`);
+        return undefined;
+    }
+    const { chain, fallbackName } = resolved;
+    const callee = parseCallee(table.decl.file, chain.baseCallee);
+    const builder = callee.name;
+    // The first argument is the column name; builders also accept the options object first.
+    const firstArg = chain.baseArgs[0];
+    const firstValue = firstArg === undefined ? undefined : evaluateNode(firstArg);
+    const config = firstValue?.kind === 'object' ? firstValue : objectValue(chain.baseArgs[1]);
+    let columnName = key;
+    if (firstValue?.kind === 'string') {
+        columnName = firstValue.value;
+    }
+    else if (firstValue !== undefined && firstValue.kind !== 'object') {
+        if (fallbackName !== undefined) {
+            columnName = fallbackName;
+        }
+        else {
+            project.warnings.push(`${label}: the column name is not a string literal; the property name "${key}" was used.`);
+        }
+    }
+    const field = {
+        name: key,
+        columnName,
+        type: 'string',
+        isPrimaryKey: false,
+        isUnique: false,
+        isNullable: true,
+        isAutoUpdated: false,
+    };
+    let isNotNull = false;
+    const enumDecl = callee.object === undefined ? project.enums.get(builder) : undefined;
+    let resolvedType;
+    if (enumDecl !== undefined) {
+        resolvedType = { type: 'string' };
+        field.enumName = enumDecl.ir.name;
+    }
+    else if (builder === 'mysqlEnum' && table.decl.dialect === 'mysql') {
+        const values = chain.baseArgs[1] === undefined
+            ? undefined
+            : resolveValue(chain.baseArgs[1], project);
+        if (values?.kind === 'array') {
+            const inline = inlineEnum(table, key, values.items, enums, project);
+            field.enumName = inline.name;
+            resolvedType = { type: 'string' };
+        }
+        else {
+            project.warnings.push(`${label}: mysqlEnum is not given a literal list of values; the column was read as a string.`);
+            resolvedType = { type: 'string' };
+        }
+    }
+    else {
+        resolvedType = resolveType(table.decl.dialect, builder, config);
+        if (resolvedType === undefined) {
+            resolvedType = {
+                type: 'unsupported',
+                unsupportedType: builder,
+                note: `the column builder "${chain.baseCallee}" is not a ${dialectName(table.decl.dialect)} column type this parser knows; ` +
+                    `the column was kept as an unsupported "${builder}" column.`,
+            };
+        }
+    }
+    field.type = resolvedType.type;
+    if (resolvedType.maxLength !== undefined) {
+        field.maxLength = resolvedType.maxLength;
+    }
+    if (resolvedType.maxDigits !== undefined) {
+        field.maxDigits = resolvedType.maxDigits;
+    }
+    if (resolvedType.decimalPlaces !== undefined) {
+        field.decimalPlaces = resolvedType.decimalPlaces;
+    }
+    if (resolvedType.unsupportedType !== undefined) {
+        field.unsupportedType = resolvedType.unsupportedType;
+        if (enumDecl === undefined && resolvedType.note === undefined) {
+            project.warnings.push(`${label}: the column type "${resolvedType.unsupportedType}" has no equivalent in the shared model and was kept as an unsupported column.`);
+        }
+    }
+    if (resolvedType.note !== undefined) {
+        project.warnings.push(`${label}: ${resolvedType.note}`);
+    }
+    if (resolvedType.autoIncrement === true) {
+        field.default = { kind: 'autoIncrement' };
+    }
+    if (resolvedType.notNull === true) {
+        isNotNull = true;
+    }
+    if (resolvedType.unique === true) {
+        field.isUnique = true;
+    }
+    if (config !== undefined && boolOption(config, 'unsigned') === true) {
+        project.warnings.push(`${label}: unsigned integers are not represented in the shared model; the column was read as a signed integer.`);
+    }
+    let defaultNode;
+    let hasDefaultFn = false;
+    for (const link of chain.links) {
+        switch (link.name) {
+            case 'notNull':
+                isNotNull = true;
+                break;
+            case 'primaryKey': {
+                field.isPrimaryKey = true;
+                isNotNull = true;
+                if (boolOption(objectValue(link.args[0]), 'autoIncrement') === true) {
+                    field.default = { kind: 'autoIncrement' };
+                }
+                break;
+            }
+            case 'autoincrement':
+            case 'generatedAlwaysAsIdentity':
+            case 'generatedByDefaultAsIdentity':
+                field.default = { kind: 'autoIncrement' };
+                break;
+            case 'unique': {
+                field.isUnique = true;
+                const constraintName = stringValue(link.args[0]);
+                if (constraintName !== undefined) {
+                    field.uniqueName = constraintName;
+                }
+                if (link.args.some((arg) => arg.type === 'object')) {
+                    project.warnings.push(`${label}: the unique constraint options (NULLS NOT DISTINCT) are not represented in the shared model and were ignored.`);
+                }
+                break;
+            }
+            case 'default':
+                defaultNode = link.args[0];
+                break;
+            case 'defaultNow':
+                field.default = { kind: 'now' };
+                break;
+            case 'defaultRandom':
+                field.default = { kind: 'uuid' };
+                break;
+            case '$defaultFn':
+            case '$default':
+                hasDefaultFn = true;
+                applyClientDefault(field, link.args[0], label, project);
+                break;
+            case '$onUpdate':
+            case '$onUpdateFn':
+                applyOnUpdate(field, label, project);
+                break;
+            case 'onUpdateNow':
+                field.isAutoUpdated = true;
+                break;
+            case 'array':
+                field.arrayDepth = (field.arrayDepth ?? 0) + 1;
+                break;
+            case 'references':
+                addReference(table, key, link.args, label, project);
+                break;
+            case 'generatedAlwaysAs':
+                applyGenerated(field, link.args, label, project);
+                break;
+            case '$type':
+            case 'notnull':
+                break;
+            default:
+                project.warnings.push(`${label}: the .${link.name}() modifier is not represented in the shared model and was ignored.`);
+                break;
+        }
+    }
+    if (defaultNode !== undefined) {
+        if (hasDefaultFn) {
+            project.warnings.push(`${label}: both .default() and a client-side default are set; the .default() value is used.`);
+        }
+        const converted = convertDefault(defaultNode, field, label, project, enumDecl?.ir ?? enums.find((item) => item.name === field.enumName));
+        if (converted !== undefined) {
+            field.default = converted;
+        }
+    }
+    if (field.isAutoUpdated && field.default?.kind === 'now') {
+        // An auto-updated column is stamped on every write, so the other readers do not carry a separate "now" default.
+        delete field.default;
+    }
+    if (field.isPrimaryKey) {
+        isNotNull = true;
+        field.isUnique = false;
+    }
+    field.isNullable = !isNotNull;
+    return { key, field, isNotNull };
+}
+function dialectName(dialect) {
+    switch (dialect) {
+        case 'pg':
+            return 'PostgreSQL';
+        case 'mysql':
+            return 'MySQL';
+        default:
+            return 'SQLite';
+    }
+}
+/** A MySQL `mysqlEnum` column becomes an enum named after the table and the column. */
+function inlineEnum(table, key, items, enums, project) {
+    const values = items.flatMap((item) => item.kind === 'string' ? [item.value] : []);
+    if (values.length !== items.length) {
+        project.warnings.push(`${tableLabel(table)}, column "${key}": some mysqlEnum values are not string literals and were skipped.`);
+    }
+    let name = `${table.modelName}${toPascalCase(key)}`;
+    while (enums.some((item) => item.name === name)) {
+        name = `${name}Enum`;
+    }
+    const created = {
+        name,
+        values: enumValuesOf(values),
+        ...(table.decl.schema === undefined ? {} : { schema: table.decl.schema }),
+    };
+    enums.push(created);
+    return created;
+}
+/** Maps a column builder to an IR type. Returns undefined for a builder the dialect does not have. */
+function resolveType(dialect, builder, config) {
+    const length = numberOption(config, 'length');
+    const precision = numberOption(config, 'precision');
+    const scale = numberOption(config, 'scale');
+    const mode = stringOption(config, 'mode');
+    const decimalType = () => ({
+        type: 'decimal',
+        ...(precision === undefined ? {} : { maxDigits: precision }),
+        ...(scale === undefined ? {} : { decimalPlaces: scale }),
+    });
+    if (dialect === 'pg') {
+        const simple = PG_SIMPLE_TYPES[builder];
+        if (simple !== undefined) {
+            const serial = PG_SERIAL_TYPES.has(builder);
+            return {
+                type: simple,
+                ...(serial ? { autoIncrement: true, notNull: true } : {}),
+            };
+        }
+        switch (builder) {
+            case 'varchar':
+                return {
+                    type: 'string',
+                    ...(length === undefined ? {} : { maxLength: length }),
+                };
+            case 'char':
+                return { type: 'string', maxLength: length ?? 1 };
+            case 'numeric':
+            case 'decimal':
+                return decimalType();
+            default:
+                break;
+        }
+        const unsupported = PG_UNSUPPORTED_TYPES[builder];
+        if (unsupported !== undefined) {
+            const dimensions = numberOption(config, 'dimensions');
+            return {
+                type: 'unsupported',
+                unsupportedType: dimensions === undefined
+                    ? unsupported
+                    : `${unsupported}(${dimensions})`,
+            };
+        }
+        return undefined;
+    }
+    if (dialect === 'mysql') {
+        const simple = MYSQL_SIMPLE_TYPES[builder];
+        if (simple !== undefined) {
+            return { type: simple };
+        }
+        switch (builder) {
+            case 'serial':
+                return {
+                    type: 'bigInt',
+                    autoIncrement: true,
+                    notNull: true,
+                    unique: true,
+                };
+            case 'varchar':
+            case 'char':
+                return {
+                    type: 'string',
+                    ...(length === undefined
+                        ? builder === 'char'
+                            ? { maxLength: 1 }
+                            : {}
+                        : { maxLength: length }),
+                };
+            case 'decimal':
+            case 'numeric':
+                return decimalType();
+            case 'binary':
+            case 'varbinary':
+                return {
+                    type: 'bytes',
+                    ...(length === undefined ? {} : { maxLength: length }),
+                };
+            default:
+                return undefined;
+        }
+    }
+    // SQLite
+    const simple = SQLITE_SIMPLE_TYPES[builder];
+    if (simple !== undefined) {
+        return { type: simple };
+    }
+    switch (builder) {
+        case 'integer':
+            if (mode === 'timestamp' || mode === 'timestamp_ms') {
+                return {
+                    type: 'dateTime',
+                    note: `integer({ mode: '${mode}' }) stores Unix time as an integer; it was read as a date-time column.`,
+                };
+            }
+            return { type: mode === 'boolean' ? 'boolean' : 'int' };
+        case 'text':
+            if (mode === 'json') {
+                return { type: 'json' };
+            }
+            return length === undefined
+                ? { type: 'text' }
+                : { type: 'string', maxLength: length };
+        case 'blob':
+            if (mode === 'json') {
+                return { type: 'json' };
+            }
+            return { type: mode === 'bigint' ? 'bigInt' : 'bytes' };
+        case 'numeric':
+            return { type: 'decimal' };
+        default:
+            return undefined;
+    }
+}
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+function describeNode(node) {
+    const text = (node?.text ?? '').replace(/\s+/g, ' ');
+    return text.length > 60 ? `${text.slice(0, 57)}...` : text;
+}
+function applyClientDefault(field, fn, label, project) {
+    const source = describeNode(fn);
+    const result = fn === undefined || !isFunctionNode(stripWrappers(fn))
+        ? undefined
+        : functionResult(stripWrappers(fn));
+    const body = result?.text ?? '';
+    if (field.type === 'uuid' &&
+        /randomUUID\s*\(|\buuid(v4)?\s*\(|\bv4\s*\(/i.test(body)) {
+        field.default = { kind: 'uuid' };
+        project.warnings.push(`${label}: $defaultFn(${source}) is generated in application code; it was read as a generated UUID default, which the target generates instead.`);
+        return;
+    }
+    if ((field.type === 'dateTime' || field.type === 'date') &&
+        /^(new Date\(\)|Date\.now\(\)|sql`now\(\)`)$/.test(body)) {
+        field.default = { kind: 'now' };
+        project.warnings.push(`${label}: $defaultFn(${source}) is evaluated in application code; it was read as a "now" default, which the target applies in the database instead.`);
+        return;
+    }
+    project.warnings.push(`${label}: $defaultFn(${source}) is a client-side default computed in application code; it has no equivalent in the shared model and was dropped.`);
+}
+function applyOnUpdate(field, label, project) {
+    if (field.type === 'dateTime' ||
+        field.type === 'date' ||
+        field.type === 'time') {
+        field.isAutoUpdated = true;
+        return;
+    }
+    project.warnings.push(`${label}: $onUpdate on a ${field.type} column is not represented in the shared model (only date-time columns refresh on update); it was ignored.`);
+}
+function applyGenerated(field, args, label, project) {
+    const expressionNode = args[0];
+    const expression = expressionNode === undefined
+        ? undefined
+        : isFunctionNode(stripWrappers(expressionNode))
+            ? functionResult(stripWrappers(expressionNode))
+            : expressionNode;
+    const sql = expression === undefined ? undefined : sqlText(expression);
+    if (sql === undefined) {
+        project.warnings.push(`${label}: the generated column expression could not be read statically; the column was read as an ordinary column.`);
+        return;
+    }
+    const mode = stringOption(objectValue(args[1]), 'mode');
+    field.generated = {
+        expression: sql.text.trim(),
+        isStored: mode !== 'virtual',
+    };
+    if (sql.isDynamic) {
+        project.warnings.push(`${label}: the generated column expression refers to other columns through \${...}; the expression text is kept as written.`);
+    }
+}
+function jsonText(value) {
+    switch (value.kind) {
+        case 'string':
+            return JSON.stringify(value.value);
+        case 'number':
+            return String(value.value);
+        case 'bool':
+            return value.value ? 'true' : 'false';
+        case 'null':
+            return 'null';
+        case 'array': {
+            const items = value.items.map(jsonText);
+            return items.every((item) => item !== undefined)
+                ? `[${items.join(',')}]`
+                : undefined;
+        }
+        case 'object': {
+            const parts = [];
+            for (const [key, item] of Object.entries(value.properties)) {
+                const text = jsonText(item);
+                if (text === undefined) {
+                    return undefined;
+                }
+                parts.push(`${JSON.stringify(key)}:${text}`);
+            }
+            return `{${parts.join(',')}}`;
+        }
+        default:
+            return undefined;
+    }
+}
+function convertDefault(node, field, label, project, enumeration) {
+    const sql = sqlText(node);
+    if (sql !== undefined) {
+        if (sql.isDynamic) {
+            project.warnings.push(`${label}: the default sql\`${sql.text}\` refers to other values through \${...} and cannot be read statically; it was dropped.`);
+            return undefined;
+        }
+        return convertSqlDefault(sql.text, field, enumeration);
+    }
+    const value = resolveValue(stripWrappers(node), project);
+    switch (value.kind) {
+        case 'null':
+            return undefined;
+        case 'bool':
+            return { kind: 'literal', value: value.value };
+        case 'number':
+            return { kind: 'literal', value: value.value };
+        case 'string': {
+            const member = enumeration?.values.find((candidate) => candidate.dbValue === value.value);
+            if (member !== undefined) {
+                return { kind: 'enumValue', value: member.name };
+            }
+            if (/^-?\d+(\.\d+)?$/.test(value.value) &&
+                (field.type === 'decimal' ||
+                    field.type === 'int' ||
+                    field.type === 'bigInt' ||
+                    field.type === 'float')) {
+                return { kind: 'literal', value: Number(value.value) };
+            }
+            return { kind: 'literal', value: value.value };
+        }
+        case 'object':
+        case 'array': {
+            const text = jsonText(value);
+            if (text !== undefined &&
+                field.type === 'json' &&
+                field.arrayDepth === undefined) {
+                return { kind: 'literal', value: text };
+            }
+            break;
+        }
+        case 'other': {
+            const bigint = /^(-?\d+)n$/.exec(value.text);
+            if (bigint !== null) {
+                return { kind: 'literal', value: Number(bigint[1]) };
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    project.warnings.push(`${label}: the default value (${describeNode(node)}) cannot be evaluated statically and was dropped.`);
+    return undefined;
+}
+function convertSqlDefault(sql, field, enumeration) {
+    const trimmed = sql.trim();
+    if (NOW_SQL.test(trimmed)) {
+        return { kind: 'now' };
+    }
+    if (UUID_SQL.test(trimmed)) {
+        return { kind: 'uuid' };
+    }
+    if (/^null$/i.test(trimmed)) {
+        return undefined;
+    }
+    if (/^(true|false)$/i.test(trimmed)) {
+        return { kind: 'literal', value: trimmed.toLowerCase() === 'true' };
+    }
+    if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+        return field.type === 'string' || field.type === 'text'
+            ? { kind: 'literal', value: trimmed }
+            : { kind: 'literal', value: Number(trimmed) };
+    }
+    const quoted = QUOTED_SQL.exec(trimmed);
+    if (quoted !== null) {
+        const text = (quoted[1] ?? '').replace(/''/g, "'");
+        const member = enumeration?.values.find((candidate) => candidate.dbValue === text);
+        if (member !== undefined) {
+            return { kind: 'enumValue', value: member.name };
+        }
+        return { kind: 'literal', value: text };
+    }
+    return { kind: 'dbExpression', expression: trimmed };
+}
+// ---------------------------------------------------------------------------
+// Foreign keys, indexes and keys declared in the table callback
+// ---------------------------------------------------------------------------
+function mapAction(value, what, label, project) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const mapped = ON_ACTION_MAP[value.toLowerCase()];
+    if (mapped === undefined) {
+        project.warnings.push(`${label}: ${what} "${value}" has no equivalent and was ignored.`);
+    }
+    return mapped;
+}
+/** Reads `.references(() => users.id, { onDelete: 'cascade' })` into a foreign key on the column. */
+function addReference(table, key, args, label, project) {
+    const targetFn = args[0] === undefined ? undefined : stripWrappers(args[0]);
+    const target = targetFn === undefined || !isFunctionNode(targetFn)
+        ? undefined
+        : functionResult(targetFn);
+    const ref = target === undefined ? undefined : parseColumnRef(target);
+    if (ref === undefined || ref.owner === undefined) {
+        project.warnings.push(`${label}: the target of .references(${describeNode(args[0])}) is not written as () => table.column; the foreign key was skipped.`);
+        return;
+    }
+    const config = objectValue(args[1]);
+    table.foreignKeys.push({
+        columns: [key],
+        targetVar: canonicalName(table.decl.file, ref.owner),
+        targetColumns: [ref.key],
+        onDelete: mapAction(stringOption(config, 'onDelete'), 'onDelete', label, project),
+        onUpdate: mapAction(stringOption(config, 'onUpdate'), 'onUpdate', label, project),
+        name: undefined,
+    });
+}
+function parseExtras(table, project) {
+    const extra = table.decl.extraNode === undefined
+        ? undefined
+        : stripWrappers(table.decl.extraNode);
+    if (extra === undefined) {
+        return;
+    }
+    const label = tableLabel(table);
+    const result = isFunctionNode(extra)
+        ? functionResult(extra)
+        : undefined;
+    const container = result === undefined ? undefined : stripWrappers(result);
+    if (container === undefined ||
+        (container.type !== 'array' && container.type !== 'object')) {
+        project.warnings.push(`${label}: the indexes and constraints are not returned from the table callback as an array or object literal; they were skipped.`);
+        return;
+    }
+    const items = [];
+    for (const child of container.namedChildren) {
+        if (child.type === 'comment') {
+            continue;
+        }
+        if (container.type === 'array') {
+            items.push(child);
+        }
+        else if (child.type === 'pair') {
+            const value = child.childForFieldName('value');
+            if (value !== null) {
+                items.push(value);
+            }
+        }
+        else {
+            project.warnings.push(`${label}: the table callback entry "${describeNode(child)}" is a spread or computed entry and was skipped.`);
+        }
+    }
+    for (const item of items) {
+        parseExtraItem(table, item, project);
+    }
+}
+function localKeys(table, refs, label, project) {
+    const known = new Set(table.columns.map((column) => column.key));
+    const missing = refs
+        .filter((ref) => !known.has(ref.key))
+        .map((ref) => ref.key);
+    if (missing.length > 0) {
+        project.warnings.push(`${label}: refers to "${missing.join('", "')}", which is not a column of the table; it was skipped.`);
+        return undefined;
+    }
+    return refs.map((ref) => ref.key);
+}
+function parseExtraItem(table, item, project) {
+    const label = tableLabel(table);
+    const chain = unwindChain(item);
+    if (chain === undefined) {
+        project.warnings.push(`${label}: the table callback entry "${describeNode(item)}" is not a call such as index('name').on(...) and was skipped.`);
+        return;
+    }
+    const callee = parseCallee(table.decl.file, chain.baseCallee);
+    switch (callee.name) {
+        case 'index':
+        case 'uniqueIndex':
+        case 'unique':
+            parseIndex(table, callee.name, chain, project);
+            return;
+        case 'primaryKey': {
+            const options = chain.baseArgs[0];
+            const refs = columnRefs(objectProperty(options, 'columns'));
+            const keys = refs === undefined
+                ? undefined
+                : localKeys(table, refs, `${label}: the primary key`, project);
+            if (keys !== undefined) {
+                table.primaryKey = {
+                    columns: keys,
+                    name: stringValue(objectProperty(options, 'name')),
+                };
+            }
+            else if (refs === undefined) {
+                project.warnings.push(`${label}: the primary key columns are not a literal list of table.column references; the primary key was skipped.`);
+            }
+            return;
+        }
+        case 'foreignKey': {
+            const options = chain.baseArgs[0];
+            const local = columnRefs(objectProperty(options, 'columns'));
+            const foreign = columnRefs(objectProperty(options, 'foreignColumns'));
+            const keys = local === undefined
+                ? undefined
+                : localKeys(table, local, `${label}: the foreign key`, project);
+            const targetOwner = foreign?.[0]?.owner;
+            if (foreign === undefined ||
+                foreign.length !== local?.length ||
+                targetOwner === undefined ||
+                foreign.some((ref) => ref.owner !== targetOwner)) {
+                if (keys !== undefined || local === undefined) {
+                    project.warnings.push(`${label}: a foreignKey() is not written with literal columns and foreignColumns lists of the same table; it was skipped.`);
+                }
+                return;
+            }
+            if (keys === undefined) {
+                return;
+            }
+            const lookup = (name) => stringValue(chain.links.find((link) => link.name === name)?.args[0]);
+            table.foreignKeys.push({
+                columns: keys,
+                targetVar: canonicalName(table.decl.file, targetOwner),
+                targetColumns: foreign.map((ref) => ref.key),
+                onDelete: mapAction(lookup('onDelete'), 'onDelete', label, project),
+                onUpdate: mapAction(lookup('onUpdate'), 'onUpdate', label, project),
+                name: stringValue(objectProperty(options, 'name')),
+            });
+            return;
+        }
+        case 'check':
+            project.warnings.push(`${label}: the check constraint ${describeNode(chain.baseArgs[0])} has no equivalent in the shared model and was dropped.`);
+            return;
+        default:
+            project.warnings.push(`${label}: the table callback entry ${callee.name}(...) is not represented in the shared model and was skipped.`);
+    }
+}
+function parseIndex(table, kind, chain, project) {
+    const label = tableLabel(table);
+    const name = stringValue(chain.baseArgs[0]);
+    const display = name === undefined ? '' : ` "${name}"`;
+    const what = `the ${kind === 'index' ? 'index' : 'unique constraint'}${display}`;
+    let refs;
+    let method;
+    let isPartial = false;
+    for (const link of chain.links) {
+        if (link.name === 'on' || link.name === 'using') {
+            const columnArgs = link.name === 'using' ? link.args.slice(1) : link.args;
+            if (link.name === 'using') {
+                method = stringValue(link.args[0]);
+            }
+            const parsed = columnArgs.map(parseColumnRef);
+            if (parsed.some((ref) => ref === undefined)) {
+                project.warnings.push(`${label}: ${what} is built on an expression (${describeNode(columnArgs[0])}) rather than plain columns; it was skipped.`);
+                return;
+            }
+            refs = parsed.flatMap((ref) => ref === undefined ? [] : [ref]);
+        }
+        else if (link.name === 'where') {
+            isPartial = true;
+        }
+        else if (link.name === 'nullsNotDistinct') {
+            project.warnings.push(`${label}: ${what} is NULLS NOT DISTINCT, which is not represented in the shared model and was ignored.`);
+        }
+    }
+    if (refs === undefined || refs.length === 0) {
+        project.warnings.push(`${label}: ${what} has no .on(...) columns; it was skipped.`);
+        return;
+    }
+    const keys = localKeys(table, refs, `${label}: ${what}`, project);
+    if (keys === undefined) {
+        return;
+    }
+    const isUnique = kind !== 'index';
+    if (isPartial) {
+        if (isUnique) {
+            project.warnings.push(`${label}: ${what} has a where condition (a partial index), which the shared model cannot represent; it was dropped because a full unique index would reject rows the source accepts.`);
+            return;
+        }
+        project.warnings.push(`${label}: ${what} has a where condition (a partial index), which is not preserved; it was read as a full index.`);
+    }
+    let indexMethod;
+    if (method !== undefined) {
+        indexMethod = INDEX_METHODS[method.toLowerCase()];
+        if (indexMethod === undefined) {
+            project.warnings.push(`${label}: ${what} uses the "${method}" access method, which is not represented in the shared model; the default method is used.`);
+        }
+    }
+    const fieldOptions = {};
+    for (const ref of refs) {
+        if (ref.sort !== undefined || ref.ops !== undefined) {
+            fieldOptions[ref.key] = {
+                ...(ref.sort === undefined ? {} : { sort: ref.sort }),
+                ...(ref.ops === undefined ? {} : { ops: ref.ops }),
+            };
+        }
+    }
+    table.indexes.push({
+        columns: keys,
+        isUnique,
+        name,
+        method: indexMethod,
+        fieldOptions,
+        isPartial,
+    });
+}
+// ---------------------------------------------------------------------------
+// Relations
+// ---------------------------------------------------------------------------
+function sameList(first, second) {
+    return (first.length === second.length &&
+        first.every((item, index) => item === second[index]));
+}
+/** The relation name for a foreign key declared only through `.references()`: `authorId` -> `author`. */
+function derivedRelationName(table, foreignKey) {
+    const key = foreignKey.columns[0] ?? '';
+    const stripped = key.replace(/(_id|Id|ID)$/, '');
+    const taken = new Set(table.columns
+        .filter((column) => !foreignKey.columns.includes(column.key))
+        .map((column) => column.key));
+    if (foreignKey.columns.length > 1) {
+        return toCamelCase(modelNameOf(foreignKey.targetVar));
+    }
+    return stripped === '' || stripped === key || taken.has(stripped)
+        ? key
+        : stripped;
+}
+/**
+ * Builds the owning side of every relation: a foreign key, named by the `one(...)` entry of the
+ * table's `relations()` when there is one, otherwise by the column it is declared on.
+ */
+function collectOwners(tables, byVar, project) {
+    const owners = [];
+    for (const table of tables) {
+        const label = tableLabel(table);
+        const used = new Set();
+        const defs = project.relationDefs.filter((def) => def.tableVar === table.decl.varName);
+        for (const def of defs) {
+            for (const entry of def.entries) {
+                if (entry.kind !== 'one' || entry.fields === undefined) {
+                    continue;
+                }
+                const keys = entry.fields.map((ref) => ref.key);
+                const references = (entry.references ?? []).map((ref) => ref.key);
+                const missing = keys.filter((key) => !table.columns.some((column) => column.key === key));
+                if (keys.length === 0 || missing.length > 0) {
+                    project.warnings.push(`${label}: the relation "${entry.key}" uses fields (${keys.join(', ')}) that are not columns of the table; it was skipped.`);
+                    continue;
+                }
+                let foreignKey = table.foreignKeys.find((candidate) => !used.has(candidate) &&
+                    sameList(candidate.columns, keys) &&
+                    candidate.targetVar === entry.targetVar);
+                if (foreignKey === undefined) {
+                    // A relation without a database constraint (Drizzle relations are an application-level feature).
+                    foreignKey = {
+                        columns: keys,
+                        targetVar: entry.targetVar,
+                        targetColumns: references.length > 0
+                            ? references
+                            : primaryKeyOf(byVar.get(entry.targetVar)),
+                        onDelete: undefined,
+                        onUpdate: undefined,
+                        name: undefined,
+                    };
+                    table.foreignKeys.push(foreignKey);
+                }
+                used.add(foreignKey);
+                owners.push({
+                    table,
+                    name: entry.key,
+                    foreignKey,
+                    relationName: entry.relationName,
+                    reverseName: undefined,
+                    isDeclared: true,
+                });
+            }
+        }
+        for (const foreignKey of table.foreignKeys) {
+            if (!used.has(foreignKey)) {
+                owners.push({
+                    table,
+                    name: derivedRelationName(table, foreignKey),
+                    foreignKey,
+                    relationName: undefined,
+                    reverseName: undefined,
+                    isDeclared: false,
+                });
+            }
+        }
+    }
+    return owners;
+}
+function primaryKeyOf(table) {
+    if (table === undefined) {
+        return ['id'];
+    }
+    if (table.primaryKey !== undefined) {
+        return table.primaryKey.columns;
+    }
+    const keys = table.columns
+        .filter((column) => column.field.isPrimaryKey)
+        .map((column) => column.key);
+    return keys.length > 0 ? keys : ['id'];
+}
+/** Links the `many(...)` and field-less `one(...)` entries to the owning side they mirror. */
+function linkReverseSides(tables, byVar, owners, project) {
+    for (const def of project.relationDefs) {
+        const table = byVar.get(def.tableVar);
+        if (table === undefined) {
+            project.warnings.push(`${def.file.label}: relations() are defined for "${def.tableVar}", which is not a table in the input; they were skipped.`);
+            continue;
+        }
+        for (const entry of def.entries) {
+            if (entry.kind === 'one' && entry.fields !== undefined) {
+                continue;
+            }
+            const location = `${tableLabel(table)}: the relation "${entry.key}"`;
+            const candidates = owners.filter((owner) => owner.table.decl.varName === entry.targetVar &&
+                owner.foreignKey.targetVar === table.decl.varName &&
+                owner.reverseName === undefined &&
+                (entry.relationName === undefined ||
+                    owner.relationName === entry.relationName));
+            if (!byVar.has(entry.targetVar)) {
+                project.warnings.push(`${location} points at "${entry.targetVar}", which is not a table in the input; the reverse side was skipped.`);
+                continue;
+            }
+            // Drizzle only knows the relations written as one(...); a bare foreign key is a fallback.
+            const declared = candidates.filter((owner) => owner.isDeclared);
+            const matching = declared.length > 0 ? declared : candidates;
+            const owner = matching[0];
+            if (owner === undefined) {
+                project.warnings.push(`${location} has no matching one(${table.decl.varName}, { fields, references }) on "${entry.targetVar}"` +
+                    `${entry.relationName === undefined ? '' : ` with relationName "${entry.relationName}"`}; the reverse side was not linked.`);
+                continue;
+            }
+            if (matching.length > 1) {
+                project.warnings.push(`${location} matches several relations of "${entry.targetVar}" (${matching.map((candidate) => candidate.name).join(', ')}); add a relationName to tell them apart. It was linked to "${owner.name}".`);
+            }
+            owner.reverseName = entry.key;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Models
+// ---------------------------------------------------------------------------
+function finalizeModel(table, byVar, owners, warnings, options) {
+    const label = tableLabel(table);
+    const fields = table.columns.map((column) => column.field);
+    const fieldByKey = new Map(fields.map((field) => [field.name, field]));
+    const tableOwners = owners.filter((owner) => owner.table === table);
+    // Which keys form the primary key, and which single columns are unique.
+    const pkKeys = table.primaryKey !== undefined
+        ? table.primaryKey.columns
+        : fields
+            .filter((field) => field.isPrimaryKey)
+            .map((field) => field.name);
+    const uniqueKeys = new Set(fields
+        .filter((field) => field.isUnique)
+        .map((field) => field.name));
+    for (const index of table.indexes) {
+        const only = index.columns[0];
+        if (index.isUnique &&
+            index.columns.length === 1 &&
+            only !== undefined &&
+            !index.isPartial) {
+            uniqueKeys.add(only);
+        }
+    }
+    const relations = [];
+    const compositeForeignKeys = [];
+    /** Column key -> the relation that replaced it. */
+    const renamed = new Map();
+    const mergedKeys = new Set();
+    const takenNames = new Set();
+    for (const owner of tableOwners) {
+        const foreignKey = owner.foreignKey;
+        const target = byVar.get(foreignKey.targetVar);
+        const targetModel = target === undefined
+            ? modelNameOf(foreignKey.targetVar)
+            : target.modelName;
+        const targetPk = primaryKeyOf(target);
+        const columns = foreignKey.columns.flatMap((key) => {
+            const column = table.columns.find((candidate) => candidate.key === key);
+            return column === undefined ? [] : [column];
+        });
+        if (foreignKey.columns.length > 1) {
+            const references = foreignKey.targetColumns;
+            compositeForeignKeys.push({
+                name: owner.name,
+                targetModel,
+                fields: foreignKey.columns,
+                references,
+                kind: 'foreignKey',
+                isNullable: columns.some((column) => !column.isNotNull),
+                onDelete: foreignKey.onDelete ?? 'noAction',
+                ...(foreignKey.onUpdate === undefined
+                    ? {}
+                    : { onUpdate: foreignKey.onUpdate }),
+                ...(owner.reverseName === undefined
+                    ? {}
+                    : { relatedName: owner.reverseName }),
+                ...(foreignKey.name === undefined
+                    ? {}
+                    : { constraintName: foreignKey.name }),
+            });
+            continue;
+        }
+        const backing = columns[0];
+        if (backing === undefined || mergedKeys.has(backing.key)) {
+            warnings.push(`${label}: the foreign key on "${foreignKey.columns.join(', ')}" ${backing === undefined ? 'refers to a column that does not exist' : 'repeats a column that already has a foreign key'}; it was skipped.`);
+            continue;
+        }
+        let name = owner.name;
+        if (takenNames.has(name)) {
+            name = backing.key;
+        }
+        takenNames.add(name);
+        mergedKeys.add(backing.key);
+        renamed.set(backing.key, name);
+        const isPrimary = pkKeys.length === 1 && pkKeys[0] === backing.key;
+        const referenced = foreignKey.targetColumns[0];
+        const isOneToOne = isPrimary || uniqueKeys.has(backing.key);
+        relations.push({
+            name,
+            kind: isOneToOne ? 'oneToOne' : 'foreignKey',
+            targetModel,
+            columnName: backing.field.columnName,
+            isNullable: !backing.isNotNull && !isPrimary,
+            onDelete: foreignKey.onDelete ?? 'noAction',
+            ...(owner.reverseName === undefined
+                ? {}
+                : { relatedName: owner.reverseName }),
+            ...(referenced === undefined ||
+                target === undefined ||
+                sameList(targetPk, [referenced])
+                ? {}
+                : { toField: referenced }),
+            ...(isPrimary ? { isPrimaryKey: true } : {}),
+            ...(foreignKey.onUpdate === undefined
+                ? {}
+                : { onUpdate: foreignKey.onUpdate }),
+            ...(foreignKey.name === undefined
+                ? {}
+                : { constraintName: foreignKey.name }),
+        });
+    }
+    const finalFields = fields.filter((field) => !mergedKeys.has(field.name));
+    // Indexes, with columns that became relations renamed.
+    const known = new Set([
+        ...finalFields.map((field) => field.name),
+        ...relations.map((relation) => relation.name),
+    ]);
+    const indexes = [];
+    for (const raw of table.indexes) {
+        const names = raw.columns.map((key) => renamed.get(key) ?? key);
+        if (names.some((name) => !known.has(name))) {
+            continue;
+        }
+        const single = names.length === 1
+            ? finalFields.find((field) => field.name === names[0])
+            : undefined;
+        const onRelation = names.length === 1 &&
+            relations.some((relation) => relation.name === names[0]);
+        if (raw.isUnique && onRelation && !raw.isPartial) {
+            // A unique foreign key is a one-to-one relation, which already implies the constraint.
+            continue;
+        }
+        if (raw.isUnique &&
+            raw.name === undefined &&
+            single !== undefined &&
+            !single.isPrimaryKey &&
+            !raw.isPartial) {
+            single.isUnique = true;
+            continue;
+        }
+        const fieldOptions = {};
+        for (const [key, entry] of Object.entries(raw.fieldOptions)) {
+            fieldOptions[renamed.get(key) ?? key] = entry;
+        }
+        indexes.push({
+            fields: names,
+            isUnique: raw.isUnique,
+            ...(raw.name === undefined ? {} : { name: raw.name }),
+            ...(raw.method === undefined ? {} : { method: raw.method }),
+            ...(Object.keys(fieldOptions).length === 0 ? {} : { fieldOptions }),
+        });
+    }
+    // Primary key.
+    let compositePrimaryKey;
+    if (pkKeys.length === 0) {
+        warnings.push(`${label}: the table has no primary key; most ORMs need one, so add .primaryKey() to a column or a primaryKey({ columns: [...] }) constraint.`);
+    }
+    else if (pkKeys.length > 1) {
+        compositePrimaryKey = pkKeys.map((key) => renamed.get(key) ?? key);
+        for (const key of pkKeys) {
+            const field = fieldByKey.get(key);
+            if (field !== undefined) {
+                field.isPrimaryKey = false;
+                field.isUnique = false;
+            }
+        }
+    }
+    else if (table.primaryKey !== undefined) {
+        const field = finalFields.find((candidate) => candidate.name === table.primaryKey?.columns[0]);
+        if (field !== undefined) {
+            field.isPrimaryKey = true;
+            field.isNullable = false;
+        }
+    }
+    for (const relation of relations) {
+        if (compositePrimaryKey !== undefined) {
+            delete relation.isPrimaryKey;
+        }
+    }
+    return {
+        name: table.modelName,
+        tableName: table.dbName,
+        appLabel: options.appLabel,
+        fields: finalFields,
+        relations,
+        indexes,
+        ...(compositePrimaryKey === undefined ? {} : { compositePrimaryKey }),
+        ...(table.primaryKey?.name !== undefined &&
+            compositePrimaryKey !== undefined
+            ? { primaryKeyName: table.primaryKey.name }
+            : {}),
+        ...(table.decl.schema === undefined ? {} : { schema: table.decl.schema }),
+        ...(compositeForeignKeys.length === 0 ? {} : { compositeForeignKeys }),
+    };
+}
+function addStubModels(models, warnings, options) {
+    const known = new Set(models.map((model) => model.name));
+    const stubs = [];
+    const targets = [];
+    for (const model of models) {
+        for (const relation of model.relations) {
+            targets.push({
+                from: model.name,
+                via: relation.name,
+                target: relation.targetModel,
+            });
+        }
+        for (const composite of model.compositeForeignKeys ?? []) {
+            targets.push({
+                from: model.name,
+                via: composite.name,
+                target: composite.targetModel,
+            });
+        }
+    }
+    for (const { from, via, target } of targets) {
+        if (known.has(target)) {
+            continue;
+        }
+        known.add(target);
+        stubs.push({
+            name: target,
+            tableName: toSnakeCase(target),
+            appLabel: options.appLabel,
+            fields: [
+                {
+                    name: 'id',
+                    columnName: 'id',
+                    type: 'int',
+                    isPrimaryKey: true,
+                    isUnique: false,
+                    isNullable: false,
+                    isAutoUpdated: false,
+                    default: { kind: 'autoIncrement' },
+                },
+            ],
+            relations: [],
+            indexes: [],
+        });
+        warnings.push(`${from}.${via} references "${target}", which is not a table in the input. ` +
+            `A stub model with an auto-increment id was generated; replace it with the real definition.`);
+    }
+    models.push(...stubs);
+}
+//# sourceMappingURL=drizzle.js.map