uql-codemod 0.34.0 → 0.35.0

package/README.md

@@ -14,11 +14,11 @@ npx uql-codemod --dry-run
 npx uql-codemod
 ```
 
-| Flag               |                                                                                                                                                                                                                                                       |
-| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `--project=<path>` | `tsconfig.json` to read, defaulting to `./tsconfig.json`. It is a real program and not a parser, because the codemod writes down the types `design:type` used to report at runtime, so a config that covers your entities is what makes the run work. |
-| `--dry-run`        | Report what would change and touch nothing.                                                                                                                                                                                                           |
-| `--include=<a,b>`  | Only files whose path contains one of these fragments.                                                                                                                                                                                                |
+| Flag               |                                                                                                                                               |
+| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--project=<path>` | The `tsconfig.json` to read, `./tsconfig.json` by default. It has to cover your entities: the type checker is what says each property's type. |
+| `--dry-run`        | Report what would change and touch nothing.                                                                                                   |
+| `--include=<a,b>`  | Only files whose path contains one of these fragments.                                                                                        |
 
 Only the `--flag=value` form is read, and anything unrecognised is an error: a misspelled `--dry-run` would otherwise rewrite the project for real. It exits `0` when nothing is left for you, `1` when something is, and `2` when it could not start at all - a bad argument, or a project it cannot read.
 
@@ -28,6 +28,10 @@ Only the `--flag=value` form is read, and anything unrecognised is an error: a m
 - Bare relation decorators: inserts `entity: () => X`, unwrapping arrays and the old `Relation<T>` alias.
 - `Relation<T>` becomes `T`, and its import goes with the last usage - `uql-orm` no longer exports it. A usage somewhere the codemod does not reach, such as a type alias, keeps the import and is reported.
 - `@Field({ virtual })` becomes `@Field({ computed })`, the name it was renamed to - written as a plain key, a quoted one, or a shorthand, which becomes `computed: virtual` so it keeps referring to the same local. A decorator given both names is reported instead, because which one wins is your call.
+- `mappedBy: 'author'` becomes the callback `(post) => post.author`, the one form left, named after the relation's target.
+- `@Index(['title', { column: 'createdAt', order: 'desc' }], { include: ['slug'] })` becomes `@Index((post) => [post.title, { column: post.createdAt, order: 'desc' }], { include: (post) => [post.slug] })`, and `references` pairs and the `@Entity`/`defineEntity`/`defineIndex`/`defineRelation` string forms likewise. A value that is not a literal is reported.
+- An aggregate's `$agg: { total: { $sum: 'amount' } }` becomes `$select: { total: { $sum: { amount: true } } }`, and `$text`'s `$fields: ['title']` becomes `$fields: { title: true }`.
+- `QueryWhereMap` and `RelationKeyMap`, renamed to `QueryWhere` and `KeyMap`, are renamed at their import and every use.
 - A primary key not called `id`, `_id` or `uuid`, and every composite key, gets the `[idKey]?: '...'` brand naming it, plus the import. `@Id` refuses a key it cannot name, since one that resolves to any column types `findOneById` against the wrong one.
 - `import 'reflect-metadata'` goes. Removing the package from your `package.json` is left to you.
 - `tsconfig.json`: removes `experimentalDecorators` and `emitDecoratorMetadata`, keeping the rest of the file - comments and formatting included - exactly as written.
@@ -39,11 +43,11 @@ It reports rather than guesses, and exits non-zero when anything is left for you
 - **`target: esnext`** is reported, not changed. Removing the line falls back to the compiler default (`es5` for `tsc`), and choosing a replacement means guessing which era the project targets. Any dated target works; `esnext` is the one where TypeScript emits decorator syntax untransformed.
 - **A value inherited through `extends`** cannot be edited here, so the base config is reported instead.
 - **`@Log()`, `@Serialized()`, `@Transactional()` and `@InjectQuerier()`** are reported and left in place. They no longer exist, and what to do instead is a judgement call - a `@Transactional()` method becomes a `pool.transaction(async (querier) => { ... })` around its body, and the codemod cannot know which pool.
