uql-codemod 0.46.0 → 0.47.0

package/LICENSE.md

@@ -0,0 +1,22 @@
+Copyright (c) 2015-present UQL Contributors
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -32,7 +32,8 @@ Only `--flag=value` is read, and anything unrecognised is an error. It exits `0`
 - 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.
 - 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`, moving the import to the entry that exports it; and `MongoQuerier`, `isMongoQuerier`, `MongoMigrationStorage` and `MongoSchemaIntrospector` to `uql-orm/mongo`.
+- 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`.
+- 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.
 
@@ -42,7 +43,7 @@ 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 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`).
 - 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.

package/dist/bin.js

@@ -1,13 +1,17 @@
 #!/usr/bin/env node
 import { parseArgs } from './cli.js';
 import { run } from './index.js';
-const USAGE = 'usage: uql-codemod [--project=<path>] [--include=<a,b>] [--dry-run]';
+const USAGE = 'usage: uql-codemod [--project=<path>] [--include=<a,b>] [--dry-run] [--help]';
 // Exit 2 is "could not start", so a script can tell it apart from exit 1, "there is work left".
 const stop = (message) => {
     console.error(message);
     process.exit(2);
 };
-const { options, errors } = parseArgs(process.argv.slice(2));
+const { options, help, errors } = parseArgs(process.argv.slice(2));
+if (help) {
+    console.log(USAGE);
+    process.exit(0);
+}
 if (errors.length) {
     stop([...errors, USAGE].join('\n'));
 }
@@ -19,8 +23,11 @@ for (const line of summary.notes) {
 for (const line of summary.unresolved) {
     console.error(`needs a decision: ${line}`);
 }
+for (const file of summary.changed) {
+    console.log(`${options.dryRun ? 'would change' : 'changed'}: ${file}`);
+}
 console.log(`${summary.changed.length} file(s) ${options.dryRun ? 'would change' : 'changed'}`);
 if (summary.unresolved.length) {
-    console.error(`${summary.unresolved.length} property(ies) left untouched; see above`);
+    console.error(`${summary.unresolved.length} item(s) need a decision; see above`);
     process.exit(1);
 }

package/dist/cli.d.ts

@@ -1,6 +1,8 @@
 import type { RunOptions } from './index.js';
 export type ParsedArgs = {
     readonly options: RunOptions;
+    /** Whether to print the usage and stop. */
+    readonly help: boolean;
     /** Why the arguments were rejected. Nothing runs while this is non-empty. */
     readonly errors: readonly string[];
 };

package/dist/cli.js

@@ -11,11 +11,16 @@ export function parseArgs(argv) {
     const errors = [];
     const values = new Map();
     let dryRun = false;
+    let help = false;
     for (const arg of argv) {
         if (arg === '--dry-run') {
             dryRun = true;
             continue;
         }
+        if (arg === '--help' || arg === '-h') {
+            help = true;
+            continue;
+        }
         const separator = arg.indexOf('=');
         const name = arg.slice(2, separator === -1 ? undefined : separator);
         if (!arg.startsWith('--') || !VALUE_FLAGS.has(name)) {
@@ -35,6 +40,7 @@ export function parseArgs(argv) {
             dryRun,
             include: values.get('include')?.split(',').filter(Boolean),
         },
+        help,
         errors,
     };
 }

package/dist/entitySql.d.ts

@@ -7,6 +7,8 @@ export declare function isRaw(node: ts.Node): node is RawSql;
 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;
+/** `sql` as a template literal reading the same text: a backslash, a backtick and a `${` escaped. */
+export declare function templateOf(sql: 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;
 /**

package/dist/entitySql.js

@@ -20,7 +20,11 @@ export function columnExpressions(list) {
 }
 /** SQL text as a `raw` tagged template, escaping what would end or interpolate it. */
 export function rawTag(sql) {
-    return `raw\`${sql.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${')}\``;
+    return `raw${templateOf(sql)}`;
+}
+/** `sql` as a template literal reading the same text: a backslash, a backtick and a `${` escaped. */
+export function templateOf(sql) {
+    return `\`${sql.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) {

package/dist/index.js

@@ -29,13 +29,15 @@ export async function run({ project, dryRun, include }) {
         noEmit: true,
     });
     const checker = program.getTypeChecker();
+    const { strictNullChecks, strict } = program.getCompilerOptions();
+    const nulls = { strictNullChecks: strictNullChecks ?? strict ?? false };
     const results = [];
     for (const source of program.getSourceFiles()) {
         if (source.isDeclarationFile || /[/\\]node_modules[/\\]/.test(source.fileName))
             continue;
         if (include?.length && !include.some((fragment) => source.fileName.includes(fragment)))
             continue;
-        const result = transformFile(source, checker);
+        const result = transformFile(source, checker, nulls);
         if (result.changed || result.unresolved.length || result.notes.length)
             results.push(result);
     }

package/dist/transform.d.ts

@@ -9,4 +9,6 @@ export type FileResult = {
     readonly notes: readonly string[];
 };
 /** Rewrites one source file for the standard decorator spec. */
-export declare function transformFile(source: ts.SourceFile, checker: ts.TypeChecker): FileResult;
+export declare function transformFile(source: ts.SourceFile, checker: ts.TypeChecker, options?: {
+    readonly strictNullChecks: boolean;
+}): FileResult;

package/dist/transform.js

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 import { appended, applyEdits, inserted, removeFromList, replaced } from './edits.js';
-import { columnExpressions, handNamedColumns, isRaw, rawTag, rawWhereEdit } from './entitySql.js';
+import { columnExpressions, handNamedColumns, isRaw, rawTag, rawWhereEdit, templateOf } from './entitySql.js';
 import { fieldTypeFor, isBrandedString, relationTargetFor } from './fieldType.js';
 import { entityGetterTarget, fieldKeysEdits, isCallback, keyListEdits, mappedByEdits, memberAccess, paramFor, propertyKey, propertyValue, quoted, referencesEdits, } from './keyMaps.js';
 const FIELD_DECORATORS = new Set(['Field', 'Id']);
@@ -56,14 +56,33 @@ const REMOVED_EXPORTS = new Map([
         'POSTGRES_WIRE_DRIVER_CAPABILITIES',
         'pass `driverCapabilities: { nativeArrays: false, explicitJsonCast: true }` to the dialect',
     ],
-    ['MysqlLikeSqlDialect', 'extend `MySqlDialect` (`uql-orm/mysql`) or `MariaDialect` (`uql-orm/maria`)'],
+    ['MysqlLikeSqlDialect', 'extend `MySqlDialect` (`uql-orm/mysql`) or `MariaDialect` (`uql-orm/mariadb`)'],
     ['D1Meta', "uql reads `D1Result['meta']`; the rest of a binding is typed by `@cloudflare/workers-types`"],
     ['D1ExecResult', 'the rest of a binding is typed by `@cloudflare/workers-types`'],
     ['createSchemaGenerator', 'use `new SqlSchemaGenerator(dialect)`, or `migrator.getSchemaGenerator()`'],
+    ...['JsonMigrationStorage', 'DatabaseMigrationStorage', 'MongoMigrationStorage'].map((name) => [name, 'the migrator keeps its journal in the database itself, named by `tableName`']),
 ]);
+/** What `uql-orm/util` exported that the root still does. */
+const UTIL_ROOT_EXPORTS = [
+    'currentDate',
+    'currentTime',
+    'currentTimestamp',
+    'raw',
+    'refs',
+    'uuid',
+    'uuidv7',
+    'deleteFrom',
+    'insertInto',
+    'refuse',
+    'updateTable',
+    'upsertInto',
+    'withDeleted',
+    'HookContext',
+    'DefaultLogger',
+];
 /**
- * Exports renamed or moved and nothing else - the driver classes were empty subclasses - so the import and
- * every use follow, the import moving to `from` where the name lives in another entry.
+ * 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.
  */
 const RENAMED_EXPORTS = new Map([
     ['QueryWhereMap', { to: 'QueryWhere' }],
@@ -75,7 +94,7 @@ const RENAMED_EXPORTS = new Map([
     ['CrdbQuerier', { to: 'PgQuerier', from: 'uql-orm/postgres' }],
     ['NeonQuerier', { to: 'PgQuerier', from: 'uql-orm/postgres' }],
     ['MySql2Dialect', { to: 'MySqlDialect', from: 'uql-orm/mysql' }],
-    ['MongodbNativeDialect', { to: 'MongoDialect', from: 'uql-orm/mongo' }],
+    ['MongodbNativeDialect', { to: 'MongoDialect', from: 'uql-orm/mongodb' }],
     ['LibsqlQuerier', { to: 'HranaQuerier', from: 'uql-orm/sqlite' }],
     ['TursoQuerier', { to: 'HranaQuerier', from: 'uql-orm/sqlite' }],
     ['TursoLocalQuerier', { to: 'SqliteQuerier', from: 'uql-orm/sqlite' }],
@@ -87,10 +106,43 @@ const RENAMED_EXPORTS = new Map([
     ['KnownMigratorDialect', { to: 'DialectName', from: 'uql-orm' }],
     ['D1Preparer', { to: 'D1Queryable' }],
     ['D1Database', { to: 'D1Queryable', from: 'uql-orm/d1' }],
-    ['MongoQuerier', { to: 'MongoQuerier', from: 'uql-orm/mongo' }],
-    ['isMongoQuerier', { to: 'isMongoQuerier', from: 'uql-orm/mongo' }],
-    ['MongoMigrationStorage', { to: 'MongoMigrationStorage', from: 'uql-orm/mongo' }],
-    ['MongoSchemaIntrospector', { to: 'MongoSchemaIntrospector', from: 'uql-orm/mongo' }],
+    ['MongoQuerier', { to: 'MongoQuerier', from: 'uql-orm/mongodb' }],
+    ['isMongoQuerier', { to: 'isMongoQuerier', from: 'uql-orm/mongodb' }],
+    ['MongoSchemaIntrospector', { to: 'MongoSchemaIntrospector', from: 'uql-orm/mongodb' }],
+    ['Sqlite3QuerierPool', { to: 'SqliteQuerierPool' }],
+    ['Sqlite3PoolOptions', { to: 'SqlitePoolOptions' }],
+    ['IMigrationBuilder', { to: 'MigrationBuilder' }],
+    ['ITableBuilder', { to: 'TableBuilder' }],
+    ['IAlterTableBuilder', { to: 'AlterTableBuilder' }],
+    ['IColumnBuilder', { to: 'ColumnBuilder' }],
+    ['IColumnFactory', { to: 'ColumnFactory' }],
+    ['IForeignKeyBuilder', { to: 'ForeignKeyBuilder' }],
+    ['ITableForeignKeyBuilder', { to: 'TableForeignKeyBuilder' }],
+    ['UqlLockUsageError', { to: 'UqlUsageError' }],
+    ['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' }]),
+]);
+/** What the root exported that is internal now, and what to write instead. */
+const INTERNAL_EXPORTS = new Map([
+    ...['AbstractDialect', 'AbstractSqlDialect', 'AbstractQuerier', 'AbstractQuerierPool'].map((name) => [name, "extend a driver's dialect or pool from its entry instead"]),
+    ...['AbstractSqlQuerier', 'AbstractSqlQuerierPool'].map((name) => [name, "extend a driver's querier or pool from its entry instead"]),
+    ['SqlQueryContext', 'make one with `dialect.createContext()`, typed `QueryContext`'],
+    ['dialectOptionsFrom', "pass the options to the driver's dialect"],
+    ...['fieldOf', 'relationOf', 'soleIdOf', 'assertSoleId'].map((name) => [name, 'read the field off `getMeta(Entity).fields`']),
+    ['namesKey', 'read the keys off `getMeta(Entity).ids`'],
+    ['getEntities', 'list your entities in the config'],
+]);
+/** Entries renamed, or dropped for repeating the root, each to the one now exporting what it did. */
+const MOVED_ENTRIES = new Map([
+    ['uql-orm/maria', 'uql-orm/mariadb'],
+    ['uql-orm/mongo', 'uql-orm/mongodb'],
+    ['uql-orm/bunSql', 'uql-orm/bun-sql'],
+    ['uql-orm/dialect', 'uql-orm'],
+    ['uql-orm/entity', 'uql-orm'],
+    ['uql-orm/namingStrategy', 'uql-orm'],
+    ['uql-orm/querier', 'uql-orm'],
+    ['uql-orm/type', 'uql-orm'],
 ]);
 /** A node's decorators, or none where it is a kind that cannot carry them. */
 function decoratorsOf(node) {
@@ -216,8 +268,8 @@ function addFieldType(decorator, node, ctx) {
     const type = addInferredOption(decorator, node, ctx, {
         option: 'type',
         // A `references` field deliberately has no `type`: the column resolves from the primary key it
-        // points at, which also carries that key's `columnType` and length.
-        satisfiedBy: ['type', 'references'],
+        // points at, which also carries that key's `columnType` and length. A `computed` one is its SQL.
+        satisfiedBy: ['type', 'references', 'computed'],
         infer: fieldTypeFor,
     });
     // A branded id type (`type UUID = `${string}-${string}-...``) erased to `String` under reflection, so
@@ -440,6 +492,75 @@ function rewriteIndexWhere(options, ctx) {
 function isStringTyped(type) {
     return type.isUnion() ? type.types.every(isStringTyped) : Boolean(type.flags & ts.TypeFlags.StringLike);
 }
+/**
+ * A querier's `run`/`all` handed SQL as a string, which now takes a tagged statement: a literal becomes
+ * `run`...``, SQL built at run time `raw.text`, which splices as the string did. One passed with values is reported.
+ */
+function rewriteSqlCall(call, ctx) {
+    const callee = call.expression;
+    if (!ts.isPropertyAccessExpression(callee) || !SQL_METHODS.has(callee.name.text) || !isUqlMember(callee, ctx)) {
+        return;
+    }
+    const [sql, ...values] = call.arguments;
+    if (!sql || !isStringTyped(ctx.checker.getTypeAtLocation(sql))) {
+        return;
+    }
+    if (values.length) {
+        ctx.unresolved.push(`${ctx.describe(call)}: ${callee.name.text}() takes one raw statement: write the values into it, raw\`... \${value}\`, which binds them`);
+        return;
+    }
+    if (ts.isStringLiteral(sql) || ts.isNoSubstitutionTemplateLiteral(sql)) {
+        const typeArguments = call.typeArguments ? `<${call.typeArguments.map((type) => type.getText()).join(', ')}>` : '';
+        ctx.edits.push(replaced(call, `${callee.getText()}${typeArguments}${templateOf(sql.text)}`));
+        return;
+    }
+    if (ts.isTemplateExpression(sql)) {
+        ctx.notes.push(`${ctx.describe(call)}: the values in this template are spliced into the SQL; write it as raw\`...\` to bind them`);
+    }
+    ctx.edits.push(replaced(sql, `raw.text(${sql.getText()})`));
+    ctx.imports.set('raw', 'the raw.text(...)');
+}
+const SQL_METHODS = new Set(['run', 'all']);
+/** `const { id } = await q.upsertOne(...)`, which resolves to the id now, as the id: other keys are reported. */
+function rewriteUpsertResult(declaration, ctx) {
+    const { name, initializer } = declaration;
+    const call = initializer && ts.isAwaitExpression(initializer) ? initializer.expression : initializer;
+    if (!ts.isObjectBindingPattern(name) ||
+        !call ||
+        !ts.isCallExpression(call) ||
+        !ts.isPropertyAccessExpression(call.expression) ||
+        call.expression.name.text !== 'upsertOne' ||
+        !isUqlMember(call.expression, ctx)) {
+        return;
+    }
+    const [element] = name.elements;
+    const key = element && (element.propertyName ?? element.name);
+    if (name.elements.length === 1 && key && ts.isIdentifier(key) && key.text === 'id' && ts.isIdentifier(element.name)) {
+        ctx.edits.push(replaced(name, element.name.text));
+    }
+    else {
+        ctx.unresolved.push(`${ctx.describe(declaration)}: upsertOne() resolves to the id; 'created' and 'changes' are gone`);
+    }
+}
+/** A `Migrator` call whose name or meaning changed: `pending()`/`executed()` are `status()`, and `down()` reverts one. */
+function reportMigratorCall(call, ctx) {
+    const callee = call.expression;
+    if (!ts.isPropertyAccessExpression(callee) || !isUqlMember(callee, ctx)) {
+        return;
+    }
+    const method = callee.name.text;
+    if (method === 'pending' || method === 'executed') {
+        ctx.unresolved.push(`${ctx.describe(call)}: '${method}()' was removed; read \`(await migrator.status()).${method}\``);
+    }
+    else if (method === 'down' && !call.arguments.length) {
+        ctx.notes.push(`${ctx.describe(call)}: down() with no options reverts only the last migration now; pass \`{ step: Infinity }\` to revert them all`);
+    }
+}
+/** Whether `member` is declared by uql-orm, so a `run` of another library's is left alone. */
+function isUqlMember(member, ctx) {
+    const declarations = ctx.checker.getSymbolAtLocation(member.name)?.declarations ?? [];
+    return declarations.some((declaration) => declaration.getSourceFile().fileName.includes('/node_modules/uql-orm/'));
+}
 /** The migration builder's index methods, each with the position of the options it takes. */
 const BUILDER_INDEX_METHODS = new Map([
     ['index', 1],
@@ -717,14 +838,18 @@ function addImports(source, rewritten, ctx) {
     if (!missing.length) {
         return;
     }
-    const anchor = uqlImportDeclarations(source).find(({ declaration }) => !rewritten.has(declaration))?.elements[0];
+    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`);
         }
         return;
     }
-    ctx.edits.push(inserted(anchor, missing.map(([name]) => `${name}, `).join('')));
+    const names = missing.map(([name]) => name);
+    const typeOnly = anchor.declaration.importClause?.phaseModifier === ts.SyntaxKind.TypeKeyword;
+    ctx.edits.push(typeOnly
+        ? inserted(anchor.declaration, `import { ${names.join(', ')} } from 'uql-orm';\n`)
+        : inserted(anchor.elements[0], names.map((name) => `${name}, `).join('')));
 }
 /** Everything the standard spec needs written onto one decorated property, and the options renamed since. */
 function rewriteProperty(node, ctx) {
@@ -771,7 +896,7 @@ function rewriteProperty(node, ctx) {
 function admitNull(options, node, ctx) {
     // Options it cannot read may state `nullable` themselves, and appending to the property would then
     // contradict the column. `addFieldType` already reports the same options, so this adds no second note.
-    if (options.kind === 'opaque') {
+    if (options.kind === 'opaque' || !ctx.strictNullChecks) {
         return;
     }
     if (declaresNotNull(options) ||
@@ -830,17 +955,31 @@ function reportRemovedDecorators(node, ctx) {
 }
 /** Names an export that no longer exists, where it is imported from the package or one of its entries. */
 function reportRemovedExports(source, ctx) {
-    for (const element of uqlImports(source, true)) {
-        const name = importedName(element);
-        const advice = REMOVED_EXPORTS.get(name);
-        if (advice) {
-            ctx.unresolved.push(`${ctx.describe(element)}: '${name}' was removed; ${advice}`);
+    for (const { declaration, entry, elements } of uqlImportDeclarations(source, true)) {
+        if (entry === 'uql-orm/util') {
+            const names = elements.filter((element) => !renamedTo(element, entry)).map(importedName);
+            if (names.length) {
+                ctx.unresolved.push(`${ctx.describe(declaration)}: 'uql-orm/util' was removed; its helpers are internal, so write your own \`${names.join('`, `')}\``);
+            }
+            continue;
+        }
+        const root = (MOVED_ENTRIES.get(entry) ?? entry) === 'uql-orm';
+        for (const element of elements) {
+            const name = importedName(element);
+            const removed = REMOVED_EXPORTS.get(name);
+            const internal = root ? INTERNAL_EXPORTS.get(name) : undefined;
+            if (removed) {
+                ctx.unresolved.push(`${ctx.describe(element)}: '${name}' was removed; ${removed}`);
+            }
+            else if (internal) {
+                ctx.unresolved.push(`${ctx.describe(element)}: '${name}' is internal; ${internal}`);
+            }
         }
     }
 }
 /**
- * Rewrites each import naming a {@link RENAMED_EXPORTS} export, renaming every use of it: a name moving
- * entries gets an import from its new one, and a name the file already imports is dropped, as is a `dead`
+ * Rewrites each import naming a {@link RENAMED_EXPORTS} export, or from a {@link MOVED_ENTRIES} entry, renaming
+ * every use of it: a name moving entries gets an import from its new one, and a name the file already imports is dropped, as is a `dead`
  * one. Returns the rewritten imports, which nothing else may edit.
  */
 function renameExports(source, dead, ctx) {
@@ -848,8 +987,9 @@ function renameExports(source, dead, ctx) {
     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, elements } of imports) {
-        if (!elements.some((element) => renamedTo(element, entry))) {
+    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, []]]);
@@ -883,7 +1023,7 @@ function renameExports(source, dead, ctx) {
 /** The rename `element` still needs, none where it already names the export at its entry. */
 function renamedTo(element, entry) {
     const name = importedName(element);
-    const rename = RENAMED_EXPORTS.get(name);
+    const rename = RENAMED_EXPORTS.get(`${entry}#${name}`) ?? RENAMED_EXPORTS.get(name);
     return rename?.to === name && rename.from === entry ? undefined : rename;
 }
 /** Every identifier in the file bound to the same symbol as `name`, besides `name` itself. */
@@ -1085,9 +1225,10 @@ function relatedClass(property, node, checker) {
     return symbol && symbol.flags & ts.SymbolFlags.Class ? symbol : undefined;
 }
 /** Rewrites one source file for the standard decorator spec. */
-export function transformFile(source, checker) {
+export function transformFile(source, checker, options = { strictNullChecks: true }) {
     const ctx = {
         checker,
+        strictNullChecks: options.strictNullChecks,
         edits: [],
         unresolved: [],
         notes: [],
@@ -1117,6 +1258,8 @@ export function transformFile(source, checker) {
             rewriteUpsertCall(node, ctx);
             if (importsUql) {
                 rewriteBuilderCall(node, ctx);
+                rewriteSqlCall(node, ctx);
+                reportMigratorCall(node, ctx);
             }
             if (importsExpr) {
                 rewriteExprCall(node, ctx);
@@ -1125,6 +1268,9 @@ export function transformFile(source, checker) {
         if (ts.isPropertyAssignment(node)) {
             rewriteStatementKeys(node, ctx);
         }
+        if (importsUql && ts.isVariableDeclaration(node)) {
+            rewriteUpsertResult(node, ctx);
+        }
         ts.forEachChild(node, visit);
     };
     visit(source);

package/package.json

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