uql-codemod 0.50.1 → 0.52.0

package/README.md

@@ -31,12 +31,13 @@ Only `--flag=value` is read, and anything unrecognised is an error. It exits `0`
 - Members named by string to callbacks: `mappedBy: 'author'` to `(post) => post.author`, and `include`, `references` and `@Entity`/`defineEntity`'s `indexes` and `hooks` likewise: `{ columns: (post) => [post.title] }`.
 - `references: (post) => post.authorId` on a to-one (`@ManyToOne`, `@OneToOne`, or in `defineEntity`) 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 `sql`, importing it, on entities and in the migration builder.
-- A class registered with `defineEntity(Post, { ... })` to the `defineEntity({ ... })` call it stands for, whole or not at all: `export const Post = defineEntity({ name: 'Post', fields })` with its sections chained, as a defined entity's options are above, and `export type Post = InstanceType<typeof Post>`. The class is removed and a table it named kept as `table`; a field stating no `type` takes the one its property declares (`authorId?: number | null` is `f.number().nullable()`), each relation becomes `author: () => rel.manyToOne(User, { ... })`, a relation aggregate a derived field (`(post) => ({ total: () => post.comments.count() })`), a hook's method a function of the row (`this` read as the row), and the same class's `defineField`, `defineId`, `defineRelation`, `defineHook`, `defineIndex`, `defineTrigger` and `defineFilter` are folded in.
+- A class registered with `defineEntity(Post, { ... })` to the `defineEntity({ ... })` call it stands for, whole or not at all: `export const Post = defineEntity({ name: 'Post', fields })` with its sections chained, as a defined entity's options are above, and `export type Post = InstanceType<typeof Post>`. The class is removed and a table it named kept as `table`; a field stating no `type` takes the one its property declares (`authorId?: number | null` is `f.number().nullable()`), each relation becomes `author: () => rel.manyToOne(User, { ... })`, a relation aggregate an aggregate field (`(post) => ({ total: () => post.comments.count() })`), a hook's method a function of the row (`this` read as the row), and the same class's `defineField`, `defineId`, `defineRelation`, `defineHook`, `defineIndex`, `defineTrigger` and `defineFilter` are folded in.
 - A JSON index entry to the path read off the column's ref: `{ column: post.kind, jsonPath: { path: 'theme', type: Number } }` to `{ column: post.kind.theme, type: Number }`, and a `jsonArray`'s element type to `type: [String]`.
 - `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 } }`.