-- **An export that no longer exists** (`setQuerierPool`, `getQuerier`, `QueryWhereMap`, `augmentWhere`, ...) is reported with what replaces it. A `$where` given an id, a list of them or a bare `raw()` needs no report: it is a compile error on that value, fixed by naming the key (`{ id: [1, 2] }`) or wrapping the raw in `$and`.
+- **An export that no longer exists** (`setQuerierPool`, `getQuerier`, `augmentWhere`, `RelationMappedBy`, ...) is reported with what replaces it. A `$where` given an id, a list of them or a bare `raw()` needs no report: it is a compile error on that value, fixed by naming the key (`{ id: [1, 2] }`) or wrapping the raw in `$and`.
 - **A key written under a computed name** (`@Id() [KEY]?: string`) is reported: the brand has to spell the name out, and only you know what that expression evaluates to.
 - **Options it cannot read** (`@Field(sharedOptions)`, a spread, or a `@Field` never called at all) are left exactly as written. Replacing an argument it cannot parse would silently drop the options.
 - **A property whose type it cannot map to a column** (a `Json<T>`, a vector, a union that disagrees with itself) is reported as `needs a decision`. Those always had to declare `type` by hand anyway, because `design:type` reported the useless `Object`/`Array` for them.
-- **A branded string id**, e.g. `type UUID = \`${string}-${string}\``, gets `type: String`plus a`worth a look`note. That is a real fork:`String`generates a text column,`'uuid'` generates a native one, and only you know which the database has.
+- **A branded string id**, e.g. ``type UUID = `${string}-${string}` ``, gets `type: String` plus a `worth a look` note. That is a real fork: `String` generates a text column, `'uuid'` a native one, and only you know which the database has.
 
 ## After it runs
 
@@ -51,11 +55,7 @@ It reports rather than guesses, and exits non-zero when anything is left for you
 
 ## Why TypeScript 6
 
-TypeScript is a real dependency here, not a dev one: reading the types `design:type` used to report needs a checker, and that means shipping a compiler. Version 6 is pinned deliberately.
-
-TypeScript 7 is not a version bump away. Its `typescript` entry point exports only the version number, and the compiler API moved to `typescript/unstable/*` in a different shape. The gap that matters is the parser: 7 has no standalone one, and `ts.parseJsonText` is what lets the `tsconfig.json` rewrite keep your comments and formatting instead of reserialising the file.
-
-Staying on 6 costs nothing. This is a one-shot tool for a spec `uql-orm` no longer supports, so it never needs a new language feature, and 7 reads `experimentalDecorators` projects perfectly well when the time comes. Worth revisiting once that API drops the `unstable/` prefix and regains a parser.
+TypeScript is a runtime dependency here: reading each property's type needs the checker. Version 6 is pinned because 7's `typescript` entry point exports no compiler API yet (it moved to `typescript/unstable/*`), and 7 has no standalone parser, which the `tsconfig.json` rewrite needs to keep your comments and formatting. A one-shot tool for a spec `uql-orm` no longer supports needs nothing newer; revisit once that API is stable.
 
 ## License
 

package/dist/keyMaps.d.ts

