uql-codemod 0.48.1 → 0.49.0

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']>>`"],
@@ -49,7 +54,6 @@ const UTIL_ROOT_EXPORTS = [
     'currentDate',
     'currentTime',
     'currentTimestamp',
-    'raw',
     'sql',
     'refs',
     'uuid',
@@ -63,12 +67,17 @@ const UTIL_ROOT_EXPORTS = [
     'HookContext',
     'DefaultLogger',
 ];
+/** The name `uql-orm` gave its SQL tag, and gives it now. */
+export const LEGACY_SQL_TAG = 'raw';
+export const SQL_TAG = 'sql';
 /**
  * Exports renamed or moved and nothing else, so the import and every use follow, the import moving to `from`
  * where the name lives in another entry. Keyed by name, or by `entry#name` where the name stays elsewhere.
  */
 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' }],
@@ -97,11 +106,15 @@ 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' }],
+    [LEGACY_SQL_TAG, { to: SQL_TAG }],
+    [`uql-orm/util#${LEGACY_SQL_TAG}`, { to: SQL_TAG, from: 'uql-orm' }],
     ['uql-orm/http#Hook', { to: 'RequestHook' }],
     ['uql-orm/http#HookContext', { to: 'RequestHookContext' }],
     ...UTIL_ROOT_EXPORTS.map((name) => [`uql-orm/util#${name}`, { to: name, from: 'uql-orm' }]),
@@ -127,6 +140,8 @@ const MOVED_ENTRIES = new Map([
     ['uql-orm/querier', 'uql-orm'],
     ['uql-orm/type', 'uql-orm'],
 ]);
+/** The entry an import from `entry` lives in now. */
+const entryOf = (entry) => MOVED_ENTRIES.get(entry) ?? entry;
 /**
  * The file's named imports from `uql-orm`. `entries` adds the driver entries (`uql-orm/postgres`, ...),
  * for what is read by name only: `idKey` written into one would land on an entry that may not export it.
@@ -137,13 +152,15 @@ export function uqlImportDeclarations(source, entries = false) {
             return [];
         }
         const entry = declaration.moduleSpecifier.text;
-        if (entry !== 'uql-orm' && !(entries && entry.startsWith('uql-orm/'))) {
+        if (entries ? !isUqlEntry(entry) : entry !== 'uql-orm') {
             return [];
         }
         const bindings = declaration.importClause?.namedBindings;
         return bindings && ts.isNamedImports(bindings) ? [{ declaration, entry, elements: bindings.elements }] : [];
     });
 }
+/** Whether `entry` is `uql-orm` itself or one of its `uql-orm/<driver>` entries. */
+const isUqlEntry = (entry) => entry === 'uql-orm' || entry.startsWith('uql-orm/');
 function uqlImports(source, entries = false) {
     return uqlImportDeclarations(source, entries).flatMap(({ elements }) => elements);
 }
@@ -157,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) {
@@ -186,7 +220,7 @@ export function reportRemovedExports(ctx) {
             }
             continue;
         }
-        const root = (MOVED_ENTRIES.get(entry) ?? entry) === 'uql-orm';
+        const root = entryOf(entry) === 'uql-orm';
         for (const element of elements) {
             const name = importedName(element);
             const removed = REMOVED_EXPORTS.get(name);
@@ -200,116 +234,196 @@ export function reportRemovedExports(ctx) {
         }
     }
 }
-/**
- * Rewrites each import naming a {@link RENAMED_EXPORTS} export, or from a {@link MOVED_ENTRIES} entry, renaming
- * every use: a name moving entries gets an import from its new one, and one the file already imports is dropped,
- * as is a `dead` one. Returns the rewritten imports, which nothing else may edit.
- */
-export function renameExports(dead, ctx) {
-    const imports = uqlImportDeclarations(ctx.source, true);
-    const kept = imports.flatMap(({ entry, elements }) => elements.filter((element) => !renamedTo(element, entry)));
-    const bound = new Set(kept.map((element) => element.name.text));
-    const rewritten = new Set();
-    for (const { declaration, entry: imported, elements } of imports) {
-        const entry = MOVED_ENTRIES.get(imported) ?? imported;
-        if (entry === imported && !elements.some((element) => renamedTo(element, entry))) {
-            continue;
-        }
-        const byEntry = new Map([[entry, []]]);
-        for (const element of elements.filter(({ name }) => !dead.has(name.text))) {
-            const rename = renamedTo(element, entry);
-            const local = element.propertyName || !rename ? element.name.text : rename.to;
-            if (rename && !element.propertyName) {
-                ctx.edits.push(...usesOf(ctx.source, element.name, ctx.checker).map((use) => replaced(use, rename.to)));
-            }
-            if (rename && bound.has(local)) {
-                continue;
-            }
-            bound.add(local);
-            const target = rename?.from ?? entry;
-            const text = rename
-                ? `${element.isTypeOnly ? 'type ' : ''}${rename.to}${element.propertyName ? ` as ${local}` : ''}`
-                : element.getText();
-            byEntry.set(target, [...(byEntry.get(target) ?? []), text]);
-        }
-        const keyword = isTypeOnly(declaration) ? 'import type' : 'import';
-        const quote = declaration.moduleSpecifier.getText()[0];
-        const statements = [...byEntry]
-            .filter(([, names]) => names.length)
-            .map(([from, names]) => `${keyword} { ${names.join(', ')} } from ${quote}${from}${quote};`);
-        ctx.edits.push(statements.length ? replaced(declaration, statements.join('\n')) : removeStatement(declaration));
-        rewritten.add(declaration);
-    }
-    return rewritten;
-}
 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');
