uql-codemod 0.48.1 → 0.49.0

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, replaced } from './edits.js';
-import { columnExpressions, handNamedColumns, rawTag, rawWhereEdit } from './entitySql.js';
-import { fieldTypeFor, isBrandedString, relationTargetFor } from './fieldType.js';
-import { addImports, deadImportNames, dropDeadImports, renameExports, reportRemovedExports, uqlImport, uqlImportDeclarations, } from './imports.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 { 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;
@@ -69,70 +65,22 @@ function renameSqlOption(options, from, to, node, owner, ctx) {
 }
 /** Notes SQL that names a column by hand, which a rename does not reach. */
 function noteHandNamedColumns(sql, owner, ctx) {
-    const names = sql ? handNamedColumns(sql, memberNames(owner.entity, ctx.checker)) : [];
+    const names = sql ? handNamedColumns(sql, memberNames(owner.entity, ctx.checker), ctx.checker) : [];
     if (!sql || !names.length) {
         return;
     }
     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}) => raw\`...\${${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} }`);
+        `read each off a callback's refs instead: (${owner.param}) => sql\`...\${${owner.param}.<member>}...\``);
 }
-/**
- * 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 (definer === 'defineIndex' && literal) {
+        rewriteIndexOptions(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 === 'defineRelation' && literal) {
+        rewriteRelationOptions(literal, owner.param, ctx);
+        addForeignKeyReference(literal, key, owner, ctx);
     }
-    else if (name === 'defineFilter' && third) {
-        renameOption(optionsOf(third), 'condition', 'where', call, 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,25 +284,26 @@ 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), literal && propertyValue(literal, 'where')]) {
+    for (const sql of [...columnExpressions(columns, ctx.checker), literal && propertyValue(literal, 'where')]) {
         noteHandNamedColumns(sql, owner, ctx);
     }
 }
-/** A partial-index `where` string as `raw`, on an entity and in the migration builder alike, or reported. */
+/** A partial-index `where` string as `sql`, on an entity and in the migration builder alike, or reported. */
 function rewriteIndexWhere(options, ctx) {
     const where = options && propertyValue(options, 'where');
     if (!where || !isStringTyped(ctx.checker.getTypeAtLocation(where))) {
         return;
     }
-    const edit = rawWhereEdit(where);
+    const edit = sqlWhereEdit(where, sqlName(ctx.source));
     if (edit) {
         ctx.edits.push(edit);
-        ctx.imports.set('raw', 'the raw`...`');
+        ctx.imports.set(SQL_TAG, 'the sql`...`');
     }
     else {
-        ctx.report(where, "write the partial-index 'where' as raw`...` or a predicate; this one could not be read");
+        ctx.report(where, "write the partial-index 'where' as sql`...` or a predicate; this one could not be read");
     }
 }
 /** Whether every value `type` admits is a string. */
