uql-codemod 0.48.2 → 0.50.0

package/dist/transform.js

@@ -1,14 +1,20 @@
 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 { nameClash } from './schemaMessages.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 +37,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 +73,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 +136,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 +144,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 +203,7 @@ function rewriteClassDecorators(node, ctx) {
         }
         else if (name === 'Entity' && options) {
             rewriteEntityOptions(options, owner, ctx);
+            reportEntityMembers(options, ctx);
         }
     }
 }
@@ -253,23 +213,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 +246,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 +260,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 +285,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 +422,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 +474,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 +541,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 +580,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 +609,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 +636,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 +682,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 taken = foreignNames(source, BUILDER_NAMES, checker);
+    const legacy = rewriteLegacy(source, checker, options, taken);
+    const located = (pass) => (at) => locationAt(source, pass.sourceOffset(at));
+    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, taken = foreignNames(source, BUILDER_NAMES, checker)) {
     const ctx = createContext(source, checker, options.strictNullChecks);
     const importsUql = uqlImportDeclarations(source, true).length > 0;
     const importsExpr = uqlImport(source, 'expr', true) !== undefined;
@@ -717,6 +720,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);
@@ -740,13 +744,20 @@ export function transformFile(source, checker, options = { strictNullChecks: tru
     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());
+        ctx.report(clash, `${nameClash(clash.text)}: rename that, then run again`);
+        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, {
+        locate: (at) => locationAt(source, edited.sourceOffset(at)),
+        taken,
+    });
+    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,39 +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)) {
-        const legacy = LEGACY_FLAGS.flatMap((flag) => {
-            const property = propertyAssignment(compilerOptions, flag);
-            return property ? [property] : [];
-        });
-        edits.push(...removeFromList(compilerOptions.properties, legacy, 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;
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "uql-codemod",
   "description": "Upgrade uql-orm across versions that introduce breaking changes",
   "license": "MIT",
-  "version": "0.48.2",
+  "version": "0.50.0",
   "type": "module",
   "engines": {
     "node": ">=22.18"

package/dist/fieldType.d.ts

@@ -1,13 +0,0 @@
-import ts from 'typescript';
-export declare function isBrandedString(type: ts.Type): boolean;
-/**
- * The `type` option reflection supplied for a property of `type`, mirroring `TypeFor` in `uql-orm`, or nothing
- * for a shape a human decides. Only what reflection could produce is read: a `Json<T>` or vector property got
- * `Object`/`Array` from it, so it already declared its `type`.
- */
-export declare function fieldTypeFor(type: ts.Type): string | undefined;
-/**
- * The entity name a relation property points at: `Company` for `Company`, `Company[]`, and
- * `Relation<Company>` alike, since `Relation<T>` is an alias for `T` and erases before this runs.
- */
-export declare function relationTargetFor(type: ts.Type, checker: ts.TypeChecker): string | undefined;

package/dist/fieldType.js

@@ -1,56 +0,0 @@
-import ts from 'typescript';
-/** The string types carrying more than `string`, e.g. `` type UUID = `${string}-${string}` ``, still string columns. */
-const BRANDED_STRING = ts.TypeFlags.TemplateLiteral | ts.TypeFlags.StringMapping;
-export function isBrandedString(type) {
-    return (type.isUnion() ? type.types : [type]).some((t) => !!(t.getFlags() & BRANDED_STRING));
-}
-/**
- * Reads a union by requiring its arms to agree, which is what an `'a' | 'b'` enum or a `T | null` looks
- * like. `undefined` and `null` arms are dropped first: they carry no column type of their own.
- */
-function foldUnion(type, read) {
-    const arms = type.types.filter((arm) => !(arm.getFlags() & (ts.TypeFlags.Undefined | ts.TypeFlags.Null)));
-    const readings = new Set(arms.map(read));
-    return readings.size === 1 ? [...readings][0] : undefined;
-}
-/**
- * The `type` option reflection supplied for a property of `type`, mirroring `TypeFor` in `uql-orm`, or nothing
- * for a shape a human decides. Only what reflection could produce is read: a `Json<T>` or vector property got
- * `Object`/`Array` from it, so it already declared its `type`.
- */
-export function fieldTypeFor(type) {
-    const flags = type.getFlags();
-    if (type.isUnion()) {
-        return foldUnion(type, fieldTypeFor);
-    }
-    if (flags & (ts.TypeFlags.String | ts.TypeFlags.StringLiteral | BRANDED_STRING))
-        return 'String';
-    if (flags & (ts.TypeFlags.Number | ts.TypeFlags.NumberLiteral))
-        return 'Number';
-    if (flags & (ts.TypeFlags.BigInt | ts.TypeFlags.BigIntLiteral))
-        return 'BigInt';
-    if (flags & (ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral))
-        return 'Boolean';
-    // Matched by declared symbol rather than by the printed type: both of these became generic in the
-    // modern lib, so `Uint8Array` prints as `Uint8Array<ArrayBufferLike>` and never compared equal.
-    const name = type.getSymbol()?.getName();
-    if (name === 'Date')
-        return 'Date';
-    if (name === 'Buffer' || name === 'Uint8Array')
-        return "'blob'";
-    return undefined;
-}
-/**
- * The entity name a relation property points at: `Company` for `Company`, `Company[]`, and
- * `Relation<Company>` alike, since `Relation<T>` is an alias for `T` and erases before this runs.
- */
-export function relationTargetFor(type, checker) {
-    if (type.isUnion()) {
-        return foldUnion(type, (arm) => relationTargetFor(arm, checker));
-    }
-    const elementType = checker.getIndexTypeOfType(type, ts.IndexKind.Number);
-    const target = elementType ?? type;
-    const symbol = target.getSymbol();
-    const name = symbol?.getName();
-    return name && name !== '__type' && /^[A-Z][A-Za-z0-9_]*$/.test(name) ? name : undefined;
-}