@@ -0,0 +1,25 @@
+import ts from 'typescript';
+import type { Edit } from './edits.js';
+/** A callback's parameter, named after the class it reads: `Post` -> `post`. */
+export declare function paramFor(className: string | undefined): string;
+/** A key's name where it is spelled out, which is every form but a computed one (`{ [k]: v }`). */
+export declare function propertyKey(name: ts.PropertyName): string | undefined;
+/** The initializer of the property `name` in an object literal, however its key is written. */
+export declare function propertyValue(node: ts.ObjectLiteralExpression, name: string): ts.Expression | undefined;
+/** `'amount'` or `['title', 'body']` -> `{ amount: true }`, the key map a statement names fields by. */
+export declare function fieldKeysEdit(value: ts.Expression): Edit | undefined;
+/** Whether `value` is already a function, the form every rewrite here produces. */
+export declare function isCallback(value: ts.Expression): boolean;
+/** `['title', { column: 'createdAt' }]` -> `(post) => [post.title, { column: post.createdAt }]`. */
+export declare function keyListEdit(list: ts.Expression, param: string): Edit | undefined;
+/** `'author'` -> `(post) => post.author`, `param` being the relation's target. */
+export declare function mappedByEdit(value: ts.Expression, param: string): Edit | undefined;
+/**
+ * `[{ local: 'customerCode', foreign: 'code' }]` -> `(order, customer) => [{ local: order.customerCode,
+ * foreign: customer.code }]`. A self-relation would give both parameters one name, so it reads
+ * `(local, foreign)` instead.
+ */
+export declare function referencesEdit(value: ts.Expression, owner: string, target: string): Edit | undefined;
+/** The class an `entity: () => Post` getter returns, as written. */
+export declare function entityGetterTarget(relation: ts.ObjectLiteralExpression): string | undefined;
+export declare function replaced(node: ts.Node, text: string): Edit;

package/dist/keyMaps.js

