uql-codemod 0.48.0 → 0.48.2

package/README.md

@@ -26,13 +26,13 @@ Only `--flag=value` is read, and anything unrecognised is an error. It exits `0`
 
 - `type` on a `@Field`/`@Id` that has none, from the property's declared type; not beside `references`, whose column comes from the key it points at.
 - `entity: () => X` on a bare relation decorator, and `Relation<T>` to `T`, its import going with the last use.
-- `virtual` to `computed` (on `@Field` and in `defineEntity`'s `fields`), a check's `expression` and a filter's `condition` to `where` (`@Entity`/`defineEntity`, `@Filter`, `defineFilter`), `raw('sql')` to the tagged template, and a `raw` alias argument onto `.as()`.
+- `virtual` to `computed` (on `@Field` and in `defineEntity`'s `fields`), a check's `expression` and a filter's `condition` to `where` (`@Entity`/`defineEntity`, `@Filter`, `defineFilter`), `raw('...')` to the `sql` tagged template, and a second argument onto `.as()`.
 - Members named by string to callbacks: `mappedBy: 'author'` to `(post) => post.author`, and `@Index`, `include`, `references` and `@Entity`/`defineEntity`'s `indexes` and `hooks` likewise: `@Index((post) => [post.title])`.
 - `references: (post) => post.authorId` on a to-one (`@ManyToOne`, `@OneToOne`, or `defineEntity`/`defineRelation`) that names no foreign key, declaring `@Field({ references: () => User }) authorId` first on a decorated class that has no such column, typed as the key it points at.
-- A partial-index `where` string to `raw`, importing it, on entities and in the migration builder.
-- `col('cost')` to the ref it names, ``(product) => raw`${product.cost}` `` in a `computed` and `refs(Item).cost` in a statement, and `$lock: { wait: 'skip' }` to `{ $wait: 'skip' }`, or to `true` for `{}` and a `'block'` wait.
+- A partial-index `where` string to `sql`, importing it, on entities and in the migration builder.
+- `col('cost')` to the ref it names, ``(product) => sql`${product.cost}` `` in a `computed` and `refs(Item).cost` in a statement, and `$lock: { wait: 'skip' }` to `{ $wait: 'skip' }`, or to `true` for `{}` and a `'block'` wait.
 - An aggregate's `$agg` to `$select`, and each field it or `$text`'s `$fields` names to a key: `{ $sum: { amount: true } }`.
-- Renamed exports, at the import and every use: `QueryWhereMap` to `QueryWhere`, `RelationKeyMap` to `KeyMap`, `FilterCondition` to `FilterWhere`, `SqlMigrationModuleOptions` to `MigrationModuleOptions`, `buildSqlQuerierMigrationModule` to `buildMigrationModule`, `QueryDialect` to `SqlQueryDialect`, `EngineFeatures` to `DialectFeatures`, `KnownMigratorDialect` to `DialectName`, `D1Preparer`/`D1Database` to `D1Queryable`, and the removed driver classes to the one each extended: `PgDialect`/`NeonDialect`/`PgliteDialect` to `PostgresDialect`, `CrdbQuerier`/`NeonQuerier` to `PgQuerier`, `LibsqlQuerier`/`TursoQuerier` to `HranaQuerier`, `TursoLocalQuerier` to `SqliteQuerier` and `TursoDatabase` to `SqliteDatabase`, `MySql2Dialect` to `MySqlDialect`, `MongodbNativeDialect` to `MongoDialect`, `Sqlite3QuerierPool` to `SqliteQuerierPool`, the migration builder's `I`-prefixed types to the unprefixed name, moving the import to the entry that exports it; and `MongoQuerier`, `isMongoQuerier` and `MongoSchemaIntrospector` to `uql-orm/mongodb`.
+- Renamed exports, at the import and every use: `raw` to `sql`, `QueryWhereMap` to `QueryWhere`, `RelationKeyMap` to `KeyMap`, `FilterCondition` to `FilterWhere`, `SqlMigrationModuleOptions` to `MigrationModuleOptions`, `buildSqlQuerierMigrationModule` to `buildMigrationModule`, `QueryDialect` to `SqlQueryDialect`, `EngineFeatures` to `DialectFeatures`, `KnownMigratorDialect` to `DialectName`, `D1Preparer`/`D1Database` to `D1Queryable`, and the removed driver classes to the one each extended: `PgDialect`/`NeonDialect`/`PgliteDialect` to `PostgresDialect`, `CrdbQuerier`/`NeonQuerier` to `PgQuerier`, `LibsqlQuerier`/`TursoQuerier` to `HranaQuerier`, `TursoLocalQuerier` to `SqliteQuerier` and `TursoDatabase` to `SqliteDatabase`, `MySql2Dialect` to `MySqlDialect`, `MongodbNativeDialect` to `MongoDialect`, `Sqlite3QuerierPool` to `SqliteQuerierPool`, the migration builder's `I`-prefixed types to the unprefixed name, moving the import to the entry that exports it; and `MongoQuerier`, `isMongoQuerier` and `MongoSchemaIntrospector` to `uql-orm/mongodb`.
 - Imports off `uql-orm/maria`, `uql-orm/mongo` and `uql-orm/bunSql` to `uql-orm/mariadb`, `uql-orm/mongodb` and `uql-orm/bun-sql`, and off `uql-orm/type`, `uql-orm/dialect`, `uql-orm/entity`, `uql-orm/querier` and `uql-orm/namingStrategy` to `uql-orm`.
 - The `[idKey]?: '...'` brand, and its import, on a key not called `id`, `_id` or `uuid` and on every composite.
 - `import 'reflect-metadata'`, and `experimentalDecorators`/`emitDecoratorMetadata` in `tsconfig.json`, comments and formatting kept.
@@ -43,13 +43,14 @@ Reported with what to do, never guessed:
 
 - `target: esnext`, the one target that leaves decorators untransformed, and a value inherited through `extends`.
 - `@Log()`, `@Serialized()`, `@Transactional()` and `@InjectQuerier()`: a `@Transactional()` method becomes a `pool.transaction()` around its body, and only you know which pool.
-- An export removed with no one-to-one replacement (`setQuerierPool`, `getQuerier`, `augmentWhere`, `AbstractPgQuerier`, ...), an internal the root no longer exports (`AbstractSqlQuerier`, `fieldOf`, ...), the migration storages, and any import from `uql-orm/util` the root does not export (`raw`, `refs`, ... move to `uql-orm`).
+- An export removed with no one-to-one replacement (`setQuerierPool`, `getQuerier`, `augmentWhere`, `AbstractPgQuerier`, ...), an internal the root no longer exports (`AbstractSqlQuerier`, `fieldOf`, ...), the migration storages, and any import from `uql-orm/util` the root does not export (`refs`, ... move to `uql-orm`).
 - A value it cannot read: options passed as a variable or a spread, a list that is not a literal, a key under a computed name.
 - A to-one onto a composite key: declare a column per key and pair each with it in `references`.
 - A to-one whose `<relation>Id` is not a declared column: an undecorated property, a `defineEntity` whose `fields` leave it out, or a `defineRelation` whose entity has no such member.
-- A partial-index `where` string that interpolates, since `raw` would bind what the template spliced in.
+- A partial-index `where` string that interpolates, since `sql` would bind what the template spliced in.
 - A `col()` whose entity it cannot tell: a raw built apart from its query, one under a relation filter, or a column no field maps.
-- SQL in a definition that names a column by hand, as a note: a rename reaches a callback's refs, ``(user) => raw`lower(${user.email})` ``, and never the text.
+- SQL in a definition that names a column by hand, as a note: a rename reaches a callback's refs, ``(user) => sql`lower(${user.email})` ``, and never the text.
+- A file that already names something the codemod would write (`sql`, `refs`, `idKey`, a renamed export): left unchanged and reported, since the new import would shadow it or be shadowed.
 - A property whose type maps to no column (`Json<T>`, a vector, a mixed union).
 - A branded string id, written as `type: String` to keep the column you have, with a note: `'uuid'` is a native column, and a migration.
 

package/dist/columnRefs.js

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import { constructedType, memberNames, ownerOf, propertyNames } from './context.js';
 import { inserted, replaced } from './edits.js';
-import { isRaw } from './entitySql.js';
+import { isSqlCall } from './entitySql.js';
 import { uqlImport, usesOf } from './imports.js';
 import { memberAccess } from './keyMaps.js';
 import { identifierText, propertyKey, propertyValue } from './syntax.js';
@@ -19,7 +19,7 @@ export function rewriteColumnRefs(ctx) {
     const unread = [];
     for (const use of usesOf(ctx.source, element.name, ctx.checker)) {
         const call = ts.isCallExpression(use.parent) && use.parent.expression === use ? use.parent : undefined;
-        const sql = call && ts.findAncestor(call, isRaw);
+        const sql = call && ts.findAncestor(call, (node) => isSqlCall(node, ctx.checker));
         const option = sql?.parent;
         const owner = option && ts.isPropertyAssignment(option) && isComputedOption(option) ? computedOwner(option) : undefined;
         const edit = call && !owner ? statementRefEdit(call, ctx) : undefined;

package/dist/edits.d.ts

@@ -1,24 +1,35 @@
 import type ts from 'typescript';
+/** A stretch of the original text, which a replacement can keep. */
+export type Span = {
+    readonly start: number;
+    readonly end: number;
+};
+/** A piece of a replacement: text written, or a stretch of the original kept. */
+export type Part = string | Span;
+/** What replaces a range: text, or text with stretches of the original in it, edits inside them included. */
+export type Replacement = string | readonly Part[];
 /** One text replacement in a file. */
 export type Edit = {
     readonly start: number;
     readonly end: number;
-    readonly text: string;
+    readonly text: Replacement;
 };
+/** The text of `node` as written, for a replacement to keep. */
+export declare function original(node: ts.Node): Span;
 /**
- * Applies edits back to front, so none shifts the offsets of another, and at a shared offset the replacement
- * first, so an insertion there lands before it. Splicing rather than reprinting keeps the rest of the file
- * byte for byte: a codemod that reformats everything it touches buries its own change in the diff.
+ * Applies edits to `source`, which is spliced rather than reprinted: a codemod that reformats everything it
+ * touches buries its own change in the diff. An edit inside a range another replaces is moot, unless that
+ * replacement keeps the stretch it sits in; edits that overlap without one holding the other are a bug.
  */
-export declare function applyEdits(text: string, edits: readonly Edit[]): string;
-export declare function replaced(node: ts.Node, text: string): Edit;
+export declare function applyEdits(source: string, edits: readonly Edit[]): string;
+export declare function replaced(node: ts.Node, text: Replacement): Edit;
 export declare function inserted(node: ts.Node, text: string): Edit;
 export declare function appended(node: ts.Node, text: string): Edit;
 /**
- * Removes one element of a comma-separated list with the separator that would dangle: the comma before the
- * last element, the one after any other. `source` is passed because a tree from `ts.parseJsonText` carries
- * no back-reference for `getStart()` to find.
+ * Removes elements of a comma-separated list with the separators that would dangle. Each removed element takes
+ * the text up to the next item; the removed run at the end takes the separator before it, so the ranges never
+ * overlap. `source` is passed because a tree from `ts.parseJsonText` carries no back-reference for `getStart()`.
  */
-export declare function removeFromList(items: readonly ts.Node[], item: ts.Node, source: ts.SourceFile): Edit;
+export declare function removeFromList(items: readonly ts.Node[], removed: readonly ts.Node[], source: ts.SourceFile): readonly Edit[];
 /** Removes a statement together with the rest of its line, so nothing is left blank behind it. */
 export declare function removeStatement(node: ts.Node): Edit;

package/dist/edits.js

@@ -1,17 +1,51 @@
+/** The text of `node` as written, for a replacement to keep. */
+export function original(node) {
+    return { start: node.getStart(), end: node.getEnd() };
+}
+const isInsertion = (edit) => edit.start === edit.end;
 /**
- * Applies edits back to front, so none shifts the offsets of another, and at a shared offset the replacement
- * first, so an insertion there lands before it. Splicing rather than reprinting keeps the rest of the file
- * byte for byte: a codemod that reformats everything it touches buries its own change in the diff.
+ * Applies edits to `source`, which is spliced rather than reprinted: a codemod that reformats everything it
+ * touches buries its own change in the diff. An edit inside a range another replaces is moot, unless that
+ * replacement keeps the stretch it sits in; edits that overlap without one holding the other are a bug.
  */
-export function applyEdits(text, edits) {
-    let result = text;
-    for (const edit of [...edits].sort((a, b) => b.start - a.start || b.end - a.end)) {
-        result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+export function applyEdits(source, edits) {
+    const ordered = edits
+        .map((edit, index) => ({ edit, index }))
+        .sort((a, b) => a.edit.start - b.edit.start ||
+        Number(!isInsertion(a.edit)) - Number(!isInsertion(b.edit)) ||
+        (isInsertion(a.edit) ? b.index - a.index : b.edit.end - a.edit.end))
+        .map(({ edit }) => edit);
+    return render(source, ordered, { start: 0, end: source.length });
+}
+/**
+ * `range` of `source` with `edits` (ordered outermost first, an insertion before a replacement at its offset, a
+ * later insertion before an earlier) applied. `parent` is the edit keeping `range`: an insertion at its edges
+ * is written beside it, so it is not written again inside.
+ */
+function render(source, edits, range, parent) {
+    const within = (edit) => edit !== parent &&
+        range.start <= edit.start &&
+        edit.end <= range.end &&
+        !(parent && isInsertion(edit) && (edit.start === parent.start || edit.start === parent.end));
+    const inside = edits.filter(within);
+    let written = '';
+    let at = range.start;
+    for (const edit of inside) {
+        if (edit.start < at) {
+            if (edit.end > at) {
+                throw new Error(`overlapping edits at ${edit.start}`);
+            }
+            continue;
+        }
+        const parts = typeof edit.text === 'string' ? [edit.text] : edit.text;
+        written += source.slice(at, edit.start);
+        written += parts.map((part) => (typeof part === 'string' ? part : render(source, inside, part, edit))).join('');
+        at = edit.end;
     }
-    return result;
+    return written + source.slice(at, range.end);
 }
 export function replaced(node, text) {
-    return { start: node.getStart(), end: node.getEnd(), text };
+    return { ...original(node), text };
 }
 export function inserted(node, text) {
     return { start: node.getStart(), end: node.getStart(), text };
@@ -20,19 +54,22 @@ export function appended(node, text) {
     return { start: node.getEnd(), end: node.getEnd(), text };
 }
 /**
- * Removes one element of a comma-separated list with the separator that would dangle: the comma before the
- * last element, the one after any other. `source` is passed because a tree from `ts.parseJsonText` carries
- * no back-reference for `getStart()` to find.
+ * Removes elements of a comma-separated list with the separators that would dangle. Each removed element takes
+ * the text up to the next item; the removed run at the end takes the separator before it, so the ranges never
+ * overlap. `source` is passed because a tree from `ts.parseJsonText` carries no back-reference for `getStart()`.
  */
-export function removeFromList(items, item, source) {
-    const at = items.indexOf(item);
-    const next = items[at + 1];
-    const previous = items[at - 1];
-    return {
-        start: previous && !next ? previous.getEnd() : item.getStart(source),
-        end: next ? next.getStart(source) : item.getEnd(),
-        text: '',
-    };
+export function removeFromList(items, removed, source) {
+    const kept = items.map((item) => !removed.includes(item));
+    const lastKept = kept.lastIndexOf(true);
+    const between = items
+        .slice(0, lastKept + 1)
+        .flatMap((item, at) => kept[at] ? [] : [{ start: item.getStart(source), end: items[at + 1].getStart(source), text: '' }]);
+    const trailing = items.slice(lastKept + 1);
+    if (!trailing.length) {
+        return between;
+    }
+    const from = lastKept < 0 ? trailing[0].getStart(source) : items[lastKept].getEnd();
+    return [...between, { start: from, end: items[items.length - 1].getEnd(), text: '' }];
 }
 /** Removes a statement together with the rest of its line, so nothing is left blank behind it. */
 export function removeStatement(node) {

package/dist/entitySql.d.ts

@@ -1,22 +1,21 @@
 import ts from 'typescript';
-import { type Edit } from './edits.js';
-/** `raw\`...\`` or `raw(...)`. */
-type RawSql = ts.TaggedTemplateExpression | ts.CallExpression;
-export declare function isRaw(node: ts.Node): node is RawSql;
-/** The expressions of a column list, written as one or returned by its callback: each entry or `column` that is `raw`. */
-export declare function columnExpressions(list: ts.Expression | undefined): readonly RawSql[];
-/** SQL text as a `raw` tagged template, escaping what would end or interpolate it. */
-export declare function rawTag(sql: string): string;
-/**
- * A template literal reading `texts` with the source of each of `values` interpolated between them, one fewer
- * than `texts`: in the texts, a backslash, a backtick and a `${` are escaped.
- */
-export declare function templateOf(texts: readonly string[], values?: readonly string[]): string;
-/** A partial-index `where` string as `raw`, or nothing for a template that interpolates, whose values `raw` would bind. */
-export declare function rawWhereEdit(where: ts.Expression): Edit | undefined;
+import { type Edit, type Part, type Span } from './edits.js';
+/** `sql\`...\`` or `sql(...)`, or the deprecated `raw` of either. */
+type SqlCall = ts.TaggedTemplateExpression | ts.CallExpression;
+export declare function isSqlCall(node: ts.Node, checker: ts.TypeChecker): node is SqlCall;
+/** The expressions of a column list, written as one or returned by its callback: each entry or `column` that is `sql`. */
+export declare function columnExpressions(list: ts.Expression | undefined, checker: ts.TypeChecker): readonly SqlCall[];
+/** SQL text as a template tagged by `name`, escaping what would end or interpolate it. */
+export declare function sqlTag(name: string, sql: string): string;
+/** `text` as a template literal binding nothing: a backslash, a backtick and a `${` in it are escaped. */
+export declare function templateOf(text: string): string;
+/** A template literal reading `texts`, the `values` kept from the original interpolated between them. */
+export declare function templateWith(texts: readonly string[], values: readonly Span[]): readonly Part[];
+/** A partial-index `where` string as `sql`, or nothing for a template that interpolates, whose values `sql` would bind. */
+export declare function sqlWhereEdit(where: ts.Expression, name: string): Edit | undefined;
 /**
  * The columns SQL names by hand, which a rename does not reach: each quoted identifier, and each bare word
  * naming one of `members`. What a string literal holds is left out, as is a word called as a function.
  */
-export declare function handNamedColumns(sql: ts.Expression, members: ReadonlySet<string>): readonly string[];
+export declare function handNamedColumns(sql: ts.Expression, members: ReadonlySet<string>, checker: ts.TypeChecker): readonly string[];
 export {};

package/dist/entitySql.js

@@ -1,59 +1,64 @@
 import ts from 'typescript';
 import { inserted, replaced } from './edits.js';
-import { identifierText, propertyValue } from './syntax.js';
-export function isRaw(node) {
+import { isSqlExport, uqlExport } from './imports.js';
+import { propertyValue } from './syntax.js';
+export function isSqlCall(node, checker) {
     const callee = ts.isTaggedTemplateExpression(node)
         ? node.tag
         : ts.isCallExpression(node)
             ? node.expression
             : undefined;
-    return identifierText(callee) === 'raw';
+    return isSqlExport(uqlExport(callee, checker));
 }
-/** The expressions of a column list, written as one or returned by its callback: each entry or `column` that is `raw`. */
-export function columnExpressions(list) {
+/** The expressions of a column list, written as one or returned by its callback: each entry or `column` that is `sql`. */
+export function columnExpressions(list, checker) {
     const body = list && ts.isArrowFunction(list) ? list.body : list;
     const entries = body && ts.isArrayLiteralExpression(body) ? body.elements : [];
     return entries.flatMap((entry) => {
         const sql = ts.isObjectLiteralExpression(entry) ? propertyValue(entry, 'column') : entry;
-        return sql && isRaw(sql) ? [sql] : [];
+        return sql && isSqlCall(sql, checker) ? [sql] : [];
     });
 }
-/** SQL text as a `raw` tagged template, escaping what would end or interpolate it. */
-export function rawTag(sql) {
-    return `raw${templateOf([sql])}`;
+/** SQL text as a template tagged by `name`, escaping what would end or interpolate it. */
+export function sqlTag(name, sql) {
+    return `${name}${templateOf(sql)}`;
 }
-/**
- * A template literal reading `texts` with the source of each of `values` interpolated between them, one fewer
- * than `texts`: in the texts, a backslash, a backtick and a `${` are escaped.
- */
-export function templateOf(texts, values = []) {
-    const escaped = texts.map((text) => text.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${'));
-    return `\`${escaped.reduce((template, text, at) => `${template}\${${values[at - 1]}}${text}`)}\``;
+/** `text` as a template literal binding nothing: a backslash, a backtick and a `${` in it are escaped. */
+export function templateOf(text) {
+    return `\`${escapedIn(text)}\``;
+}
+/** A template literal reading `texts`, the `values` kept from the original interpolated between them. */
+export function templateWith(texts, values) {
+    const [first, ...rest] = texts.map(escapedIn);
+    return ['`', first, ...rest.flatMap((text, at) => ['${', values[at], '}', text]), '`'];
+}
+function escapedIn(text) {
+    return text.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
 }
-/** A partial-index `where` string as `raw`, or nothing for a template that interpolates, whose values `raw` would bind. */
-export function rawWhereEdit(where) {
+/** A partial-index `where` string as `sql`, or nothing for a template that interpolates, whose values `sql` would bind. */
+export function sqlWhereEdit(where, name) {
     if (ts.isNoSubstitutionTemplateLiteral(where)) {
-        return inserted(where, 'raw');
+        return inserted(where, name);
     }
-    return ts.isStringLiteral(where) ? replaced(where, rawTag(where.text)) : undefined;
+    return ts.isStringLiteral(where) ? replaced(where, sqlTag(name, where.text)) : undefined;
 }
 /**
  * The columns SQL names by hand, which a rename does not reach: each quoted identifier, and each bare word
  * naming one of `members`. What a string literal holds is left out, as is a word called as a function.
  */
-export function handNamedColumns(sql, members) {
-    const code = sqlText(sql)?.replace(/'(?:[^']|'')*'/g, "''") ?? '';
+export function handNamedColumns(sql, members, checker) {
+    const code = sqlText(sql, checker)?.replace(/'(?:[^']|'')*'/g, "''") ?? '';
     const quoted = Array.from(code.matchAll(/"[^"]+"|`[^`]+`/g), ([token]) => token.slice(1, -1));
     const bare = Array.from(code.matchAll(/\b[A-Za-z_]\w*\b(?!\s*\()/g), ([word]) => word);
     return [...new Set([...quoted, ...bare.filter((word) => members.has(word))])];
 }
-/** The text of a `raw` or a string, `?` standing in for each interpolation. */
-function sqlText(sql) {
+/** The text of a `sql` or a string, `?` standing in for each interpolation. */
+function sqlText(sql, checker) {
     if (!sql) {
         return undefined;
     }
-    if (isRaw(sql)) {
-        return sqlText(ts.isTaggedTemplateExpression(sql) ? sql.template : sql.arguments[0]);
+    if (isSqlCall(sql, checker)) {
+        return sqlText(ts.isTaggedTemplateExpression(sql) ? sql.template : sql.arguments[0], checker);
     }
     if (ts.isTemplateExpression(sql)) {
         return [sql.head, ...sql.templateSpans.map((span) => span.literal)].map((part) => part.text).join(' ? ');

package/dist/imports.d.ts

@@ -1,5 +1,8 @@
 import ts from 'typescript';
 import type { Context } from './context.js';
+/** The name `uql-orm` gave its SQL tag, and gives it now. */
+export declare const LEGACY_SQL_TAG = "raw";
+export declare const SQL_TAG = "sql";
 type UqlImport = {
     readonly declaration: ts.ImportDeclaration;
     readonly entry: string;
@@ -16,25 +19,26 @@ export declare function uqlImport(source: ts.SourceFile, name: string, entries?:
 export declare function usesOf(source: ts.SourceFile, name: ts.Identifier, checker: ts.TypeChecker): ts.Identifier[];
 /** Names an export that no longer exists, where it is imported from the package or one of its entries. */
 export declare function reportRemovedExports(ctx: Context): void;
-/**
- * Rewrites each import naming a {@link RENAMED_EXPORTS} export, or from a {@link MOVED_ENTRIES} entry, renaming
- * every use: a name moving entries gets an import from its new one, and one the file already imports is dropped,
- * as is a `dead` one. Returns the rewritten imports, which nothing else may edit.
- */
-export declare function renameExports(dead: ReadonlySet<string>, ctx: Context): ReadonlySet<ts.ImportDeclaration>;
 /**
  * The imported names the codemod removes once every use was rewritten: `Relation` unwrapped and `expr` defaults.
  * A removed decorator keeps its import on purpose: deleting it would swap a clear error for a puzzling one.
  */
 export declare function deadImportNames(ctx: Context): ReadonlySet<string>;
+/** The `uql-orm` export `node` names, where its symbol is an import of it or of one of its entries. */
+export declare function uqlExport(node: ts.Node | undefined, checker: ts.TypeChecker): string | undefined;
+/** Whether `name` is the SQL tag, by either of its names. */
+export declare function isSqlExport(name: string | undefined): boolean;
+/** The name the file calls the SQL tag by once `raw` is renamed: the alias it imports it as, else `sql`. */
+export declare function sqlName(source: ts.SourceFile): string;
 /**
- * Removes `import 'reflect-metadata'`, since the polyfill only ever fed `design:type`, and each `dead` name
- * from the imports {@link renameExports} left as written, having left the dead names out of the rest.
+ * The first identifier of the file already naming something a rewrite writes: a name it imports (`sql`, `refs`,
+ * `idKey`) or a rename brings in. The write would shadow it or be shadowed, so the file is left to its owner.
  */
-export declare function dropDeadImports(dead: ReadonlySet<string>, rewritten: ReadonlySet<ts.ImportDeclaration>, ctx: Context): void;
+export declare function clashingName(ctx: Context): ts.Identifier | undefined;
 /**
- * Imports what the rewrites wrote (`idKey`, `raw`) into the file's own `uql-orm` import. Reported instead
- * where there is none: the package may be imported under a path this codemod does not recognise.
+ * Rewrites the file's imports in one pass: a name {@link RENAMED_EXPORTS} renames or a {@link MOVED_ENTRIES} entry
+ * moves is imported again where it lives now, every use renamed, and one already imported or `dead` is dropped.
+ * The names the rewrites wrote join the first `uql-orm` import, or are reported when there is none.
  */
-export declare function addImports(rewritten: ReadonlySet<ts.ImportDeclaration>, ctx: Context): void;
+export declare function rewriteImports(dead: ReadonlySet<string>, ctx: Context): void;
 export {};

package/dist/imports.js

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

package/dist/statementSql.d.ts

@@ -1,7 +1,8 @@
 import ts from 'typescript';
+import { type Part } from './edits.js';
 /**
  * A querier's `run(sql, values)` statement as the template its tag takes, each placeholder replaced by the value
  * it binds, or nothing where that is not certain: the SQL is no literal, or the values no array literal of
  * plain elements, or its placeholders cannot be told apart from the rest of the text.
  */
-export declare function statementTemplate(sql: ts.Expression, values: readonly ts.Expression[]): string | undefined;
+export declare function statementTemplate(sql: ts.Expression, values: readonly ts.Expression[]): readonly Part[] | undefined;

package/dist/statementSql.js

@@ -1,5 +1,6 @@
 import ts from 'typescript';
-import { templateOf } from './entitySql.js';
+import { original } from './edits.js';
+import { templateOf, templateWith } from './entitySql.js';
 /**
  * A quoted string or identifier, or a comment, skipped; a `?` or `$n` placeholder; or a character a placeholder
  * could hide behind that this does not read: an unclosed quote or comment, a backslash, a `#`, any other `$`.
@@ -40,7 +41,7 @@ export function statementTemplate(sql, values) {
         return undefined;
     }
     if (!values.length) {
-        return templateOf([sql.text]);
+        return [templateOf(sql.text)];
     }
     const [list] = values;
     const elements = ts.isArrayLiteralExpression(list) ? list.elements : undefined;
@@ -48,6 +49,11 @@ export function statementTemplate(sql, values) {
         return undefined;
     }
     const placeholders = placeholdersOf(sql.text, elements.length);
-    return (placeholders &&
-        templateOf(placeholders.texts, placeholders.values.map((at) => elements[at].getText())));
+    if (!placeholders || placeholders.values.some((at) => isReused(placeholders.values, at) && !isPlain(elements[at]))) {
+        return undefined;
+    }
+    return templateWith(placeholders.texts, placeholders.values.map((at) => original(elements[at])));
 }
+/** A value read twice in the template is evaluated twice, which only a name or a literal can do unseen. */
+const isPlain = (value) => ts.isIdentifier(value) || ts.isNumericLiteral(value) || ts.isStringLiteral(value);
+const isReused = (values, at) => values.filter((value) => value === at).length > 1;

package/dist/transform.js

@@ -1,10 +1,10 @@
 import ts from 'typescript';
 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 { appended, applyEdits, inserted, original, replaced } from './edits.js';
+import { columnExpressions, handNamedColumns, sqlTag, sqlWhereEdit, templateOf } from './entitySql.js';
 import { fieldTypeFor, isBrandedString, relationTargetFor } from './fieldType.js';
-import { addImports, deadImportNames, dropDeadImports, renameExports, reportRemovedExports, uqlImport, uqlImportDeclarations, } from './imports.js';
+import { clashingName, deadImportNames, LEGACY_SQL_TAG, reportRemovedExports, rewriteImports, SQL_TAG, sqlName, uqlExport, uqlImport, uqlImportDeclarations, } from './imports.js';
 import { entityGetterTarget, fieldKeysEdits, isCallback, keyListEdits, mappedByEdits, memberAccess, paramFor, quoted, referencesEdits, } from './keyMaps.js';
 import { statementTemplate } from './statementSql.js';
 import { arrayElements, decoratorName, decoratorsOf, identifierText, namedProperty, objectLiteral, objectProperties, propertyKey, propertyValue, } from './syntax.js';
@@ -69,12 +69,12 @@ 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>}...\``);
+        `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) {
@@ -311,23 +311,23 @@ function rewriteIndex(columns, options, owner, node, what, ctx) {
     rewriteKeyList(columns, owner.param, node, what, 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 +360,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 +369,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 +414,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 +430,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`);
@@ -458,7 +460,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 }`. */
@@ -549,7 +551,7 @@ function unwrapRelationAlias(node, ctx) {
         ts.isTypeReferenceNode(declared) &&
         identifierText(declared.typeName) === 'Relation' &&
         declared.typeArguments?.length === 1) {
-        ctx.edits.push(replaced(declared, declared.typeArguments[0].getText()));
+        ctx.edits.push(replaced(declared, [original(declared.typeArguments[0])]));
         ctx.rewritten.Relation += 1;
     }
 }
@@ -676,23 +678,23 @@ 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] });
     }
 }
 /**
@@ -701,12 +703,12 @@ function rewriteRawCall(node, ctx) {
  */
 export function transformFile(source, checker, options = { strictNullChecks: true }) {
     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)) {
@@ -736,16 +738,16 @@ 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());
+    }
     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,
-    };
+    return fileResult(ctx, applyEdits(source.getFullText(), ctx.edits));
+}
+function fileResult({ source, unresolved, notes }, text) {
+    return { fileName: source.fileName, text, changed: text !== source.getFullText(), unresolved, notes };
 }

package/dist/tsconfig.js

@@ -17,12 +17,11 @@ export function transformTsconfig(fileName, text) {
     const unresolved = [];
     const compilerOptions = propertyValue(root, 'compilerOptions');
     if (compilerOptions && ts.isObjectLiteralExpression(compilerOptions)) {
-        for (const flag of LEGACY_FLAGS) {
+        const legacy = LEGACY_FLAGS.flatMap((flag) => {
             const property = propertyAssignment(compilerOptions, flag);
-            if (property) {
-                edits.push(removeFromList(compilerOptions.properties, property, source));
-            }
-        }
+            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');

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.0",
+  "version": "0.48.2",
   "type": "module",
   "engines": {
     "node": ">=22.18"