+        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) {
+    const declaration = node && ts.isIdentifier(node) ? checker.getSymbolAtLocation(node)?.declarations?.[0] : undefined;
+    return declaration && isUqlSpecifier(declaration) ? importedName(declaration) : undefined;
+}
+function isUqlSpecifier(declaration) {
+    if (!ts.isImportSpecifier(declaration)) {
+        return false;
     }
-    const names = ['Relation', 'expr'];
-    return new Set(names.filter((name) => rewritten[name] > 0 && rewritten[name] === uses(name)));
+    const { moduleSpecifier } = declaration.parent.parent.parent;
+    return ts.isStringLiteral(moduleSpecifier) && isUqlEntry(moduleSpecifier.text);
+}
+/** Whether `name` is the SQL tag, by either of its names. */
+export function isSqlExport(name) {
+    return name === SQL_TAG || name === LEGACY_SQL_TAG;
+}
+/** The name the file calls the SQL tag by once `raw` is renamed: the alias it imports it as, else `sql`. */
+export function sqlName(source) {
+    const element = uqlImports(source, true).find((it) => isSqlExport(importedName(it)));
+    return element?.propertyName ? element.name.text : SQL_TAG;
+}
+/** The names the rewrites wrote that the file does not import from `uql-orm` yet, each with what wrote it. */
+function missingNames(ctx) {
+    const imported = new Set(uqlImports(ctx.source, true).map(importedName));
+    const bound = [...imported].some(isSqlExport);
+    return [...ctx.imports].filter(([name]) => !imported.has(name) && !(bound && name === SQL_TAG));
+}
+const MEMBER = ts.SymbolFlags.Property | ts.SymbolFlags.Method | ts.SymbolFlags.Accessor | ts.SymbolFlags.EnumMember;
+/** Whether `node` names a binding or a reference that is not `uql-orm`'s, which an import of the same name would capture. */
+function isForeignName(node, checker) {
+    const symbol = checker.getSymbolAtLocation(node);
+    if (!symbol) {
+        const { parent } = node;
+        return !((ts.isPropertyAccessExpression(parent) || ts.isPropertyAssignment(parent)) && parent.name === node);
+    }
+    return !(symbol.flags & MEMBER) && !symbol.declarations?.every(isUqlSpecifier);
+}
+/**
+ * The first identifier of the file already naming something a rewrite writes: a name it imports (`sql`, `refs`,
+ * `idKey`) or a rename brings in. The write would shadow it or be shadowed, so the file is left to its owner.
+ */
+export function clashingName(ctx) {
+    const renamed = uqlImportDeclarations(ctx.source, true).flatMap(({ entry, elements }) => elements.flatMap((element) => {
+        const rename = renamedTo(element, entry);
+        return rename && !element.propertyName ? [rename.to] : [];
+    }));
+    const names = new Set([...missingNames(ctx).map(([name]) => name), ...renamed]);
+    const visit = (node) => ts.isIdentifier(node) && names.has(node.text) && isForeignName(node, ctx.checker)
+        ? node
+        : ts.forEachChild(node, visit);
+    return names.size ? visit(ctx.source) : undefined;
 }
 /**
- * Removes `import 'reflect-metadata'`, since the polyfill only ever fed `design:type`, and each `dead` name
- * from the imports {@link renameExports} left as written, having left the dead names out of the rest.
+ * Rewrites the file's imports in one pass: a name {@link RENAMED_EXPORTS} renames or a {@link MOVED_ENTRIES} entry
+ * moves is imported again where it lives now, every use renamed, and one already imported or `dead` is dropped.
+ * The names the rewrites wrote join the first `uql-orm` import, or are reported when there is none.
  */