@@ -0,0 +1,112 @@
+import ts from 'typescript';
+/** A callback's parameter, named after the class it reads: `Post` -> `post`. */
+export function paramFor(className) {
+    return className ? className[0].toLowerCase() + className.slice(1) : 'entity';
+}
+function isIdentifierName(key) {
+    return /^[\p{ID_Start}$_][\p{ID_Continue}$\u200C\u200D]*$/u.test(key);
+}
+/** `post.title`, or `post['first-name']` for a key that is no identifier. */
+function memberAccess(param, key) {
+    return isIdentifierName(key) ? `${param}.${key}` : `${param}['${key}']`;
+}
+/** A key's name where it is spelled out, which is every form but a computed one (`{ [k]: v }`). */
+export function propertyKey(name) {
+    return ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : undefined;
+}
+/** The initializer of the property `name` in an object literal, however its key is written. */
+export function propertyValue(node, name) {
+    const property = node.properties.find((prop) => ts.isPropertyAssignment(prop) && propertyKey(prop.name) === name);
+    return property?.initializer;
+}
+/** `'amount'` or `['title', 'body']` -> `{ amount: true }`, the key map a statement names fields by. */
+export function fieldKeysEdit(value) {
+    const names = ts.isArrayLiteralExpression(value) ? value.elements : [value];
+    if (!names.every((name) => ts.isStringLiteralLike(name))) {
+        return undefined;
+    }
+    const keys = names.map(({ text }) => `${isIdentifierName(text) ? text : `'${text}'`}: true`);
+    return replaced(value, `{ ${keys.join(', ')} }`);
+}
+/** Whether `value` is already a function, the form every rewrite here produces. */
+export function isCallback(value) {
+    return ts.isArrowFunction(value) || ts.isFunctionExpression(value);
+}
+/** `['title', { column: 'createdAt' }]` -> `(post) => [post.title, { column: post.createdAt }]`. */
+export function keyListEdit(list, param) {
+    const text = ts.isArrayLiteralExpression(list)
+        ? spliced(list, list.elements.map((entry) => [entry, keyListEntry(entry, param)]))
+        : undefined;
+    return callbackEdit(list, param, text);
+}
+/** `'author'` -> `(post) => post.author`, `param` being the relation's target. */
+export function mappedByEdit(value, param) {
+    return callbackEdit(value, param, ts.isStringLiteralLike(value) ? memberAccess(param, value.text) : undefined);
+}
+/**
+ * `[{ local: 'customerCode', foreign: 'code' }]` -> `(order, customer) => [{ local: order.customerCode,
+ * foreign: customer.code }]`. A self-relation would give both parameters one name, so it reads
+ * `(local, foreign)` instead.
+ */
+export function referencesEdit(value, owner, target) {
+    const [local, foreign] = owner === target ? ['local', 'foreign'] : [owner, target];
+    const text = ts.isArrayLiteralExpression(value)
+        ? spliced(value, value.elements.map((pair) => [pair, referenceText(pair, local, foreign)]))
+        : undefined;
+    return callbackEdit(value, `${local}, ${foreign}`, text);
+}
+/** The class an `entity: () => Post` getter returns, as written. */
+export function entityGetterTarget(relation) {
+    const getter = propertyValue(relation, 'entity');
+    return getter && ts.isArrowFunction(getter) && ts.isIdentifier(getter.body) ? getter.body.text : undefined;
+}
+/** An expression entry (`raw\`...\``) and a `column` that is not a string stay as written. */
+function keyListEntry(entry, param) {
+    if (ts.isStringLiteralLike(entry)) {
+        return memberAccess(param, entry.text);
+    }
+    if (ts.isTaggedTemplateExpression(entry) || ts.isCallExpression(entry)) {
+        return entry.getText();
+    }
+    if (!ts.isObjectLiteralExpression(entry)) {
+        return undefined;
+    }
+    const column = propertyValue(entry, 'column');
+    return column && ts.isStringLiteralLike(column)
+        ? spliced(entry, [[column, memberAccess(param, column.text)]])
+        : entry.getText();
+}
+function referenceText(pair, local, foreign) {
+    if (!ts.isObjectLiteralExpression(pair)) {
+        return undefined;
+    }
+    const localKey = propertyValue(pair, 'local');
+    const foreignKey = propertyValue(pair, 'foreign');
+    return localKey && foreignKey && ts.isStringLiteralLike(localKey) && ts.isStringLiteralLike(foreignKey)
+        ? spliced(pair, [
+            [localKey, memberAccess(local, localKey.text)],
+            [foreignKey, memberAccess(foreign, foreignKey.text)],
+        ])
+        : undefined;
+}
+/** `node`'s text with each part swapped for its own, everything between kept as written. */
+function spliced(node, parts) {
+    if (!parts.every((part) => part[1] !== undefined)) {
+        return undefined;
+    }
+    const start = node.getStart();
+    const source = node.getText();
+    const sorted = [...parts].sort(([a], [b]) => a.getStart() - b.getStart());
+    const { text, at } = sorted.reduce((acc, [part, replacement]) => ({
+        text: acc.text + source.slice(acc.at, part.getStart() - start) + replacement,
+        at: part.getEnd() - start,
+    }), { text: '', at: 0 });
+    return text + source.slice(at);
+}
+/** `value` replaced by `(params) => body`, or nothing when the body could not be read. */
+function callbackEdit(value, params, body) {
+    return body === undefined ? undefined : replaced(value, `(${params}) => ${body}`);
+}
+export function replaced(node, text) {
+    return { start: node.getStart(), end: node.getEnd(), text };
+}

package/dist/transform.js

@@ -1,6 +1,7 @@
 import ts from 'typescript';
 import { applyEdits, removeFromList } from './edits.js';
 import { fieldTypeFor, isBrandedString, relationTargetFor } from './fieldType.js';
