uql-codemod 0.51.0 → 0.52.0

package/README.md

@@ -36,7 +36,7 @@ Only `--flag=value` is read, and anything unrecognised is an error. It exits `0`
 - `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.
 - `$exclude` to a `$select` leaving its fields out: `$exclude: { password: true }` to `$select: { password: false }`, at every depth of `$populate`.
 - An aggregate's `$agg` to `$select`, and each field it or `$text`'s `$fields` names to a key: `{ $sum: { amount: true } }`.
-- An upsert's conflict keys to a query, `upsertOne(User, { email: true }, row)` to `upsertOne(User, { $conflict: { email: true } }, row)`, and its `{ update: X }` options to `X` as its fourth argument, in `upsertOne`, `upsertMany` and a trigger's `upsertInto`; `const { id } = await upsertOne(...)` to `const id`.
+- An upsert's conflict keys to a query, `upsertOne(User, { email: true }, row)` to `upsertOne(User, { $conflict: { email: true } }, row)`, and its update, `{ update: X }` options or a fourth argument, to the query's `$update: X`, in `upsertOne`, `upsertMany` and a trigger's `upsertInto`; `const { id } = await upsertOne(...)` to `const id`.
 - Renamed exports, at the import and every use: `raw` to `sql`, `QueryWhereMap` to `QueryWhere`, `IndexColumnSchema` to `IndexEntry`, `IndexColumnModifiers` to `IndexEntryModifiers`, `RelationKeyMap` to `KeyMap`, `FilterCondition` to `FilterWhere`, `SqlMigrationModuleOptions` to `MigrationModuleOptions`, `buildSqlQuerierMigrationModule` to `buildMigrationModule`, `QueryDialect` to `SqlQueryDialect`, `EngineFeatures` to `DialectFeatures`, `KnownMigratorDialect` to `DialectName`, `QueryConflictPaths` to `QueryConflictKeys`, `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 (`IColumnBuilder`/`IColumnFactory`, and `uql-orm/migrate`'s `ColumnBuilder`/`ColumnFactory`, to `TableColumnBuilder`/`TableColumnFactory`), 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.

package/dist/builders.d.ts

@@ -3,7 +3,7 @@ import { type Pass } from './edits.js';
 export type BuildersResult = Pass & {
     readonly unresolved: string[];
 };
-/** Whether `node` is already a builder, `f.string()...`. */
+/** Whether `node` is already a builder, `f.string()...`, or a chain off a `const` holding one. */
 export declare function isBuilder(node: ts.Expression): boolean;
 /** The names a builder writes, which the file must not bind otherwise. */
 export declare const BUILDER_NAMES: ReadonlySet<string>;

package/dist/builders.js

@@ -6,7 +6,7 @@ import { CHAINED_OPTIONS, FIRST_CALL_OPTIONS } from './definedOptions.js';
 import { applyEdits, editedText, replaced, replacingUses, reparsedAgain, unedited, } from './edits.js';
 import { importEdits } from './imports.js';
 import { isCallback, paramFor } from './keyMaps.js';
-import { chainOf, decoratorName, decoratorsOf, FIELD_DECORATORS, identifierText, identifierUses, indentOf, indentUnit, keyOf, objectLiteral, objectProperties, optionsOf, propertiesByKey, propertyAssignment, propertyKey, propertyValue, } from './syntax.js';
+import { chainOf, constValue, decoratorName, decoratorsOf, FIELD_DECORATORS, identifierText, identifierUses, indentOf, indentUnit, isNamedProperty, keyOf, namedValue, objectLiteral, objectProperties, optionsOf, propertiesByKey, propertyAssignment, propertyKey, propertyValue, } from './syntax.js';
 /** The column type each constructor implies, and the builder it is now. */
 const CONSTRUCTORS = {
     String: 'f.string()',
@@ -228,9 +228,14 @@ function computedDecorator(call, options, computed, findings, used) {
     used.add('f');
     return [replaced(call, `Computed((${param}) => ${built})`)];
 }
-/** Whether `node` is already a builder, `f.string()...`. */
+/** Whether `node` is already a builder, `f.string()...`, or a chain off a `const` holding one. */
 export function isBuilder(node) {
-    return identifierText(chainOf(node).root) === 'f';
+    const { root } = chainOf(node);
+    if (identifierText(root) === 'f') {
+        return true;
+    }
+    const held = ts.isIdentifier(root) ? constValue(root) : undefined;
+    return held !== undefined && isBuilder(held);
 }
 /** The options a defined entity's first call keeps. */
 const FIRST_CALL = new Set(FIRST_CALL_OPTIONS);
@@ -545,7 +550,7 @@ function appendedEntries(literal, entries, base) {
 }
 /** Whether a defined column is a builder naming no foreign key, which a defined entity's `fields` keep as they are. */
 function isDefinedColumn(prop) {
-    return (ts.isPropertyAssignment(prop) && isBuilder(prop.initializer) && !chainMethods(prop.initializer).has('references'));
+    return isNamedProperty(prop) && isBuilder(namedValue(prop)) && !chainMethods(namedValue(prop)).has('references');
 }
 /** Each method a builder chain calls, by name. */
 function chainMethods(node) {

package/dist/syntax.d.ts

@@ -6,6 +6,10 @@ export declare function propertyKey(name: ts.PropertyName): string | undefined;
 /** A property of an object literal written with its own name: a plain or quoted key, or a shorthand. */
 export type NamedProperty = ts.PropertyAssignment | ts.ShorthandPropertyAssignment;
 export declare function isNamedProperty(prop: ts.ObjectLiteralElementLike): prop is NamedProperty;
+/** What a named property holds: a shorthand holds its name. */
+export declare function namedValue(prop: NamedProperty): ts.Expression;
+/** What the `const` `name` reads holds, where one is declared before it in a scope it sits in. */
+export declare function constValue(name: ts.Identifier): ts.Expression | undefined;
 /** The property `name` of an object literal, a shorthand included. */
 export declare function namedProperty(node: ts.ObjectLiteralExpression, name: string): NamedProperty | undefined;
 /** The key a property is written under, a shorthand's included; nothing for a spread, a method or a computed key. */

package/dist/syntax.js

@@ -10,6 +10,30 @@ export function propertyKey(name) {
 export function isNamedProperty(prop) {
     return ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop);
 }
+/** What a named property holds: a shorthand holds its name. */
+export function namedValue(prop) {
+    return ts.isShorthandPropertyAssignment(prop) ? prop.name : prop.initializer;
+}
+/** What the `const` `name` reads holds, where one is declared before it in a scope it sits in. */
+export function constValue(name) {
+    for (let scope = name.parent; scope; scope = scope.parent) {
+        const statements = ts.isSourceFile(scope) || ts.isBlock(scope) || ts.isModuleBlock(scope) ? scope.statements : [];
+        for (const statement of statements) {
+            if (statement.end > name.pos) {
+                break;
+            }
+            if (!ts.isVariableStatement(statement)) {
+                continue;
+            }
+            const { declarationList } = statement;
+            const declared = declarationList.declarations.find((it) => identifierText(it.name) === name.text);
+            if (declared && declarationList.flags & ts.NodeFlags.Const) {
+                return declared.initializer;
+            }
+        }
+    }
+    return undefined;
+}
 /** The property `name` of an object literal, a shorthand included. */
 export function namedProperty(node, name) {
     return node.properties.find((prop) => isNamedProperty(prop) && propertyKey(prop.name) === name);
@@ -45,7 +69,7 @@ export function propertiesByKey(node) {
         if (key === undefined) {
             return undefined;
         }
-        props.set(key, ts.isShorthandPropertyAssignment(prop) ? prop.name : prop.initializer);
+        props.set(key, namedValue(prop));
     }
     return props;
 }

package/dist/transform.js

@@ -14,7 +14,7 @@ import { entityGetterTarget, fieldKeysEdits, isCallback, keyListEdits, mappedByE
 import { toMigrationBuilders } from './migrationBuilders.js';
 import { relationTargetFor } from './relationTarget.js';
 import { statementTemplate } from './statementSql.js';
-import { arrayElements, decoratorName, decoratorsOf, FIELD_DECORATORS, identifierText, indentOf, namedProperty, objectLiteral, objectProperties, optionsOf, propertyKey, propertyValue, } from './syntax.js';
+import { arrayElements, decoratorName, decoratorsOf, FIELD_DECORATORS, identifierText, indentOf, namedProperty, namedValue, objectLiteral, objectProperties, optionsOf, propertyKey, propertyValue, } from './syntax.js';
 const RELATION_DECORATORS = new Set(['OneToOne', 'ManyToOne', 'OneToMany', 'ManyToMany']);
 const TO_ONE_DECORATORS = new Set(['OneToOne', 'ManyToOne']);
 const TO_ONE_CARDINALITIES = new Set(['11', 'm1']);
@@ -428,36 +428,65 @@ function rewriteBuilderCall(call, ctx) {
 }
 const UPSERT_CALLS = new Set(['upsertOne', 'upsertMany', 'upsertInto']);
 /**
- * Rewrites an upsert's conflict keys into its query's `$conflict`, `{ $conflict: { sku: true } }`, and its options
- * holding `update` alone into that update, its fourth argument now. Read wherever it is called, since a querier is
- * seldom imported from uql where it is used. A query already naming `$conflict`, or typed with one, is left as it is,
- * and any other fourth argument is already an update, `{}` included, so a second run changes nothing.
+ * Rewrites an upsert into one query: its conflict keys as `$conflict`, `{ $conflict: { sku: true } }`, and its update, a
+ * fourth argument or options holding `update` alone, as `$update`, the options after it kept. Read wherever it is
+ * called, since a querier is seldom imported from uql where it is used. A fourth argument holding only `returning` is
+ * already the options, and a query already naming `$conflict` keeps it, so a second run changes nothing.
  */
 function rewriteUpsertCall(call, ctx) {
     const callee = call.expression;
     const name = identifierText(ts.isPropertyAccessExpression(callee) ? callee.name : callee);
-    if (!name || !UPSERT_CALLS.has(name)) {
+    const [, query, payload, fourth] = call.arguments;
+    if (!name || !UPSERT_CALLS.has(name) || !query || !payload || ts.isSpreadElement(query)) {
         return;
     }
-    const keys = call.arguments[1];
-    if (call.arguments.length >= 3 && keys && isConflictKeys(keys, ctx)) {
-        ctx.edits.push(replaced(keys, ['{ $conflict: ', original(keys), ' }']));
+    const moved = fourth && !isWriteOptions(fourth, ctx) ? fourth : undefined;
+    const update = moved && !isUndefined(moved) ? (upsertUpdate(moved) ?? moved) : undefined;
+    const keys = isConflictKeys(query, ctx);
+    if (!keys && !moved) {
+        return;
+    }
+    const end = moved ?? query;
+    ctx.edits.push({
+        start: query.getStart(),
+        end: end.getEnd(),
+        text: [...upsertQuery(query, keys, update), ...(moved ? [{ start: query.getEnd(), end: payload.getEnd() }] : [])],
+    });
+}
+/** The parts of an upsert's query naming `update` as its `$update`: the old conflict map wrapped, a literal extended, else spread. */
+function upsertQuery(query, keys, update) {
+    const named = update ? [', $update: ', original(update)] : [];
+    if (keys) {
+        return ['{ $conflict: ', original(query), ...named, ' }'];
     }
-    const options = call.arguments[3];
-    const update = options && upsertUpdate(options);
-    if (update) {
-        ctx.edits.push(replaced(options, [original(update)]));
+    if (!update) {
+        return [original(query)];
     }
+    const last = objectLiteral(query)?.properties.at(-1);
+    return last
+        ? [{ start: query.getStart(), end: last.getEnd() }, ...named, ' }']
+        : ['{ ...', original(query), ...named, ' }'];
 }
 /** Whether `keys` is the old conflict map, `{ sku: true }`: an argument of its own, not yet a query naming `$conflict`. */
 function isConflictKeys(keys, ctx) {
-    return !ts.isSpreadElement(keys) && !ctx.checker.getTypeAtLocation(keys).getProperty('$conflict');
+    return !ctx.checker.getTypeAtLocation(keys).getProperty('$conflict');
+}
+/** Whether a fourth argument is already the write's options: something naming `returning` and nothing else. */
+function isWriteOptions(node, ctx) {
+    const names = ctx.checker
+        .getTypeAtLocation(node)
+        .getProperties()
+        .map((property) => property.name);
+    return names.length > 0 && names.every((name) => name === 'returning');
+}
+function isUndefined(node) {
+    return identifierText(node) === 'undefined';
 }
 /** The value of options holding `update` alone, `{ update: value }` or `{ update }`. */
 function upsertUpdate(options) {
     const literal = objectLiteral(options);
     const property = literal?.properties.length === 1 ? namedProperty(literal, 'update') : undefined;
-    return property && (ts.isPropertyAssignment(property) ? property.initializer : property.name);
+    return property && namedValue(property);
 }
 /**
  * `owner` is the declaring class's parameter and `target` the related one's, read off the `entity`

package/package.json

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