@@ -360,7 +336,7 @@ function rewriteMethodCall(call, ctx) {
 /**
  * A querier's `run`/`all` handed SQL as a string, which now takes a tagged statement: a literal becomes
  * `run`...``, its values interpolated where {@link statementTemplate} can place them, and SQL built at run
- * time `raw.text`, which splices as the string did. Values it cannot place are reported.
+ * time `<sql>.text(...)`, which splices as the string did. Values it cannot place are reported.
  */
 function rewriteSqlCall(call, method, ctx) {
     const [sql, ...values] = call.arguments;
@@ -369,19 +345,21 @@ function rewriteSqlCall(call, method, ctx) {
     }
     const template = statementTemplate(sql, values);
     if (template) {
-        const typeArguments = call.typeArguments ? `<${call.typeArguments.map((type) => type.getText()).join(', ')}>` : '';
-        ctx.edits.push(replaced(call, `${call.expression.getText()}${typeArguments}${template}`));
+        const typeArguments = (call.typeArguments ?? []).map(original);
+        const listed = typeArguments.flatMap((type, at) => (at ? [', ', type] : [type]));
+        const angle = typeArguments.length ? ['<', ...listed, '>'] : [];
+        ctx.edits.push(replaced(call, [original(call.expression), ...angle, ...template]));
         return;
     }
     if (values.length) {
-        ctx.report(call, `${method}() takes one raw statement: write the values into it, raw\`... \${value}\`, which binds them`);
+        ctx.report(call, `${method}() takes one statement: write the values into it, sql\`... \${value}\`, which binds them`);
         return;
     }
     if (ts.isTemplateExpression(sql)) {
-        ctx.note(call, 'the values in this template are spliced into the SQL; write it as raw`...` to bind them');
+        ctx.note(call, 'the values in this template are spliced into the SQL; write it as sql`...` to bind them');
     }
-    ctx.edits.push(replaced(sql, `raw.text(${sql.getText()})`));
-    ctx.imports.set('raw', 'the raw.text(...)');
+    ctx.edits.push(replaced(sql, [`${sqlName(ctx.source)}.text(`, original(sql), ')']));
+    ctx.imports.set(SQL_TAG, 'the sql.text(...)');
 }
 /** `const { id } = await q.upsertOne(...)`, which resolves to the id now, as the id: other keys are reported. */
 function rewriteUpsertResult(declaration, ctx) {
@@ -412,7 +390,7 @@ const EXPR_VALUES = new Map([
     ...['currentDate', 'currentTime', 'uuid', 'uuidv7'].map((name) => [name, name]),
 ]);
 /**
- * Rewrites the migration builder's `expr.<helper>()` default as the value or `raw` an entity declares, or reports
+ * Rewrites the migration builder's `expr.<helper>()` default as the value or `sql` an entity declares, or reports
  * one with no rewrite. Called only where the file imports `expr` from uql, so a variable of its own is left alone.
  */
 function rewriteExprCall(call, ctx) {
@@ -428,8 +406,8 @@ function rewriteExprCall(call, ctx) {
         ctx.imports.set(value, `the expr.${helper}()`);
     }
     else if (helper === 'raw' && sql && ts.isStringLiteralLike(sql)) {
-        ctx.edits.push(replaced(call, rawTag(sql.text)));
-        ctx.imports.set('raw', 'the raw`...`');
+        ctx.edits.push(replaced(call, sqlTag(sqlName(ctx.source), sql.text)));
+        ctx.imports.set(SQL_TAG, 'the sql`...`');
     }
     else {
         ctx.report(call, `expr.${helper}() is gone: declare the column with m.raw(...), or use a stamp on the entity`);
@@ -443,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);
     }
 }
@@ -458,7 +437,7 @@ function rewriteUpsertCall(call, ctx) {
     const options = call.arguments[3];
     const update = options && upsertUpdate(options);
     if (name && UPSERT_CALLS.has(name) && update) {
-        ctx.edits.push(replaced(options, update.getText()));
+        ctx.edits.push(replaced(options, [original(update)]));
     }
 }
 /** The value of options holding `update` alone, `{ update: value }` or `{ update }`. */
@@ -494,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) {
@@ -538,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, declared.typeArguments[0].getText()));
-        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. */
@@ -592,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));
@@ -616,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;
     }