+import { entityGetterTarget, fieldKeysEdit, isCallback, keyListEdit, mappedByEdit, paramFor, propertyKey, propertyValue, referencesEdit, replaced, } from './keyMaps.js';
 const FIELD_DECORATORS = new Set(['Field', 'Id']);
 const RELATION_DECORATORS = new Set(['OneToOne', 'ManyToOne', 'OneToMany', 'ManyToMany']);
 /**
@@ -22,8 +23,10 @@ const REMOVED_EXPORTS = new Map([
     ['setQuerierPool', 'pass the pool where it is used: `createFetchHandler({ pool })`, `querierMiddleware({ pool })`'],
     ['getQuerierPool', 'take the pool from the module that builds it, or from Nest DI'],
     ['getQuerier', 'use `pool.withQuerier(...)` / `pool.transaction(...)`, which release the connection'],
-    ['QueryWhereMap', 'it is `QueryWhere` now'],
     ['QueryWhereFieldMap', 'use `QueryWhere`'],
+    ['QueryStreamProjected', 'use `QueryProjected`'],
+    ['RelationMappedBy', "a 'mappedBy' is `(keys: KeyMap<E>) => Key<E>` now"],
+    ['RelationKeyMapper', 'it is `(keys: KeyMap<E>) => Key<E>` now'],
     ['augmentWhere', 'spread the two maps: `{ ...where, ...extra }`'],
     ['buildQueryWhereAsMap', 'a `$where` is a map already; name the key for ids: `{ id: [1, 2] }`'],
     ['PgDialect', 'the pools build `PostgresDialect` (`uql-orm/postgres`); name that where a dialect is typed'],
@@ -37,6 +40,11 @@ const REMOVED_EXPORTS = new Map([
     ['LibsqlQuerier', 'the libSQL and Turso pools return `HranaQuerier` (`uql-orm/sqlite`)'],
     ['TursoQuerier', 'the libSQL and Turso pools return `HranaQuerier` (`uql-orm/sqlite`)'],
 ]);
+/** Exports renamed and nothing else, so the import and every use of it in the file follow. */
+const RENAMED_EXPORTS = new Map([
+    ['QueryWhereMap', 'QueryWhere'],
+    ['RelationKeyMap', 'KeyMap'],
+]);
 /** A node's decorators, or none where it is a kind that cannot carry them. */
 function decoratorsOf(node) {
     return ts.canHaveDecorators(node) ? (ts.getDecorators(node) ?? []) : [];
@@ -76,10 +84,6 @@ function findProperty(options, name) {
     }
     return options.node.properties.find((prop) => (ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop)) && propertyKey(prop.name) === name);
 }