-- 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`, `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`.
+- 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

@@ -1,12 +1,12 @@
 import ts from 'typescript';
 import { call, flag, flagOrCall } from './columnMethods.js';
 import { formatFindings, locationAt } from './context.js';
-import { FOREIGN_KEY_IN_DEFINED, NO_KEY_TYPE, nameClash, ON_DELETE_ON_RELATION } from './definedMessages.js';
+import { UNJOINED_FOREIGN_KEY, NO_KEY_TYPE, nameClash, ON_DELETE_ON_RELATION } from './definedMessages.js';
 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);
@@ -340,7 +345,7 @@ function definedColumn(node) {
         }
         const target = targetOf(references.call.arguments[0]);
         if (identifierText(references.receiver) === 'f' || !target) {
-            return { message: target ? NO_KEY_TYPE : FOREIGN_KEY_IN_DEFINED };
+            return { message: target ? NO_KEY_TYPE : UNJOINED_FOREIGN_KEY };
         }
         const onDelete = methods.get('onDelete');
         const cut = [references, ...(onDelete ? [onDelete] : [])].map((method) => ({
@@ -360,7 +365,7 @@ function definedColumn(node) {
     const references = options.get('references');
     const target = references && targetOf(references);
     if (references && !target) {
-        return { message: FOREIGN_KEY_IN_DEFINED };
+        return { message: UNJOINED_FOREIGN_KEY };
     }
     if (target && !options.has('type')) {
         return { message: NO_KEY_TYPE };
@@ -408,7 +413,7 @@ function claimKey(name, { target, onDelete }, claims, targets) {
     }
     const relation = ts.isIdentifier(name) ? /^(.+?)(?:Id|_id)$/.exec(key)?.[1] : undefined;
     if (!relation || claims.named.has(relation) || !targets.insertable) {
-        return { claims, problem: FOREIGN_KEY_IN_DEFINED };
+        return { claims, problem: UNJOINED_FOREIGN_KEY };
     }
     const written = [
         `references: (${targets.param}) => ${targets.param}.${key}`,
@@ -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/definedMessages.d.ts

@@ -1,7 +1,7 @@
 /** Why a name the codemod writes is refused: a file already binds it. */
 export declare const nameClash: (name: string) => string;
 /** Why a defined column's foreign key is refused: no relation joins on it, and none can be written for it. */
-export declare const FOREIGN_KEY_IN_DEFINED = "references another entity, and no relation can be named for it: declare one in '.relations()', as 'rel.manyToOne(Target, { references: (row) => row.key })'";
+export declare const UNJOINED_FOREIGN_KEY = "references another entity, and no relation can be named for it: declare one in '.relations()', as 'rel.manyToOne(Target, { references: (row) => row.key })'";
 /** Why a joined column's `onDelete` is refused: its relation states another, or takes options the codemod cannot write into. */
 export declare const ON_DELETE_ON_RELATION = "joins through a relation that cannot take its 'onDelete': settle the action in that relation's options";
 /** Why a foreign key with no type is refused: a defined column states its own, which only its target's key implied. */

package/dist/definedMessages.js

@@ -1,7 +1,7 @@
 /** Why a name the codemod writes is refused: a file already binds it. */
 export const nameClash = (name) => `'${name}' is already named here, and the codemod writes it`;
 /** Why a defined column's foreign key is refused: no relation joins on it, and none can be written for it. */
-export const FOREIGN_KEY_IN_DEFINED = "references another entity, and no relation can be named for it: declare one in '.relations()', as 'rel.manyToOne(Target, { references: (row) => row.key })'";
+export const UNJOINED_FOREIGN_KEY = "references another entity, and no relation can be named for it: declare one in '.relations()', as 'rel.manyToOne(Target, { references: (row) => row.key })'";
 /** Why a joined column's `onDelete` is refused: its relation states another, or takes options the codemod cannot write into. */
 export const ON_DELETE_ON_RELATION = "joins through a relation that cannot take its 'onDelete': settle the action in that relation's options";
 /** Why a foreign key with no type is refused: a defined column states its own, which only its target's key implied. */

package/dist/imports.js

@@ -76,6 +76,7 @@ export const SQL_TAG = 'sql';
  */
 const RENAMED_EXPORTS = new Map([
     ['QueryWhereMap', { to: 'QueryWhere' }],
+    ['QueryConflictPaths', { to: 'QueryConflictKeys' }],
     ['IndexColumnSchema', { to: 'IndexEntry' }],
     ['IndexColumnModifiers', { to: 'IndexEntryModifiers' }],
     ['RelationKeyMap', { to: 'KeyMap' }],

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,24 +428,65 @@ function rewriteBuilderCall(call, ctx) {
 }
 const UPSERT_CALLS = new Set(['upsertOne', 'upsertMany', 'upsertInto']);
 /**
- * Rewrites an upsert's 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. 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);
-    const options = call.arguments[3];
-    const update = options && upsertUpdate(options);
-    if (name && UPSERT_CALLS.has(name) && update) {
-        ctx.edits.push(replaced(options, [original(update)]));
+    const [, query, payload, fourth] = call.arguments;
+    if (!name || !UPSERT_CALLS.has(name) || !query || !payload || ts.isSpreadElement(query)) {
+        return;
+    }
+    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, ' }'];
+    }
+    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 !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.50.1",
+  "version": "0.52.0",
   "type": "module",
   "engines": {
     "node": ">=22.18"