uql-codemod 0.48.2 → 0.50.0

package/dist/imports.d.ts

@@ -1,5 +1,6 @@
 import ts from 'typescript';
-import type { Context } from './context.js';
+import { type Context } from './context.js';
+import { type Edit } from './edits.js';
 /** The name `uql-orm` gave its SQL tag, and gives it now. */
 export declare const LEGACY_SQL_TAG = "raw";
 export declare const SQL_TAG = "sql";
@@ -17,12 +18,11 @@ export declare function uqlImportDeclarations(source: ts.SourceFile, entries?: b
 export declare function uqlImport(source: ts.SourceFile, name: string, entries?: boolean): ts.ImportSpecifier | undefined;
 /** Every identifier in the file bound to the same symbol as `name`, besides `name` itself. */
 export declare function usesOf(source: ts.SourceFile, name: ts.Identifier, checker: ts.TypeChecker): ts.Identifier[];
+/** The names among `names` the file binds or reads as something other than uql-orm's export, which a rewrite would shadow. */
+export declare function foreignNames(source: ts.SourceFile, names: ReadonlySet<string>, checker: ts.TypeChecker): ReadonlySet<string>;
 /** Names an export that no longer exists, where it is imported from the package or one of its entries. */
 export declare function reportRemovedExports(ctx: Context): void;
-/**
- * The imported names the codemod removes once every use was rewritten: `Relation` unwrapped and `expr` defaults.
- * A removed decorator keeps its import on purpose: deleting it would swap a clear error for a puzzling one.
- */
+/** The imported names of `REWRITTEN` the codemod removes, once every use was rewritten. */
 export declare function deadImportNames(ctx: Context): ReadonlySet<string>;
 /** The `uql-orm` export `node` names, where its symbol is an import of it or of one of its entries. */
 export declare function uqlExport(node: ts.Node | undefined, checker: ts.TypeChecker): string | undefined;
@@ -41,4 +41,20 @@ export declare function clashingName(ctx: Context): ts.Identifier | undefined;
  * The names the rewrites wrote join the first `uql-orm` import, or are reported when there is none.
  */
 export declare function rewriteImports(dead: ReadonlySet<string>, ctx: Context): void;
+/** An import of `names` from `from`, quoted as the file quotes its imports. */
+export declare const importText: (keyword: string, names: readonly string[], from: string, quote?: string) => string;
+/**
+ * The import without `dropped` of its `elements`: the whole statement where nothing else is left of it, and the
+ * braces with them where a default import stays.
+ */
+export declare function importRemovalEdits(declaration: ts.ImportDeclaration, elements: readonly ts.ImportSpecifier[], dropped: readonly ts.ImportSpecifier[]): readonly Edit[];
+/** Every name the file spells outside its imports, which an import it binds is still used under if listed here. */
+export declare function spelledNames(source: ts.SourceFile): ReadonlySet<string>;
+/** The import names in `candidates` that the file no longer spells. */
+export declare function deadImports(elements: readonly ts.ImportSpecifier[], candidates: ReadonlySet<string | undefined>, spelled: ReadonlySet<string>): readonly ts.ImportSpecifier[];
+/**
+ * The file's `uql-orm` imports with `added` joined to the first, a new import where there is none, and each name in
+ * `candidates` the file no longer spells dropped.
+ */
+export declare function importEdits(source: ts.SourceFile, added: ReadonlySet<string>, candidates: ReadonlySet<string | undefined>): readonly Edit[];
 export {};

package/dist/imports.js

@@ -1,10 +1,12 @@
 import ts from 'typescript';
+import { REWRITTEN } from './context.js';
 import { inserted, removeFromList, removeStatement, replaced } from './edits.js';
 /**
  * Exports that no longer exist, mapped to what to do instead. Reported rather than rewritten: what replaces
  * each is decided at its call site.
  */
 const REMOVED_EXPORTS = new Map([
+    ['Relation', "write the property's type without it, and drop the import"],
     [
         'setQuerierPool',
         'pass the pool where it is used: `createFetchHandler({ pool, include })`, `querierMiddleware({ pool, include })`',
@@ -29,8 +31,11 @@ const REMOVED_EXPORTS = new Map([
     ['SqlCallback', 'use `EntitySql<E>`, which holds the callback form'],
     [
         'IndexColumnOptions',
-        "an entity's index entry is `EntityIndexColumnInput<E>`, the migration builder's `IndexColumnInput`",
+        "an entity's index entry is `EntityIndexColumnInput`, the migration builder's `IndexColumnInput`",
     ],
+    ['EntityIndexColumn', "an entity's index entry is `EntityIndexColumnInput`, the migration builder's `IndexEntry`"],
+    ['IndexJsonPath', "read the path off the column's ref: `{ column: post.meta.lang, type: Number }`"],
+    ['IndexJsonArray', "give the elements' type: `{ column: post.tags, type: [String] }`"],
     ['isKnownMigratorDialect', 'every dialect has a migrator, so it always held: drop the check'],
     ['QuerierPoolDialect', "read the pool's own: `P['dialect']`"],
     ['QuerierPoolQuerier', "read the pool's own: `Awaited<ReturnType<P['getQuerier']>>`"],
@@ -71,6 +76,8 @@ export const SQL_TAG = 'sql';
  */
 const RENAMED_EXPORTS = new Map([
     ['QueryWhereMap', { to: 'QueryWhere' }],
+    ['IndexColumnSchema', { to: 'IndexEntry' }],
+    ['IndexColumnModifiers', { to: 'IndexEntryModifiers' }],
     ['RelationKeyMap', { to: 'KeyMap' }],
     ['FilterCondition', { to: 'FilterWhere' }],
     ['PgDialect', { to: 'PostgresDialect', from: 'uql-orm/postgres' }],
@@ -99,8 +106,10 @@ const RENAMED_EXPORTS = new Map([
     ['IMigrationBuilder', { to: 'MigrationBuilder' }],
     ['ITableBuilder', { to: 'TableBuilder' }],
     ['IAlterTableBuilder', { to: 'AlterTableBuilder' }],
-    ['IColumnBuilder', { to: 'ColumnBuilder' }],
-    ['IColumnFactory', { to: 'ColumnFactory' }],
+    ['IColumnBuilder', { to: 'TableColumnBuilder' }],
+    ['IColumnFactory', { to: 'TableColumnFactory' }],
+    ['uql-orm/migrate#ColumnBuilder', { to: 'TableColumnBuilder' }],
+    ['uql-orm/migrate#ColumnFactory', { to: 'TableColumnFactory' }],
     ['IForeignKeyBuilder', { to: 'ForeignKeyBuilder' }],
     ['ITableForeignKeyBuilder', { to: 'TableForeignKeyBuilder' }],
     ['UqlLockUsageError', { to: 'UqlUsageError' }],
@@ -165,18 +174,35 @@ function importedName(element) {
 }
 /** Every identifier in the file bound to the same symbol as `name`, besides `name` itself. */
 export function usesOf(source, name, checker) {
-    const symbol = checker.getSymbolAtLocation(name);
-    const uses = [];
+    return usesOfEach(source, [name], checker)[0];
+}
+/** {@link usesOf} for each of `names`, in their order, from one walk of the file. */
+function usesOfEach(source, names, checker) {
+    const bound = names.map((name) => ({ name, symbol: checker.getSymbolAtLocation(name), uses: [] }));
     const visit = (node) => {
-        if (ts.isIdentifier(node) && node !== name && node.text === name.text) {
-            if (symbol && checker.getSymbolAtLocation(node) === symbol) {
-                uses.push(node);
+        if (ts.isIdentifier(node)) {
+            const symbol = checker.getSymbolAtLocation(node);
+            for (const binding of bound) {
+                if (symbol && binding.symbol === symbol && binding.name !== node)
+                    binding.uses.push(node);
             }
         }
         ts.forEachChild(node, visit);
     };
     visit(source);
-    return uses;
+    return bound.map(({ uses }) => uses);
+}
+/** The names among `names` the file binds or reads as something other than uql-orm's export, which a rewrite would shadow. */
+export function foreignNames(source, names, checker) {
+    const found = new Set();
+    const visit = (node) => {
+        if (ts.isIdentifier(node) && names.has(node.text) && isForeignName(node, checker)) {
+            found.add(node.text);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return found;
 }
 /** The rename `element` still needs, none where it already names the export at its entry. */
 function renamedTo(element, entry) {
@@ -211,23 +237,16 @@ export function reportRemovedExports(ctx) {
 function isTypeOnly(declaration) {
     return declaration.importClause?.phaseModifier === ts.SyntaxKind.TypeKeyword;
 }
-/**
- * The imported names the codemod removes once every use was rewritten: `Relation` unwrapped and `expr` defaults.
- * A removed decorator keeps its import on purpose: deleting it would swap a clear error for a puzzling one.
- */
+/** The imported names of `REWRITTEN` the codemod removes, once every use was rewritten. */
 export function deadImportNames(ctx) {
     const { source, rewritten } = ctx;
-    const uses = (name) => {
+    const imported = REWRITTEN.flatMap((name) => {
         const element = uqlImport(source, name, true);
-        return element ? usesOf(source, element.name, ctx.checker).length : 0;
-    };
-    const relations = uses('Relation');
-    if (relations > rewritten.Relation) {
-        ctx.unresolved.push(`${source.fileName}: ${relations - rewritten.Relation} 'Relation<T>' reference(s) are somewhere this codemod ` +
-            'does not rewrite; unwrap them and drop the import by hand');
-    }
-    const names = ['Relation', 'expr'];
-    return new Set(names.filter((name) => rewritten[name] > 0 && rewritten[name] === uses(name)));
+        return element ? [[name, element.name]] : [];
+    });
+    const found = usesOfEach(source, imported.map(([, element]) => element), ctx.checker);
+    const uses = new Map(imported.map(([name], at) => [name, found[at].length]));
+    return new Set(REWRITTEN.filter((name) => rewritten[name] > 0 && rewritten[name] === (uses.get(name) ?? 0)));
 }
 /** The `uql-orm` export `node` names, where its symbol is an import of it or of one of its entries. */
 export function uqlExport(node, checker) {
@@ -303,10 +322,6 @@ export function rewriteImports(dead, ctx) {
         if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) {
             continue;
         }
-        if (statement.moduleSpecifier.text === 'reflect-metadata' && !statement.importClause) {
-            ctx.edits.push(removeStatement(statement));
-            continue;
-        }
         const uql = imports.get(statement);
         const join = uql === home ? written.map(([name]) => name) : [];
         const entry = uql && entryOf(uql.entry);
@@ -319,7 +334,7 @@ export function rewriteImports(dead, ctx) {
     }
 }
 /** An import of `names` from `from`, quoted as the file quotes its imports. */
-const importText = (keyword, names, from, quote = "'") => `${keyword} { ${names.join(', ')} } from ${quote}${from}${quote};`;
+export const importText = (keyword, names, from, quote = "'") => `${keyword} { ${names.join(', ')} } from ${quote}${from}${quote};`;
 /**
  * The import written again: each name under the entry it lives in, `join` first under `uql-orm`. `join` is values,
  * so in a type-only declaration it becomes a value import of its own.
@@ -354,6 +369,63 @@ function rebuildImport({ declaration, entry: imported, elements }, join, dead, b
     }
     ctx.edits.push(statements.length ? replaced(declaration, statements.join('\n')) : removeStatement(declaration));
 }
+/**
+ * The import without `dropped` of its `elements`: the whole statement where nothing else is left of it, and the
+ * braces with them where a default import stays.
+ */
+export function importRemovalEdits(declaration, elements, dropped) {
+    if (dropped.length !== elements.length) {
+        return removeFromList(elements, dropped, declaration.getSourceFile());
+    }
+    const clause = declaration.importClause;
+    return clause?.name
+        ? [{ start: clause.name.getEnd(), end: clause.getEnd(), text: '' }]
+        : [removeStatement(declaration)];
+}
+/** Every name the file spells outside its imports, which an import it binds is still used under if listed here. */
+export function spelledNames(source) {
+    const names = new Set();
+    const visit = (node) => {
+        if (ts.isIdentifier(node)) {
+            names.add(node.text);
+        }
+        if (!ts.isImportDeclaration(node)) {
+            ts.forEachChild(node, visit);
+        }
+    };
+    visit(source);
+    return names;
+}
+/** The import names in `candidates` that the file no longer spells. */
+export function deadImports(elements, candidates, spelled) {
+    return elements.filter((it) => candidates.has(it.name.text) && !spelled.has(it.name.text));
+}
+/**
+ * The file's `uql-orm` imports with `added` joined to the first, a new import where there is none, and each name in
+ * `candidates` the file no longer spells dropped.
+ */
+export function importEdits(source, added, candidates) {
+    const declarations = uqlImportDeclarations(source, true);
+    const bound = new Set(declarations.flatMap(({ elements }) => elements.map((it) => it.name.text)));
+    const joined = [...added].filter((name) => !bound.has(name)).toSorted();
+    const [home] = declarations;
+    if (!home) {
+        return joined.length ? [{ start: 0, end: 0, text: `${importText('import', joined, 'uql-orm')}\n` }] : [];
+    }
+    const spelled = spelledNames(source);
+    return declarations.flatMap(({ declaration, elements }) => {
+        const dead = deadImports(elements, candidates, spelled);
+        const join = declaration === home.declaration ? joined : [];
+        const removals = dead.length ? importRemovalEdits(declaration, elements, dead) : [];
+        const first = elements.find((it) => !dead.includes(it));
+        if (!join.length) {
+            return removals;
+        }
+        return first
+            ? [...removals, inserted(first, `${join.join(', ')}, `)]
+            : [replaced(declaration, importText('import', join, 'uql-orm'))];
+    });
+}
 /** The import with the `dead` names out and `join` in, nothing else of it touched. */
 function patchImport(declaration, join, dead, ctx) {
     const named = declaration.importClause?.namedBindings;
@@ -362,11 +434,11 @@ function patchImport(declaration, join, dead, ctx) {
     }
     const dropped = named.elements.filter((element) => dead.has(element.name.text));
     const statement = importText('import', join, 'uql-orm');
-    if (dropped.length === named.elements.length && !declaration.importClause?.name) {
-        ctx.edits.push(join.length ? replaced(declaration, statement) : removeStatement(declaration));
+    if (join.length && dropped.length === named.elements.length && !declaration.importClause?.name) {
+        ctx.edits.push(replaced(declaration, statement));
         return;
     }
-    ctx.edits.push(...removeFromList(named.elements, dropped, ctx.source));
+    ctx.edits.push(...importRemovalEdits(declaration, named.elements, dropped));
     if (join.length) {
         ctx.edits.push(isTypeOnly(declaration)
             ? inserted(declaration, `${statement}\n`)

package/dist/index.d.ts

@@ -14,9 +14,9 @@ export type RunSummary = {
     readonly notes: readonly string[];
 };
 /**
- * Rewrites a project's entities for the standard decorator spec.
+ * Rewrites a project across the breaking changes of uql-orm that can be made mechanically.
  *
- * @remarks Needs a type checker, not just a parser: the whole point is to write down the types that
- * `design:type` used to report at runtime, and only the checker knows what `role?: Role` resolves to.
+ * @remarks Needs a type checker, not just a parser: the codemod reads each property's type to name a relation's
+ * target and to admit `null`, and only the checker resolves `role?: Role` to its arms.
  */
 export declare function run({ project, dryRun, include }: RunOptions): Promise<RunSummary>;

package/dist/index.js

@@ -2,14 +2,14 @@ import { writeFile } from 'node:fs/promises';
 import { dirname, resolve } from 'node:path';
 import ts from 'typescript';
 import { transformFile } from './transform.js';
-import { transformTsconfig } from './tsconfig.js';
+import { checkTsconfig } from './tsconfig.js';
 export * from './transform.js';
 export * from './tsconfig.js';
 /**
- * Rewrites a project's entities for the standard decorator spec.
+ * Rewrites a project across the breaking changes of uql-orm that can be made mechanically.
  *
- * @remarks Needs a type checker, not just a parser: the whole point is to write down the types that
- * `design:type` used to report at runtime, and only the checker knows what `role?: Role` resolves to.
+ * @remarks Needs a type checker, not just a parser: the codemod reads each property's type to name a relation's
+ * target and to admit `null`, and only the checker resolves `role?: Role` to its arms.
  */
 export async function run({ project, dryRun, include }) {
     // Absolute, because `parseJsonConfigFileContent` resolves every discovered file against the base path
@@ -41,19 +41,16 @@ export async function run({ project, dryRun, include }) {
         if (result.changed || result.unresolved.length || result.notes.length)
             results.push(result);
     }
-    // The config is rewritten too: leaving `experimentalDecorators` on is what keeps a project compiling
-    // against the old spec, so a codemod that only touched the sources would leave it half-migrated.
-    const tsconfig = transformTsconfig(configPath, ts.sys.readFile(configPath) ?? '');
     const rewritten = results.filter((r) => r.changed);
     if (!dryRun) {
         await Promise.all(rewritten.map((r) => writeFile(r.fileName, r.text, 'utf8')));
-        if (tsconfig.changed) {
-            await writeFile(configPath, tsconfig.text, 'utf8');
-        }
     }
     return {
-        changed: [...rewritten.map((r) => r.fileName), ...(tsconfig.changed ? [configPath] : [])],
-        unresolved: [...results.flatMap((r) => r.unresolved), ...tsconfig.unresolved],
+        changed: rewritten.map((r) => r.fileName),
+        unresolved: [
+            ...results.flatMap((r) => r.unresolved),
+            ...checkTsconfig(configPath, ts.sys.readFile(configPath) ?? ''),
+        ],
         notes: results.flatMap((r) => r.notes),
     };
 }

package/dist/jsonIndex.d.ts

@@ -0,0 +1,11 @@
+import ts from 'typescript';
+import type { Context } from './context.js';
+/**
+ * Rewrites each JSON entry of an index's columns into the path read off the column's ref, as a `$where` key
+ * spells it: `{ column: post.kind, jsonPath: { path: 'theme.color', type: String } }` becomes
+ * `{ column: post.kind.theme.color, type: String }`, and a `jsonArray`'s element type becomes `type: [String]`.
+ * Its `length` becomes `charLength`, and a column entry's becomes `prefixLength`.
+ */
+export declare function rewriteJsonIndexEntries(columns: ts.Expression | undefined, ctx: Context): void;
+/** A migration builder's index entries, each `length` as the option it names now: `charLength` on JSON, `prefixLength` on a column. */
+export declare function rewriteBuilderIndexLengths(columns: ts.Expression | undefined, ctx: Context): void;

package/dist/jsonIndex.js

@@ -0,0 +1,78 @@
+import ts from 'typescript';
+import { original, replaced } from './edits.js';
+import { memberAccess } from './keyMaps.js';
+import { arrayElements, columnListEntries, namedProperty, propertyAssignment, propertyKey, propertyValue, } from './syntax.js';
+/** The entry's own keys the rewritten entry writes itself rather than carrying over. */
+const MOVED_KEYS = new Set(['column', 'length']);
+/**
+ * Rewrites each JSON entry of an index's columns into the path read off the column's ref, as a `$where` key
+ * spells it: `{ column: post.kind, jsonPath: { path: 'theme.color', type: String } }` becomes
+ * `{ column: post.kind.theme.color, type: String }`, and a `jsonArray`'s element type becomes `type: [String]`.
+ * Its `length` becomes `charLength`, and a column entry's becomes `prefixLength`.
+ */
+export function rewriteJsonIndexEntries(columns, ctx) {
+    for (const entry of columnListEntries(columns).filter(ts.isObjectLiteralExpression)) {
+        const read = propertyAssignment(entry, 'jsonPath') ?? propertyAssignment(entry, 'jsonArray');
+        const edit = read ? jsonEntryEdit(entry, read) : prefixLengthEdit(entry);
+        if (edit) {
+            ctx.edits.push(edit);
+        }
+        else if (read) {
+            ctx.report(entry, "read the JSON path off the column's ref, `{ column: post.kind.theme, type: Number }`; this entry could not be read");
+        }
+    }
+}
+/** The read's options as the path's keys, and the type and length as written, `undefined` where it takes more than these. */
+function readOptions(options) {
+    const path = propertyValue(options, 'path');
+    const type = propertyValue(options, 'type');
+    const length = propertyValue(options, 'length');
+    const known = [path, type, length].filter(Boolean).length;
+    if (!type || (path && !ts.isStringLiteralLike(path)) || options.properties.length !== known) {
+        return undefined;
+    }
+    const keys = path && ts.isStringLiteralLike(path) ? path.text.split('.') : [];
+    return { keys, type, length };
+}
+/** The entry rewritten, or `undefined` where its read names a path or an option this cannot carry over. */
+function jsonEntryEdit(entry, read) {
+    const column = propertyValue(entry, 'column');
+    const options = read.initializer;
+    const parsed = column && ts.isObjectLiteralExpression(options) ? readOptions(options) : undefined;
+    const entryLength = propertyValue(entry, 'length');
+    if (!column || !parsed || (parsed.length && entryLength)) {
+        return undefined;
+    }
+    const { keys, type } = parsed;
+    const length = parsed.length ?? entryLength;
+    const elements = propertyKey(read.name) === 'jsonArray';
+    const rest = entry.properties.filter((property) => property !== read && !(ts.isPropertyAssignment(property) && MOVED_KEYS.has(propertyKey(property.name))));
+    const parts = [
+        '{ column: ',
+        original(column),
+        keys.reduce(memberAccess, ''),
+        ', type: ',
+        ...(elements ? ['[', original(type), ']'] : [original(type)]),
+        ...(length ? [', charLength: ', original(length)] : []),
+        ...rest.flatMap((property) => [', ', original(property)]),
+        ' }',
+    ];
+    return replaced(entry, parts);
+}
+/** A column entry's `length` as the `prefixLength` it now names, `undefined` where it states none. */
+function prefixLengthEdit(entry) {
+    const length = propertyAssignment(entry, 'length');
+    return length && replaced(length.name, 'prefixLength');
+}
+/** The keys only a migration builder's JSON entry states, whose `length` is the `CHAR(n)` it is read as. */
+const JSON_ENTRY_KEYS = ['json', 'path', 'type'];
+/** A migration builder's index entries, each `length` as the option it names now: `charLength` on JSON, `prefixLength` on a column. */
+export function rewriteBuilderIndexLengths(columns, ctx) {
+    for (const entry of arrayElements(columns).filter(ts.isObjectLiteralExpression)) {
+        const length = propertyAssignment(entry, 'length');
+        const json = JSON_ENTRY_KEYS.some((key) => namedProperty(entry, key));
+        if (length) {
+            ctx.edits.push(replaced(length.name, json ? 'charLength' : 'prefixLength'));
+        }
+    }
+}

package/dist/keyMaps.d.ts

@@ -8,10 +8,12 @@ export declare function paramFor(className: string | undefined): string;
 export declare function quoted(text: string): string;
 /** `post.title`, or `post['first-name']` for a key that is no identifier. */
 export declare function memberAccess(param: string, key: string): string;
+/** A key as an object literal writes it: `title`, or `'first-name'` for one that is no identifier. */
+export declare function memberKey(key: string): string;
 /** `'amount'` or `['title', 'body']` -> `{ amount: true }`, the key map a statement names fields by. */
 export declare function fieldKeysEdits(value: ts.Expression): Edits;
 /** Whether `value` is already a function, the form every rewrite here produces. */
-export declare function isCallback(value: ts.Expression): boolean;
+export declare function isCallback(value: ts.Expression): value is ts.ArrowFunction | ts.FunctionExpression;
 /** `['title', { column: 'createdAt' }]` -> `(post) => [post.title, { column: post.createdAt }]`. */
 export declare function keyListEdits(list: ts.Expression, param: string): Edits;
 /** `'author'` -> `(post) => post.author`, `param` being the relation's target. */

package/dist/keyMaps.js

@@ -16,13 +16,17 @@ export function quoted(text) {
 export function memberAccess(param, key) {
     return isIdentifierName(key) ? `${param}.${key}` : `${param}[${quoted(key)}]`;
 }
+/** A key as an object literal writes it: `title`, or `'first-name'` for one that is no identifier. */
+export function memberKey(key) {
+    return isIdentifierName(key) ? key : quoted(key);
+}
 /** `'amount'` or `['title', 'body']` -> `{ amount: true }`, the key map a statement names fields by. */
 export function fieldKeysEdits(value) {
     const names = ts.isArrayLiteralExpression(value) ? value.elements : [value];
     if (!names.every((name) => ts.isStringLiteralLike(name))) {
         return undefined;
     }
-    const keys = names.map(({ text }) => `${isIdentifierName(text) ? text : quoted(text)}: true`);
+    const keys = names.map(({ text }) => `${memberKey(text)}: true`);
     return [replaced(value, `{ ${keys.join(', ')} }`)];
 }
 /** Whether `value` is already a function, the form every rewrite here produces. */

package/dist/migrationBuilders.d.ts

@@ -0,0 +1,13 @@
+/** The column factories of a migration's table builder. */
+export declare const FACTORY_NAMES: readonly ["id", "integer", "smallint", "bigint", "float", "double", "decimal", "string", "char", "text", "boolean", "date", "time", "timestamp", "timestamptz", "json", "jsonb", "uuid", "blob", "vector"];
+export type MigrationBuildersResult = {
+    readonly text: string;
+    readonly unresolved: string[];
+};
+/**
+ * Writes a migration's columns in an entity column's vocabulary: `table.string('email', { length: 80 })` as
+ * `table.string('email').length(80)`, `.defaultValue()` as `.default()`, `.primaryKey()` as `.id()`, `.computed()`
+ * as `.as()`, and `.notNullable()` dropped, a column being NOT NULL already. Only a chain off the builder a
+ * `createTable`, `alterTable`, `addColumn` or `alterColumn` callback is handed, so no other `.string()` is touched.
+ */
+export declare function toMigrationBuilders(fileName: string, text: string, locate?: (at: number) => string): MigrationBuildersResult;

package/dist/migrationBuilders.js

@@ -0,0 +1,182 @@
+import ts from 'typescript';
+import { call, flag, flagOrCall } from './columnMethods.js';
+import { formatFindings, locationAt } from './context.js';
+import { applyEdits, replaced } from './edits.js';
+import { chainOf, identifierText, propertiesByKey } from './syntax.js';
+/** The migration builder's calls a column is declared by, and the callback each hands its builder to. */
+const DECLARING_CALLS = new Set(['createTable', 'alterTable', 'addColumn', 'alterColumn']);
+/** The column factories of a migration's table builder. */
+export const FACTORY_NAMES = [
+    'id',
+    'integer',
+    'smallint',
+    'bigint',
+    'float',
+    'double',
+    'decimal',
+    'string',
+    'char',
+    'text',
+    'boolean',
+    'date',
+    'time',
+    'timestamp',
+    'timestamptz',
+    'json',
+    'jsonb',
+    'uuid',
+    'blob',
+    'vector',
+];
+const FACTORIES = new Set(FACTORY_NAMES);
+/** A chained method renamed, or removed where it now says what a column already is. */
+const RENAMED = {
+    notNullable: () => '',
+    nullable: ([value]) => (value === 'false' ? '' : '.nullable()'),
+    defaultValue: (args) => `.default(${args.join(', ')})`,
+    primaryKey: () => '.id()',
+    computed: (args) => `.as(${args.join(', ')})`,
+};
+/** Each column option the factories took as a method now, in the order a column chains them. */
+const OPTION_METHODS = [
+    ['length', call('length')],
+    ['precision', call('precision')],
+    ['scale', call('scale')],
+    ['nullable', flag('nullable')],
+    ['primaryKey', flag('id')],
+    ['autoIncrement', flag('autoIncrement')],
+    ['unique', flag('unique')],
+    ['unsigned', flag('unsigned')],
+    ['defaultValue', call('default')],
+    ['index', flagOrCall('index')],
+    ['comment', call('comment')],
+];
+/**
+ * Writes a migration's columns in an entity column's vocabulary: `table.string('email', { length: 80 })` as
+ * `table.string('email').length(80)`, `.defaultValue()` as `.default()`, `.primaryKey()` as `.id()`, `.computed()`
+ * as `.as()`, and `.notNullable()` dropped, a column being NOT NULL already. Only a chain off the builder a
+ * `createTable`, `alterTable`, `addColumn` or `alterColumn` callback is handed, so no other `.string()` is touched.
+ */
+export function toMigrationBuilders(fileName, text, locate) {
+    if (![...DECLARING_CALLS].some((call) => text.includes(`${call}(`))) {
+        return { text, unresolved: [] };
+    }
+    const source = ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest, true);
+    const edits = [];
+    const findings = [];
+    const visit = (node) => {
+        if (ts.isCallExpression(node) && isDeclaringCall(node)) {
+            for (const callback of node.arguments) {
+                const builder = ts.isArrowFunction(callback) && identifierText(callback.parameters[0]?.name);
+                if (builder) {
+                    collect(callback.body, builder, edits, (at, message) => findings.push({ node: at, message }));
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return {
+        text: edits.length ? applyEdits(text, edits) : text,
+        unresolved: formatFindings(findings, locate ?? ((at) => locationAt(source, at))),
+    };
+}
+function isDeclaringCall(call) {
+    return ts.isPropertyAccessExpression(call.expression) && DECLARING_CALLS.has(call.expression.name.text);
+}
+/** Each column chain in `body` rooted at `builder`, the outermost call of each rewritten whole. */
+function collect(body, builder, edits, report) {
+    const visit = (node) => {
+        if (ts.isCallExpression(node) && !isChained(node)) {
+            const rewritten = chainSource(node, builder, report);
+            if (rewritten !== undefined) {
+                if (rewritten !== node.getText())
+                    edits.push(replaced(node, rewritten));
+                return;
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(body);
+}
+/** Whether `call` is the receiver of a further call in the chain, which the outermost one rewrites. */
+function isChained(call) {
+    return ts.isPropertyAccessExpression(call.parent);
+}
+/** The chain as source in the new vocabulary, or `undefined` where it is no column chain off `builder`. */
+function chainSource(outer, builder, report) {
+    const { root, methods } = chainOf(outer);
+    const [first, ...chained] = methods;
+    if (!first || identifierText(root) !== builder || !FACTORIES.has(first.name)) {
+        return undefined;
+    }
+    const start = factorySource(first.call, first.name, builder, report);
+    if (start === undefined) {
+        return outer.getText();
+    }
+    return start + chained.map(methodSource).join('');
+}
+/** `table.vector('embedding', { dimensions: 3, nullable: true })` as `table.vector('embedding', 3).nullable()`. */
+function factorySource(root, factory, builder, report) {
+    const [name, options] = root.arguments;
+    const nameText = name?.getText() ?? '';
+    if (!options) {
+        return root.getText();
+    }
+    const props = propertiesByKey(options);
+    if (!props) {
+        report(root, `cannot write '${options.getText()}' as the column's methods: chain each option as one`);
+        return undefined;
+    }
+    const text = (key) => {
+        const value = props.get(key)?.getText();
+        props.delete(key);
+        return value;
+    };
+    const args = [nameText];
+    if (factory === 'vector') {
+        const dimensions = text('dimensions');
+        if (dimensions !== undefined)
+            args.push(dimensions);
+    }
+    const references = props.get('references');
+    props.delete('references');
+    const methods = [];
+    for (const [option, method] of OPTION_METHODS) {
+        const value = text(option);
+        const written = value === undefined ? '' : method(value);
+        if (written === undefined) {
+            report(root, `cannot write '${option}: ${value}' as a method: chain it, or not, by hand`);
+            return undefined;
+        }
+        methods.push(written);
+    }
+    if (props.size) {
+        report(root, `has options no column method writes: ${[...props.keys()].join(', ')}`);
+        return undefined;
+    }
+    const foreign = references && referencesSource(references);
+    if (references && foreign === undefined) {
+        report(root, `cannot write '${references.getText()}' as '.references(table, column)'`);
+        return undefined;
+    }
+    return `${builder}.${factory}(${args.join(', ')})${methods.join('')}${foreign ?? ''}`;
+}
+/** `{ table: 'users', column: 'id', onDelete: 'CASCADE' }` as `.references('users', 'id').onDelete('CASCADE')`. */
+function referencesSource(value) {
+    const props = propertiesByKey(value);
+    const table = props?.get('table')?.getText();
+    if (!table) {
+        return undefined;
+    }
+    const [column, onDelete, onUpdate] = ['column', 'onDelete', 'onUpdate'].map((key) => props?.get(key)?.getText());
+    return (`.references(${[table, column].filter(Boolean).join(', ')})` +
+        (onDelete ? `.onDelete(${onDelete})` : '') +
+        (onUpdate ? `.onUpdate(${onUpdate})` : ''));
+}
+/** One chained call in the new vocabulary. */
+function methodSource({ call, name }) {
+    const args = call.arguments.map((arg) => arg.getText());
+    const rename = RENAMED[name];
+    return rename ? rename(args) : `.${name}(${args.join(', ')})`;
+}

package/dist/relationTarget.d.ts

@@ -0,0 +1,6 @@
+import ts from 'typescript';
+/**
+ * The entity name a relation property points at: `Company` for `Company` and `Company[]` alike, since the
+ * element of an array is what a to-many relation targets.
+ */
+export declare function relationTargetFor(type: ts.Type, checker: ts.TypeChecker): string | undefined;