-/** A key's name where it is spelled out, which is every form but a computed one (`{ [k]: v }`). */
-function propertyKey(name) {
-    return ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : undefined;
-}
 /**
  * Renames the `virtual` option to `computed`, the one it was renamed to.
  *
@@ -169,6 +173,137 @@ function addRelationEntity(decorator, node, ctx) {
         },
     });
 }
+/**
+ * Writes the edit `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
+ * is already the new form, and kept.
+ */
+function rewriteValue(value, rewrite, node, advice, ctx) {
+    if (!value || isCallback(value) || ts.isObjectLiteralExpression(value)) {
+        return;
+    }
+    const edit = rewrite(value);
+    if (edit) {
+        ctx.edits.push(edit);
+    }
+    else {
+        ctx.unresolved.push(`${ctx.describe(node)}: ${advice}; this one could not be read`);
+    }
+}
+function rewriteKeyList(value, param, node, what, ctx) {
+    rewriteValue(value, (list) => keyListEdit(list, param), node, `write ${what} as a key-map callback`, ctx);
+}
+/**
+ * Rewrites what a class decorator names by string - `@Index` columns and `include`, and `@Entity`'s
+ * `indexes`, `hooks` and `relations` - into key-map callbacks named after the class.
+ */
+function rewriteClassDecorators(node, ctx) {
+    const param = paramFor(node.name?.text);
+    for (const decorator of decoratorsOf(node)) {
+        if (!ts.isCallExpression(decorator.expression)) {
+            continue;
+        }
+        const [first, second] = decorator.expression.arguments;
+        const name = decoratorName(decorator);
+        if (name === 'Index') {
+            rewriteKeyList(first, param, decorator, "'@Index' columns", ctx);
+            if (second && ts.isObjectLiteralExpression(second)) {
+                rewriteKeyList(propertyValue(second, 'include'), param, decorator, "'include'", ctx);
+            }
+        }
+        else if (name === 'Entity' && first && ts.isObjectLiteralExpression(first)) {
+            rewriteEntityOptions(first, param, ctx);
+        }
+    }
+}
+/**
+ * Rewrites what the imperative API names by string - `defineEntity(Post, { indexes, hooks, relations })`,
+ * `defineIndex(Post, { columns, include })` and `defineRelation(Post, 'tag', { mappedBy, references })` -
+ * into key-map callbacks. Only uql's shapes, a class and a literal options object, are read.
+ */
+function rewriteDefineCall(call, ctx) {
+    const name = ts.isIdentifier(call.expression) ? call.expression.text : undefined;
+    const [entity, second, third] = call.arguments;
+    const param = paramFor(entity && ts.isIdentifier(entity) ? entity.text : undefined);
+    if (name === 'defineEntity' && second && ts.isObjectLiteralExpression(second)) {
+        rewriteEntityOptions(second, param, ctx);
+    }
+    else if (name === 'defineIndex' && second && ts.isObjectLiteralExpression(second)) {
+        rewriteIndexOptions(second, param, ctx);
+    }
+    else if (name === 'defineRelation' && third && ts.isObjectLiteralExpression(third)) {
+        rewriteRelationOptions(third, param, ctx);
+    }
+}
+function rewriteEntityOptions(options, param, ctx) {
+    const indexes = propertyValue(options, 'indexes');
+    for (const index of indexes && ts.isArrayLiteralExpression(indexes) ? indexes.elements : []) {
+        if (ts.isObjectLiteralExpression(index)) {
+            rewriteIndexOptions(index, param, ctx);
+        }
+    }
+    for (const hook of objectProperties(propertyValue(options, 'hooks'))) {
+        rewriteKeyList(hook.initializer, param, hook, 'a hook list', ctx);
+    }
+    for (const relation of objectProperties(propertyValue(options, 'relations'))) {
+        if (ts.isObjectLiteralExpression(relation.initializer)) {
+            rewriteRelationOptions(relation.initializer, param, ctx);
+        }
+    }
+}
+function rewriteIndexOptions(index, param, ctx) {
+    rewriteKeyList(propertyValue(index, 'columns'), param, index, "'columns'", ctx);
+    rewriteKeyList(propertyValue(index, 'include'), param, index, "'include'", ctx);
+}
+/**
+ * `owner` is the declaring class's parameter and `target` the related one's, read off the `entity`
+ * getter unless the caller knows it from the property's type.
+ */
+function rewriteRelationOptions(relation, owner, ctx, target = paramFor(entityGetterTarget(relation))) {
+    const advice = (what) => `write '${what}' as a key-map callback`;
+    const mappedBy = (value) => mappedByEdit(value, target);
+    const references = (value) => referencesEdit(value, owner, target);
+    rewriteValue(propertyValue(relation, 'mappedBy'), mappedBy, relation, advice('mappedBy'), ctx);
+    rewriteValue(propertyValue(relation, 'references'), references, relation, advice('references'), ctx);
+}
+/**
+ * Rewrites what a statement names by string into keys: an aggregate's `$agg: { total: { $sum: 'amount' } }`
+ * into `$select: { total: { $sum: { amount: true } } }`, and `$text`'s `$fields: ['title']` into
+ * `{ title: true }`. Both keys are uql's own, so they are read wherever a literal holds them.
+ */
+function rewriteStatementKeys(node, ctx) {
+    const key = propertyKey(node.name);
+    if (key === '$agg') {
+        rewriteAggregate(node, ctx);
+    }
+    else if (key === '$fields' && isTextSearch(node.parent)) {
+        rewriteValue(node.initializer, fieldKeysEdit, node, "write '$fields' as { field: true }", ctx);
+    }
+}
+function isTextSearch(node) {
+    return (ts.isObjectLiteralExpression(node) &&
+        ts.isPropertyAssignment(node.parent) &&
+        propertyKey(node.parent.name) === '$text');
+}
+function rewriteAggregate(agg, ctx) {
+    if (ts.isObjectLiteralExpression(agg.parent) && propertyValue(agg.parent, '$select')) {
+        ctx.unresolved.push(`${ctx.describe(agg)}: merge '$agg' into the '$select' beside it`);
+        return;
+    }
+    ctx.edits.push(replaced(agg.name, '$select'));
+    for (const fn of objectProperties(agg.initializer)) {
+        for (const op of objectProperties(fn.initializer)) {
+            const isStar = ts.isStringLiteralLike(op.initializer) && op.initializer.text === '*';
+            if (!isStar) {
+                rewriteValue(op.initializer, fieldKeysEdit, op, `write '${op.name.getText()}' as { field: true }`, ctx);
+            }
+        }
+    }
+}
+/** The property assignments of an object literal, or none where `node` is not one. */
+function objectProperties(node) {
+    return node && ts.isObjectLiteralExpression(node) ? node.properties.filter(ts.isPropertyAssignment) : [];
+}
 /**
  * Drops `declare` from a decorated field. A `declare` field emits nothing, so the standard spec has
  * nothing to decorate and rejects it ("Decorators are not valid here"). Legacy decorators tolerated it
@@ -322,9 +457,15 @@ function rewriteProperty(node, ctx) {
             addFieldType(decorator, node, ctx);
             renameVirtualOption(decorator, node, ctx);
         }
+        const options = decoratorOptions(decorator);
         if (RELATION_DECORATORS.has(name)) {
             addRelationEntity(decorator, node, ctx);
         }
+        if (RELATION_DECORATORS.has(name) && options.kind === 'literal') {
+            const owner = ts.isClassLike(node.parent) ? node.parent.name?.text : undefined;
+            const target = relationTargetFor(ctx.checker.getTypeAtLocation(node), ctx.checker);
+            rewriteRelationOptions(options.node, paramFor(owner), ctx, paramFor(target));
+        }
     }
     if (decorators.length) {
         dropDeclare(node, ctx);
@@ -351,6 +492,41 @@ function reportRemovedExports(source, ctx) {
         }
     }
 }
+/**
+ * Renames each import of a {@link RENAMED_EXPORTS} name and every use of it in the file. An aliased
+ * import only changes the name it imports; one whose new name the file already imports is dropped.
+ */
+function renameExports(source, ctx) {
+    const imported = uqlImports(source);
+    for (const element of imported) {
+        const renamed = RENAMED_EXPORTS.get(importedName(element));
+        if (!renamed) {
+            continue;
+        }
+        if (element.propertyName) {
+            ctx.edits.push(replaced(element.propertyName, renamed));
+            continue;
+        }
+        ctx.edits.push(...usesOf(source, element.name, ctx.checker).map((use) => replaced(use, renamed)));
+        const duplicate = imported.some((other) => other.name.text === renamed);
+        ctx.edits.push(duplicate ? removeFromList(element.parent.elements, element, source) : replaced(element.name, renamed));
+    }
+}
+/** Every identifier in the file bound to the same symbol as `name`, besides `name` itself. */
+function usesOf(source, name, checker) {
+    const symbol = checker.getSymbolAtLocation(name);
+    const uses = [];
+    const visit = (node) => {
+        if (ts.isIdentifier(node) && node !== name && node.text === name.text) {
+            if (symbol && checker.getSymbolAtLocation(node) === symbol) {
+                uses.push(node);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return uses;
+}
 /**
  * What the file imports from `uql-orm` by name, which is every import this codemod reads or writes.
  * `entries` adds the driver entries (`uql-orm/postgres`, ...), for reporting only: an import written
@@ -421,10 +597,18 @@ export function transformFile(source, checker) {
         }
         if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
             branded = brandIdKey(node, ctx) || branded;
+            rewriteClassDecorators(node, ctx);
+        }
+        if (ts.isCallExpression(node)) {
+            rewriteDefineCall(node, ctx);
+        }
+        if (ts.isPropertyAssignment(node)) {
+            rewriteStatementKeys(node, ctx);
         }
         ts.forEachChild(node, visit);
     };
     visit(source);
+    renameExports(source, ctx);
     reportRemovedExports(source, ctx);
     dropDeadImports(source, ctx);
     if (branded) {

package/package.json

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