uql-codemod 0.48.2 → 0.49.0

package/dist/syntax.js

@@ -7,9 +7,91 @@ export function identifierText(node) {
 export function propertyKey(name) {
     return ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : undefined;
 }
+export function isNamedProperty(prop) {
+    return ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop);
+}
 /** The property `name` of an object literal, a shorthand included. */
 export function namedProperty(node, name) {
-    return node.properties.find((prop) => (ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop)) && propertyKey(prop.name) === name);
+    return node.properties.find((prop) => isNamedProperty(prop) && propertyKey(prop.name) === name);
+}
+/** The key a property is written under, a shorthand's included; nothing for a spread, a method or a computed key. */
+export function keyOf(prop) {
+    return isNamedProperty(prop) ? propertyKey(prop.name) : undefined;
+}
+/** The options `value` writes: a literal to read and write into, or why it is not one. */
+export function optionsOf(value) {
+    if (!ts.isObjectLiteralExpression(value)) {
+        return { kind: 'opaque', reason: `its options are passed as '${value.getText()}'` };
+    }
+    return value.properties.some(ts.isSpreadAssignment)
+        ? { kind: 'opaque', reason: 'its options object spreads another' }
+        : { kind: 'literal', node: value };
+}
+/**
+ * An object literal's named properties by key, each as its value (a shorthand's value is its name), or `undefined`
+ * where `node` is no literal or one of its properties is spread, computed or a method.
+ */
+export function propertiesByKey(node) {
+    const literal = objectLiteral(node);
+    if (!literal) {
+        return undefined;
+    }
+    const props = new Map();
+    for (const prop of literal.properties) {
+        if (!isNamedProperty(prop)) {
+            return undefined;
+        }
+        const key = propertyKey(prop.name);
+        if (key === undefined) {
+            return undefined;
+        }
+        props.set(key, ts.isShorthandPropertyAssignment(prop) ? prop.name : prop.initializer);
+    }
+    return props;
+}
+/** The root a method chain starts from, and its methods in source order: `f.string().nullable()` is `f` and two. */
+export function chainOf(node) {
+    const methods = [];
+    let root = node;
+    while (ts.isCallExpression(root) && ts.isPropertyAccessExpression(root.expression)) {
+        methods.unshift({ call: root, name: root.expression.name.text, receiver: root.expression.expression });
+        root = root.expression.expression;
+    }
+    return { root, methods };
+}
+export function hasModifier(node, kind) {
+    return ts.canHaveModifiers(node) && !!ts.getModifiers(node)?.some((modifier) => modifier.kind === kind);
+}
+/** `preferred`, or it numbered past every name `nodes` mention, so a parameter named so shadows nothing they read. */
+export function freeName(preferred, nodes) {
+    const taken = (name) => nodes.some((node) => mentions(node, name));
+    let name = preferred;
+    for (let n = 2; taken(name); n++) {
+        name = `${preferred}${n}`;
+    }
+    return name;
+}
+/** Whether `node` is an identifier reading `name`, not a member named so. */
+function readsName(node, name) {
+    return (ts.isIdentifier(node) &&
+        node.text === name &&
+        !(ts.isPropertyAccessExpression(node.parent) && node.parent.name === node));
+}
+/** Each identifier in `node` naming `name`, in source order, nested functions included, but none a member named so. */
+export function identifierUses(node, name) {
+    const uses = [];
+    const visit = (child) => {
+        if (readsName(child, name)) {
+            uses.push(child);
+        }
+        ts.forEachChild(child, visit);
+    };
+    visit(node);
+    return uses;
+}
+/** Whether `node` reads a binding named `name`, which a callback parameter of that name would shadow: stops at the first. */
+export function mentions(node, name) {
+    return readsName(node, name) || !!ts.forEachChild(node, (child) => mentions(child, name) || undefined);
 }
 /** The property `name` of an object literal that is written with a value. */
 export function propertyAssignment(node, name) {
@@ -22,6 +104,13 @@ export function propertyValue(node, name) {
 export function objectProperties(node) {
     return node && ts.isObjectLiteralExpression(node) ? node.properties.filter(ts.isPropertyAssignment) : [];
 }
+/** The entries of a column list, written as an array or returned by its callback. */
+export function columnListEntries(list) {
+    if (list && ts.isArrowFunction(list) && !ts.isBlock(list.body)) {
+        return arrayElements(list.body);
+    }
+    return arrayElements(list);
+}
 /** The elements of an array literal, or none where `node` is not one. */
 export function arrayElements(node) {
     return node && ts.isArrayLiteralExpression(node) ? node.elements : [];
@@ -30,6 +119,35 @@ export function arrayElements(node) {
 export function objectLiteral(node) {
     return node && ts.isObjectLiteralExpression(node) ? node : undefined;
 }
+const indentUnits = new WeakMap();
+/** Whether `node` starts a line of code whose indent a file's unit is read from: a member, a property, a statement. */
+const startsCodeLine = (node) => ts.isClassElement(node) ||
+    ts.isPropertyAssignment(node) ||
+    ts.isShorthandPropertyAssignment(node) ||
+    ts.isVariableStatement(node) ||
+    ts.isExpressionStatement(node) ||
+    ts.isClassDeclaration(node) ||
+    ts.isFunctionDeclaration(node) ||
+    ts.isImportDeclaration(node);
+/** One level of indentation as the file writes it: the shallowest indent of its code, two spaces where it has none. */
+export function indentUnit(source) {
+    const known = indentUnits.get(source);
+    if (known !== undefined) {
+        return known;
+    }
+    const indents = [];
+    const visit = (node) => {
+        const indent = startsCodeLine(node) ? indentOf(node) : '';
+        if (indent) {
+            indents.push(indent);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    const unit = indents.reduce((shallow, indent) => (indent.length < shallow.length ? indent : shallow), indents[0] ?? '  ');
+    indentUnits.set(source, unit);
+    return unit;
+}
 /** A node's decorators, or none where it is a kind that cannot carry them. */
 export function decoratorsOf(node) {
     return ts.canHaveDecorators(node) ? (ts.getDecorators(node) ?? []) : [];
@@ -39,3 +157,15 @@ export function decoratorName(node) {
     const { expression } = node;
     return identifierText(ts.isCallExpression(expression) ? expression.expression : expression);
 }
+/** The decorators declaring a field: `@Field`, and `@Id` for the key the class names. */
+export const FIELD_DECORATORS = new Set(['Field', 'Id']);
+/** Where the line holding offset `at` of `text` starts. */
+export function lineStartOf(text, at) {
+    return text.lastIndexOf('\n', at - 1) + 1;
+}
+/** The whitespace the line holding `node` starts with. */
+export function indentOf(node) {
+    const text = node.getSourceFile().text;
+    const line = text.slice(lineStartOf(text, node.getStart()), node.getStart());
+    return line.slice(0, line.length - line.trimStart().length);
+}

package/dist/transform.d.ts

@@ -1,4 +1,5 @@
 import ts from 'typescript';
+import { type Pass } from './edits.js';
 export type FileResult = {
     readonly fileName: string;
     readonly text: string;
@@ -9,9 +10,17 @@ export type FileResult = {
     readonly notes: readonly string[];
 };
 /**
- * Rewrites one source file for the standard decorator spec. The builder's and querier's methods are known by
- * name, so they are read only in a file importing uql-orm, and `expr` only where it is uql's.
+ * Rewrites one file across every breaking change: the earlier ones off the checker, then column builders and schema
+ * chains off the text those produced, so neither pass edits what the other writes.
  */
 export declare function transformFile(source: ts.SourceFile, checker: ts.TypeChecker, options?: {
     readonly strictNullChecks: boolean;
 }): FileResult;
+/**
+ * The rewrites the checker reads types for, up to the schema entities a class-form registration declares. The
+ * builder's and querier's methods are known by name, so they are read only in a file importing uql-orm, and `expr`
+ * only where it is uql's.
+ */
+export declare function rewriteLegacy(source: ts.SourceFile, checker: ts.TypeChecker, options: {
+    readonly strictNullChecks: boolean;
+}): FileResult & Pass;

package/dist/transform.js

@@ -1,14 +1,19 @@
 import ts from 'typescript';
+import { BUILDER_NAMES, isBuilder, toBuilders } from './builders.js';
+import { foldClassDecorators } from './classOptions.js';
 import { rewriteColumnRefs } from './columnRefs.js';
-import { createContext, instanceTypeOf, memberNames, ownerOf } from './context.js';
-import { appended, applyEdits, inserted, original, replaced } from './edits.js';
+import { createContext, instanceTypeOf, locationAt, memberNames, ownerOf, } from './context.js';
+import { definerCall } from './definers.js';
+import { appended, editedText, followed, inserted, original, replaced, unedited, } from './edits.js';
 import { columnExpressions, handNamedColumns, sqlTag, sqlWhereEdit, templateOf } from './entitySql.js';
-import { fieldTypeFor, isBrandedString, relationTargetFor } from './fieldType.js';
-import { clashingName, deadImportNames, LEGACY_SQL_TAG, reportRemovedExports, rewriteImports, SQL_TAG, sqlName, uqlExport, uqlImport, uqlImportDeclarations, } from './imports.js';
+import { clashingName, deadImportNames, foreignNames, LEGACY_SQL_TAG, reportRemovedExports, rewriteImports, SQL_TAG, sqlName, uqlExport, uqlImport, uqlImportDeclarations, } from './imports.js';
+import { rewriteBuilderIndexLengths, rewriteJsonIndexEntries } from './jsonIndex.js';
 import { entityGetterTarget, fieldKeysEdits, isCallback, keyListEdits, mappedByEdits, memberAccess, paramFor, quoted, referencesEdits, } from './keyMaps.js';
+import { toMigrationBuilders } from './migrationBuilders.js';
+import { relationTargetFor } from './relationTarget.js';
+import { toSchemaEntities } from './schemaEntity.js';
 import { statementTemplate } from './statementSql.js';
-import { arrayElements, decoratorName, decoratorsOf, identifierText, namedProperty, objectLiteral, objectProperties, propertyKey, propertyValue, } from './syntax.js';
-const FIELD_DECORATORS = new Set(['Field', 'Id']);
+import { arrayElements, decoratorName, decoratorsOf, FIELD_DECORATORS, identifierText, indentOf, namedProperty, objectLiteral, objectProperties, optionsOf, propertyKey, propertyValue, } from './syntax.js';
 const RELATION_DECORATORS = new Set(['OneToOne', 'ManyToOne', 'OneToMany', 'ManyToMany']);
 const TO_ONE_DECORATORS = new Set(['OneToOne', 'ManyToOne']);
 const TO_ONE_CARDINALITIES = new Set(['11', 'm1']);
@@ -31,15 +36,6 @@ function decoratorOptions(node) {
     const [first] = node.expression.arguments;
     return first ? optionsOf(first) : { kind: 'empty', call: node.expression };
 }
-/** The options `value` writes: a literal to read and write into, or why it is not one. */
-function optionsOf(value) {
-    if (!ts.isObjectLiteralExpression(value)) {
-        return { kind: 'opaque', reason: `its options are passed as '${value.getText()}'` };
-    }
-    return value.properties.some(ts.isSpreadAssignment)
-        ? { kind: 'opaque', reason: 'its options object spreads another' }
-        : { kind: 'literal', node: value };
-}
 /** The option `name`, however its key is written: a stated option is left alone, and a renamed one moved. */
 function findProperty(options, name) {
     return options.kind === 'literal' ? namedProperty(options.node, name) : undefined;
@@ -76,63 +72,15 @@ function noteHandNamedColumns(sql, owner, ctx) {
     ctx.note(sql, `SQL names ${names.map((name) => `'${name}'`).join(', ')} by hand, which a rename does not reach; ` +
         `read each off a callback's refs instead: (${owner.param}) => sql\`...\${${owner.param}.<member>}...\``);
 }
-/** Inserts `option` into the decorator's options object, creating one in an empty argument list. */
-function insertOption(options, option) {
-    if (options.kind === 'empty') {
-        const { arguments: args } = options.call;
-        return { start: args.pos, end: args.end, text: `{ ${option} }` };
-    }
-    const first = options.node.properties[0];
-    return first ? inserted(first, `${option}, `) : replaced(options.node, `{ ${option} }`);
-}
-/**
- * Writes one option the decorator can no longer infer at runtime, or records why it could not. Returns the
- * property's type where it wrote one, for the caller to say more about.
- */
-function addInferredOption(decorator, node, ctx, spec) {
+/** Reports a decorator lacking `option` unless one of `satisfiedBy` states it, or options it cannot read, which may. */
+function reportMissingOption(decorator, node, ctx, spec) {
     const options = decoratorOptions(decorator);
-    if (spec.satisfiedBy.some((name) => findProperty(options, name))) {
-        return undefined;
-    }
     if (options.kind === 'opaque') {
-        ctx.report(node, `cannot add '${spec.option}' because ${options.reason}`);
-        return undefined;
+        ctx.report(node, options.reason);
     }
-    const type = ctx.checker.getTypeAtLocation(node);
-    const value = spec.infer(type);
-    if (!value) {
-        ctx.report(node, `cannot infer '${spec.option}' for ${ctx.checker.typeToString(type)}`);
-        return undefined;
+    else if (!spec.satisfiedBy.some((name) => findProperty(options, name))) {
+        ctx.report(node, `has no '${spec.option}': ${spec.advice}`);
     }
-    ctx.edits.push(insertOption(options, `${spec.option}: ${value}`));
-    return type;
-}
-/**
- * Writes the `type` that `design:type` supplied, unless `references` (the key it points at decides) or
- * `computed` does. A branded id erased to `String`, which keeps the column; `'uuid'` would change it, so that
- * is noted rather than decided.
- */
-function addFieldType(decorator, node, ctx) {
-    const type = addInferredOption(decorator, node, ctx, {
-        option: 'type',
-        satisfiedBy: ['type', 'references', 'computed'],
-        infer: fieldTypeFor,
-    });
-    if (type && isBrandedString(type)) {
-        ctx.note(node, `set 'type: ${fieldTypeFor(type)}' for ${ctx.checker.typeToString(type)}, matching the previous behaviour. ` +
-            "If the column should be 'uuid', change it deliberately: that alters the schema.");
-    }
-}
-/** Writes the `entity` getter relations can no longer infer. */
-function addRelationEntity(decorator, node, ctx) {
-    addInferredOption(decorator, node, ctx, {
-        option: 'entity',
-        satisfiedBy: ['entity'],
-        infer: (t) => {
-            const target = relationTargetFor(t, ctx.checker);
-            return target && `() => ${target}`;
-        },
-    });
 }
 /**
  * Names the foreign key a to-one used to find by name, `references: (post) => post.authorId` beside `author`.
@@ -187,10 +135,6 @@ function foreignKeyColumn(property, column, relation, checker) {
     const type = keyTypeSource(key, property, checker);
     return inserted(property, `@Field({ references: () => ${target} }) ${column}?: ${type} | null;\n${indentOf(property)}`);
 }
-/** The whitespace a line starting at `node` is indented by. */
-function indentOf(node) {
-    return ' '.repeat(node.getSourceFile().getLineAndCharacterOfPosition(node.getStart()).character);
-}
 /** The key's type as written where that is in scope, the same file, or as the checker spells it out. */
 function keyTypeSource(key, at, checker) {
     const written = key.declarations?.find(isIdProperty)?.type;
@@ -199,10 +143,24 @@ function keyTypeSource(key, at, checker) {
     }
     return checker.typeToString(checker.getNonNullableType(checker.getTypeOfSymbolAtLocation(key, at)), at);
 }
-/** Whether a declaration is a property carrying one of `names` as a decorator. */
-const decoratedWith = (names) => (node) => ts.isPropertyDeclaration(node) && decoratorsOf(node).some((decorator) => names.has(decoratorName(decorator) ?? ''));
-const isIdProperty = decoratedWith(new Set(['Id']));
-const isFieldProperty = decoratedWith(FIELD_DECORATORS);
+/** Whether a declaration is a property declaring a column, `@Field(...)` or `@Id(...)`. */
+function isFieldProperty(node) {
+    return (ts.isPropertyDeclaration(node) &&
+        decoratorsOf(node).some((decorator) => FIELD_DECORATORS.has(decoratorName(decorator))));
+}
+/** Whether a declaration is a key property: `@Id(...)`, or `@Field({ isId: true, ... })`. */
+function isIdProperty(node) {
+    return ts.isPropertyDeclaration(node) && decoratorsOf(node).some(declaresKey);
+}
+function declaresKey(decorator) {
+    const name = decoratorName(decorator);
+    if (name !== 'Field') {
+        return name === 'Id';
+    }
+    const options = decoratorOptions(decorator);
+    const isId = options.kind === 'literal' ? propertyValue(options.node, 'isId') : undefined;
+    return isId?.kind === ts.SyntaxKind.TrueKeyword;
+}
 /**
  * Writes the edits `rewrite` reads off `value`, which still names members as strings, or reports it
  * where it could not be read: what it holds is only known at runtime. A callback or an object literal
@@ -244,6 +202,7 @@ function rewriteClassDecorators(node, ctx) {
         }
         else if (name === 'Entity' && options) {
             rewriteEntityOptions(options, owner, ctx);
+            reportEntityMembers(options, ctx);
         }
     }
 }
@@ -253,23 +212,25 @@ function rewriteClassDecorators(node, ctx) {
  * Only uql's shapes, a class and a literal options object, are read.
  */
 function rewriteDefineCall(call, ctx) {
-    const name = identifierText(call.expression);
-    const [entity = call, second, third] = call.arguments;
-    const owner = ownerOf(entity);
-    const options = objectLiteral(second);
-    const relation = objectLiteral(third);
-    if (name === 'defineEntity' && options) {
-        rewriteEntityOptions(options, owner, ctx);
+    const read = definerCall(call);
+    if (!read) {
+        return;
     }
-    else if (name === 'defineIndex' && options) {
-        rewriteIndexOptions(options, owner, ctx);
+    const { definer, key, options } = read;
+    const owner = ownerOf(read.entity);
+    const literal = objectLiteral(options);
+    if (definer === 'defineEntity' && literal) {
+        rewriteEntityOptions(literal, owner, ctx);
     }
-    else if (name === 'defineRelation' && relation) {
-        rewriteRelationOptions(relation, owner.param, ctx);
-        addForeignKeyReference(relation, second && ts.isStringLiteralLike(second) ? second.text : undefined, owner, ctx);
+    else if (definer === 'defineIndex' && literal) {
+        rewriteIndexOptions(literal, owner, ctx);
     }
-    else if (name === 'defineFilter' && third) {
-        renameOption(optionsOf(third), 'condition', 'where', call, ctx);
+    else if (definer === 'defineRelation' && literal) {
+        rewriteRelationOptions(literal, owner.param, ctx);
+        addForeignKeyReference(literal, key, owner, ctx);
+    }
+    else if (definer === 'defineFilter' && options) {
+        renameOption(optionsOf(options), 'condition', 'where', call, ctx);
     }
 }
 function rewriteEntityOptions(options, owner, ctx) {
@@ -284,7 +245,6 @@ function rewriteEntityOptions(options, owner, ctx) {
     }
     for (const field of objectProperties(fields)) {
         renameSqlOption(optionsOf(field.initializer), 'virtual', 'computed', field, owner, ctx);
-        admitNullOnDefined(field, owner, ctx);
     }
     for (const filter of objectProperties(propertyValue(options, 'filters'))) {
         renameOption(optionsOf(filter.initializer), 'condition', 'where', filter, ctx);
@@ -299,6 +259,21 @@ function rewriteEntityOptions(options, owner, ctx) {
         }
     }
 }
+/** The options `@Entity` no longer takes: the members, which the decorators declare, and a base, which the class extends. */
+const DECORATED_MEMBER_OPTIONS = new Map([
+    ['fields', 'declare each with @Field or @Id'],
+    ['relations', 'declare each with its relation decorator'],
+    ['hooks', 'mark each method with its hook decorator'],
+    ['extends', 'extend the base class itself'],
+]);
+function reportEntityMembers(options, ctx) {
+    for (const [option, advice] of DECORATED_MEMBER_OPTIONS) {
+        const property = namedProperty(options, option);
+        if (property) {
+            ctx.report(property, `@Entity takes no '${option}' now: ${advice}`);
+        }
+    }
+}
 function rewriteIndexOptions(index, owner, ctx) {
     rewriteIndex(propertyValue(index, 'columns'), index, owner, index, "'columns'", ctx);
 }
@@ -309,6 +284,7 @@ function rewriteIndexOptions(index, owner, ctx) {
 function rewriteIndex(columns, options, owner, node, what, ctx) {
     const literal = objectLiteral(options);
     rewriteKeyList(columns, owner.param, node, what, ctx);
+    rewriteJsonIndexEntries(columns, ctx);
     rewriteKeyList(literal && propertyValue(literal, 'include'), owner.param, node, "'include'", ctx);
     rewriteIndexWhere(literal, ctx);
     for (const sql of [...columnExpressions(columns, ctx.checker), literal && propertyValue(literal, 'where')]) {
@@ -445,6 +421,7 @@ function rewriteBuilderCall(call, ctx) {
         ? BUILDER_INDEX_METHODS.get(call.expression.name.text)
         : undefined;
     if (at !== undefined) {
+        rewriteBuilderIndexLengths(call.arguments[at - 1], ctx);
         rewriteIndexWhere(objectLiteral(call.arguments[at]), ctx);
     }
 }
@@ -496,6 +473,29 @@ function rewriteStatementKeys(node, ctx) {
     else if (key === '$lock' && ts.isObjectLiteralExpression(node.initializer)) {
         rewriteLock(node.initializer, ctx);
     }
+    else if (key === '$exclude') {
+        rewriteExclude(node, ctx);
+    }
+}
+/** `$exclude: { body: true }` as `$select: { body: false }`, the one way left to leave a field out. */
+function rewriteExclude(exclude, ctx) {
+    if (ts.isObjectLiteralExpression(exclude.parent) && propertyValue(exclude.parent, '$select')) {
+        ctx.report(exclude, "merge '$exclude' into the '$select' beside it, each field as `field: false`");
+        return;
+    }
+    const fields = objectLiteral(exclude.initializer);
+    const entries = objectProperties(fields);
+    if (!fields ||
+        entries.length !== fields.properties.length ||
+        !entries.every((it) => isTruthyLiteral(it.initializer))) {
+        ctx.report(exclude, "write '$exclude' as `$select: { field: false }`");
+        return;
+    }
+    ctx.edits.push(replaced(exclude.name, '$select'), ...entries.map((entry) => replaced(entry.initializer, 'false')));
+}
+/** `true` or `1`, how an `$exclude` entry leaves its field out. */
+function isTruthyLiteral(node) {
+    return node.kind === ts.SyntaxKind.TrueKeyword || (ts.isNumericLiteral(node) && node.text === '1');
 }
 /** `{ wait: 'skip' }` as `{ $wait: 'skip' }`, and `{}` or a `'block'` wait as `true`, which waits. */
 function rewriteLock(lock, ctx) {
@@ -540,21 +540,6 @@ function dropDeclare(node, ctx) {
         ctx.edits.push({ start: modifier.getStart(), end, text: '' });
     }
 }
-/**
- * Unwraps `Relation<Company>` to `Company`. The alias is `type Relation<T> = T`, and it existed only
- * because reflection stored the property's type at class-definition time, which forced a real import and
- * so created the circular-import problem it was working around.
- */
-function unwrapRelationAlias(node, ctx) {
-    const declared = node.type;
-    if (declared &&
-        ts.isTypeReferenceNode(declared) &&
-        identifierText(declared.typeName) === 'Relation' &&
-        declared.typeArguments?.length === 1) {
-        ctx.edits.push(replaced(declared, [original(declared.typeArguments[0])]));
-        ctx.rewritten.Relation += 1;
-    }
-}
 /** The names a key is read from without help, mirroring `NamedIdKey` in `uql-orm`. */
 const CONVENTIONAL_ID_NAMES = new Set(['id', '_id', 'uuid']);
 /** Whether the member is an `[idKey]?: ...` brand, matched by the name it is written under. */
@@ -594,18 +579,23 @@ function rewriteProperty(node, ctx) {
     for (const decorator of decorators) {
         const name = decoratorName(decorator) ?? '';
         const options = decoratorOptions(decorator);
-        if (FIELD_DECORATORS.has(name)) {
+        if (FIELD_DECORATORS.has(name) && !writesBuilder(decorator)) {
             if (name === 'Field') {
                 admitNull(options, node, ctx);
             }
-            addFieldType(decorator, node, ctx);
-            if (options.kind === 'opaque' && /\bvirtual\b/.test(decorator.getText())) {
-                ctx.report(node, options.reason);
-            }
+            reportMissingOption(decorator, node, ctx, {
+                option: 'type',
+                satisfiedBy: ['type', 'references', 'computed'],
+                advice: 'declare its column as a builder, such as `f.string()`',
+            });
             renameSqlOption(options, 'virtual', 'computed', node, owner, ctx);
         }
         if (RELATION_DECORATORS.has(name)) {
-            addRelationEntity(decorator, node, ctx);
+            reportMissingOption(decorator, node, ctx, {
+                option: 'entity',
+                satisfiedBy: ['entity'],
+                advice: 'name its target, `entity: () => Target`',
+            });
             if (options.kind === 'literal') {
                 const target = relationTargetFor(ctx.checker.getTypeAtLocation(node), ctx.checker);
                 rewriteRelationOptions(options.node, owner.param, ctx, paramFor(target));
@@ -618,18 +608,23 @@ function rewriteProperty(node, ctx) {
     if (decorators.length) {
         dropDeclare(node, ctx);
     }
-    unwrapRelationAlias(node, ctx);
+}
+/** Whether a field decorator already declares its column with a builder, which states everything the rewrites add. */
+function writesBuilder(decorator) {
+    const [first] = ts.isCallExpression(decorator.expression) ? decorator.expression.arguments : [];
+    return first !== undefined && isBuilder(first);
 }
 /**
  * A column holds `null` unless `nullable: false` says otherwise, so the property says so too. A key is NOT NULL
  * everywhere and a relation aggregate types its own, so neither is touched; nor are options it cannot read,
- * which may state `nullable` and are reported by {@link addFieldType} already.
+ * which may state `nullable` and are reported by {@link reportMissingOption} already.
  */
 function admitNull(options, node, ctx) {
     if (options.kind === 'opaque' ||
         !ctx.strictNullChecks ||
         declaresNotNull(options) ||
         findProperty(options, 'isId') ||
+        findProperty(options, 'version') ||
         (findProperty(options, 'computed') && !findProperty(options, 'type'))) {
         return;
     }
@@ -640,18 +635,6 @@ function admitNull(options, node, ctx) {
         ctx.edits.push(appended(node.type, ' | null'));
     }
 }
-/** The same null rule where `defineEntity` names the field, on the property of the class the call takes. */
-function admitNullOnDefined(field, owner, ctx) {
-    const key = propertyKey(field.name);
-    const declaration = key
-        ? instanceTypeOf(owner.entity, ctx.checker)
-            .getProperty(key)
-            ?.declarations?.find((it) => ts.isPropertyDeclaration(it))
-        : undefined;
-    if (declaration?.type) {
-        admitNull(optionsOf(field.initializer), declaration, ctx);
-    }
-}
 /** Whether the options say the column refuses `null`; `nullable: true` is the default said out loud. */
 function declaresNotNull(options) {
     const nullable = findProperty(options, 'nullable');
@@ -698,10 +681,29 @@ function rewriteRawCall(node, ctx) {
     }
 }
 /**
- * Rewrites one source file for the standard decorator spec. The builder's and querier's methods are known by
- * name, so they are read only in a file importing uql-orm, and `expr` only where it is uql's.
+ * Rewrites one file across every breaking change: the earlier ones off the checker, then column builders and schema
+ * chains off the text those produced, so neither pass edits what the other writes.
  */
 export function transformFile(source, checker, options = { strictNullChecks: true }) {
+    const legacy = rewriteLegacy(source, checker, options);
+    const located = (pass) => (at) => locationAt(source, pass.sourceOffset(at));
+    const taken = foreignNames(source, BUILDER_NAMES, checker);
+    const builders = toBuilders(source.fileName, legacy.text, { locate: located(legacy), taken });
+    const { text, unresolved } = toMigrationBuilders(source.fileName, builders.text, located(followed(legacy, builders)));
+    return {
+        fileName: source.fileName,
+        text,
+        changed: text !== source.getFullText(),
+        unresolved: [...legacy.unresolved, ...builders.unresolved, ...unresolved],
+        notes: legacy.notes,
+    };
+}
+/**
+ * The rewrites the checker reads types for, up to the schema entities a class-form registration declares. The
+ * builder's and querier's methods are known by name, so they are read only in a file importing uql-orm, and `expr`
+ * only where it is uql's.
+ */
+export function rewriteLegacy(source, checker, options) {
     const ctx = createContext(source, checker, options.strictNullChecks);
     const importsUql = uqlImportDeclarations(source, true).length > 0;
     const importsExpr = uqlImport(source, 'expr', true) !== undefined;
@@ -717,6 +719,7 @@ export function transformFile(source, checker, options = { strictNullChecks: tru
         if (ts.isClassLike(node)) {
             brandIdKey(node, ctx);
             rewriteClassDecorators(node, ctx);
+            foldClassDecorators(node, ctx);
         }
         if (ts.isCallExpression(node)) {
             rewriteDefineCall(node, ctx);
@@ -741,12 +744,16 @@ export function transformFile(source, checker, options = { strictNullChecks: tru
     const clash = clashingName(ctx);
     if (clash) {
         ctx.report(clash, `'${clash.text}' is already named here, and the codemod writes it: rename that, then run again`);
-        return fileResult(ctx, source.getFullText());
+        return { ...fileResult(ctx, source.getFullText()), ...unedited(source.getFullText()) };
     }
     const dead = new Set([...deadImportNames(ctx), ...rewriteColumnRefs(ctx)]);
     rewriteImports(dead, ctx);
     reportRemovedExports(ctx);
-    return fileResult(ctx, applyEdits(source.getFullText(), ctx.edits));
+    const edited = editedText(source.getFullText(), ctx.edits);
+    const schema = toSchemaEntities(source.fileName, edited.text, (at) => locationAt(source, edited.sourceOffset(at)));
+    ctx.unresolved.push(...schema.unresolved);
+    ctx.notes.push(...schema.notes);
+    return { ...fileResult(ctx, schema.text), sourceOffset: followed(edited, schema).sourceOffset };
 }
 function fileResult({ source, unresolved, notes }, text) {
     return { fileName: source.fileName, text, changed: text !== source.getFullText(), unresolved, notes };

package/dist/tsconfig.d.ts

@@ -1,11 +1,5 @@
-export type TsconfigResult = {
-    readonly text: string;
-    readonly changed: boolean;
-    /** What the codemod will not decide, each needing a human. */
-    readonly unresolved: readonly string[];
-};
 /**
- * Rewrites a `tsconfig.json` for the standard decorator spec, as text through `ts.parseJsonText` rather than
- * re-serialised: a tsconfig is JSON with comments and someone's formatting, which a rewrite would throw away.
+ * What a `tsconfig.json` needs decided by hand for the standard decorator spec. The file is only read, never
+ * written: its flags are the project's to remove, and a rewrite would have to keep its comments and formatting.
  */
-export declare function transformTsconfig(fileName: string, text: string): TsconfigResult;
+export declare function checkTsconfig(fileName: string, text: string): readonly string[];