-export function dropDeadImports(dead, rewritten, ctx) {
-    for (const statement of ctx.source.statements) {
+export function rewriteImports(dead, ctx) {
+    const { source } = ctx;
+    const imports = new Map(uqlImportDeclarations(source, true).map((it) => [it.declaration, it]));
+    const bound = new Set([...imports.values()]
+        .flatMap(({ entry, elements }) => elements.filter((element) => !renamedTo(element, entry)))
+        .map((element) => element.name.text));
+    const home = [...imports.values()].find(({ entry }) => entryOf(entry) === 'uql-orm');
+    const written = missingNames(ctx);
+    if (!home) {
+        for (const [name, what] of written) {
+            ctx.unresolved.push(`${source.fileName}: import '${name}' from 'uql-orm' for ${what} written here`);
+        }
+    }
+    for (const statement of source.statements) {
         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);
+        if (uql && (entry !== uql.entry || uql.elements.some((element) => renamedTo(element, entry)))) {
+            rebuildImport(uql, join, dead, bound, ctx);
         }
-        const named = statement.importClause?.namedBindings;
-        if (!named || !ts.isNamedImports(named) || rewritten.has(statement)) {
-            continue;
+        else {
+            patchImport(statement, join, dead, ctx);
         }
-        const dropped = named.elements.filter((element) => dead.has(element.name.text));
-        if (dropped.length === named.elements.length && !statement.importClause?.name) {
-            ctx.edits.push(removeStatement(statement));
-            continue;
+    }
+}
+/** An import of `names` from `from`, quoted as the file quotes its imports. */
+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.
+ */
+function rebuildImport({ declaration, entry: imported, elements }, join, dead, bound, ctx) {
+    const entry = entryOf(imported);
+    const typeOnly = isTypeOnly(declaration);
+    const byEntry = new Map([[entry, typeOnly ? [] : [...join]]]);
+    for (const element of elements.filter(({ name }) => !dead.has(name.text))) {
+        const rename = renamedTo(element, entry);
+        const local = element.propertyName || !rename ? element.name.text : rename.to;
+        if (rename && !element.propertyName) {
+            ctx.edits.push(...usesOf(ctx.source, element.name, ctx.checker).map((use) => replaced(use, rename.to)));
         }
-        for (const element of dropped) {
-            ctx.edits.push(removeFromList(named.elements, element, ctx.source));
+        if (rename && bound.has(local)) {
+            continue;
         }
+        bound.add(local);
+        const target = rename?.from ?? entry;
+        const text = rename
+            ? `${element.isTypeOnly ? 'type ' : ''}${rename.to}${element.propertyName ? ` as ${local}` : ''}`
+            : element.getText();
+        byEntry.set(target, [...(byEntry.get(target) ?? []), text]);
+    }
+    const keyword = typeOnly ? 'import type' : 'import';
+    const quote = declaration.moduleSpecifier.getText()[0];
+    const statements = [...byEntry]
+        .filter(([, names]) => names.length)
+        .map(([from, names]) => importText(keyword, names, from, quote));
+    if (typeOnly && join.length) {
+        statements.unshift(importText('import', join, 'uql-orm', quote));
     }
+    ctx.edits.push(statements.length ? replaced(declaration, statements.join('\n')) : removeStatement(declaration));
 }
 /**
- * Imports what the rewrites wrote (`idKey`, `raw`) into the file's own `uql-orm` import. Reported instead
- * where there is none: the package may be imported under a path this codemod does not recognise.
+ * 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 addImports(rewritten, ctx) {
-    const { source } = ctx;
-    const imported = new Set(uqlImports(source).map(importedName));
-    const missing = [...ctx.imports].filter(([name]) => !imported.has(name));
-    if (!missing.length) {
-        return;
+export function importRemovalEdits(declaration, elements, dropped) {
+    if (dropped.length !== elements.length) {
+        return removeFromList(elements, dropped, declaration.getSourceFile());
     }
-    const anchor = uqlImportDeclarations(source).find(({ declaration }) => !rewritten.has(declaration));
-    if (!anchor) {
-        for (const [name, what] of missing) {
-            ctx.unresolved.push(`${source.fileName}: import '${name}' from 'uql-orm' for ${what} written here`);
+    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 edits dropping each `uql-orm` import name in `candidates` that the file no longer spells. */
+export function unusedImportEdits(source, candidates) {
+    const spelled = spelledNames(source);
+    return uqlImportDeclarations(source, true).flatMap(({ declaration, elements }) => {
+        const dead = deadImports(elements, candidates, spelled);
+        return dead.length ? importRemovalEdits(declaration, elements, dead) : [];
+    });
+}
+/** 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;
+    if (!named || !ts.isNamedImports(named)) {
         return;
     }
-    const names = missing.map(([name]) => name);
-    ctx.edits.push(isTypeOnly(anchor.declaration)
-        ? inserted(anchor.declaration, `import { ${names.join(', ')} } from 'uql-orm';\n`)
-        : inserted(anchor.elements[0], names.map((name) => `${name}, `).join('')));
+    const dropped = named.elements.filter((element) => dead.has(element.name.text));
+    const statement = importText('import', join, 'uql-orm');
+    if (join.length && dropped.length === named.elements.length && !declaration.importClause?.name) {
+        ctx.edits.push(replaced(declaration, statement));
+        return;
+    }
+    ctx.edits.push(...importRemovalEdits(declaration, named.elements, dropped));
+    if (join.length) {
+        ctx.edits.push(isTypeOnly(declaration)
+            ? inserted(declaration, `${statement}\n`)
+            : inserted(named.elements[0], join.map((name) => `${name}, `).join('')));
+    }
 }

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;