@@ -638,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');
@@ -676,37 +661,56 @@ function reportRemovedDecorators(node, ctx) {
     }
 }
 /**
- * Rewrites `raw('sql')` into the tagged template, and a second alias argument into `.as()`, the callback
- * form's included. A computed string is left alone: a template cannot be built from a value not known here.
+ * Rewrites the deprecated `raw('...')` into the `sql` tagged template, and a second alias argument into `.as()`, the
+ * callback form's included. A computed string is left alone: a template cannot be built from a value not known here.
  */
 function rewriteRawCall(node, ctx) {
-    if (!ts.isCallExpression(node) || identifierText(node.expression) !== 'raw') {
+    if (!ts.isCallExpression(node) || uqlExport(node.expression, ctx.checker) !== LEGACY_SQL_TAG) {
         return;
     }
     const [expression, alias] = node.arguments;
     if (!expression || node.arguments.length > 2) {
         return;
     }
-    const suffix = alias ? `.as(${alias.getText()})` : '';
+    const suffix = alias ? ['.as(', original(alias), ')'] : [];
     if (ts.isStringLiteral(expression)) {
-        ctx.edits.push(replaced(node, `${rawTag(expression.text)}${suffix}`));
+        ctx.edits.push(replaced(node, [original(node.expression), templateOf(expression.text), ...suffix]));
     }
     else if (alias) {
-        ctx.edits.push({ start: expression.getEnd(), end: node.getEnd(), text: `)${suffix}` });
+        ctx.edits.push({ start: expression.getEnd(), end: node.getEnd(), text: [')', ...suffix] });
     }
 }
 /**
- * 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 rewritesRaw = uqlImport(source, 'raw') !== undefined;
     const importsUql = uqlImportDeclarations(source, true).length > 0;
     const importsExpr = uqlImport(source, 'expr', true) !== undefined;
+    const importsRaw = uqlImport(source, LEGACY_SQL_TAG, true) !== undefined;
     const visit = (node) => {
         reportRemovedDecorators(node, ctx);
-        if (rewritesRaw) {
+        if (importsRaw) {
             rewriteRawCall(node, ctx);
         }
         if (ts.isPropertyDeclaration(node)) {
@@ -715,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);
@@ -736,16 +741,20 @@ export function transformFile(source, checker, options = { strictNullChecks: tru
         ts.forEachChild(node, visit);
     };
     visit(source);
+    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()), ...unedited(source.getFullText()) };
+    }
     const dead = new Set([...deadImportNames(ctx), ...rewriteColumnRefs(ctx)]);
-    const rewritten = renameExports(dead, ctx);
+    rewriteImports(dead, ctx);
     reportRemovedExports(ctx);
-    dropDeadImports(dead, rewritten, ctx);
-    addImports(rewritten, ctx);
-    return {
-        fileName: source.fileName,
-        text: applyEdits(source.getFullText(), ctx.edits),
-        changed: ctx.edits.length > 0,
-        unresolved: ctx.unresolved,
-        notes: ctx.notes,
-    };
+    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[];

package/dist/tsconfig.js

@@ -1,40 +1,36 @@
 import ts from 'typescript';
-import { applyEdits, removeFromList } from './edits.js';
 import { propertyAssignment, propertyValue } from './syntax.js';
 /** The flags the standard spec has no use for. Their presence is what keeps a project on the old one. */
 const LEGACY_FLAGS = ['experimentalDecorators', 'emitDecoratorMetadata'];
 /**
- * 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 function transformTsconfig(fileName, text) {
+export function checkTsconfig(fileName, text) {
     const source = ts.parseJsonText(fileName, text);
     const root = source.statements[0]?.expression;
     if (!root || !ts.isObjectLiteralExpression(root)) {
-        return { text, changed: false, unresolved: [`${fileName}: not an object, so nothing was changed`] };
+        return [`${fileName}: not an object, so nothing was checked`];
     }
-    const edits = [];
     const unresolved = [];
     const compilerOptions = propertyValue(root, 'compilerOptions');
-    if (compilerOptions && ts.isObjectLiteralExpression(compilerOptions)) {
-        for (const flag of LEGACY_FLAGS) {
-            const property = propertyAssignment(compilerOptions, flag);
-            if (property) {
-                edits.push(removeFromList(compilerOptions.properties, property, source));
-            }
-        }
-        // `target` is reported, not rewritten: removing it silently falls back to the compiler default
-        // (`es5` for `tsc`), and choosing a replacement means guessing which era the project targets.
-        const target = propertyValue(compilerOptions, 'target');
-        if (target && ts.isStringLiteral(target) && target.text.toLowerCase() === 'esnext') {
-            unresolved.push(`${fileName}: 'target' is 'esnext', the one target that emits decorator syntax untransformed. ` +
-                'Change it to any dated target, such as `es2024`.');
-        }
+    const options = compilerOptions && ts.isObjectLiteralExpression(compilerOptions) ? compilerOptions : undefined;
+    const legacy = LEGACY_FLAGS.filter((flag) => options && propertyAssignment(options, flag));
+    if (legacy.length) {
+        unresolved.push(`${fileName}: remove ${legacy.map((flag) => `'${flag}'`).join(' and ')} by hand, ` +
+            'since the standard spec is the only one uql-orm supports');
+    }
+    // `target` is only reported: removing it silently falls back to the compiler default (`es5` for `tsc`), and
+    // choosing a replacement means guessing which era the project targets.
+    const target = options && propertyValue(options, 'target');
+    if (target && ts.isStringLiteral(target) && target.text.toLowerCase() === 'esnext') {
+        unresolved.push(`${fileName}: 'target' is 'esnext', the one target that emits decorator syntax untransformed. ` +
+            'Change it to any dated target, such as `es2024`.');
     }
     // A value the file inherits cannot be edited here, and silence would read as "there was none".
-    if (propertyValue(root, 'extends') && !edits.length) {
+    if (propertyValue(root, 'extends') && !legacy.length) {
         unresolved.push(`${fileName}: extends another config, so check the base for 'experimentalDecorators', ` +
             "'emitDecoratorMetadata' and 'target'.");
     }
-    return { text: applyEdits(text, edits), changed: edits.length > 0, unresolved };
+    return unresolved;
 }