uql-codemod 0.43.0 → 0.45.0

package/dist/transform.js

@@ -447,6 +447,37 @@ const BUILDER_INDEX_METHODS = new Map([
     ['addIndex', 1],
     ['createIndex', 2],
 ]);
+/** The migration builder's `expr` helpers whose value an entity imports under the same name. */
+const EXPR_VALUES = new Set(['currentDate', 'currentTime', 'uuid', 'uuidv7']);
+/**
+ * Rewrites the migration builder's `expr.<helper>()` default as the value or `raw` 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) {
+    const callee = call.expression;
+    if (!ts.isPropertyAccessExpression(callee) ||
+        !ts.isIdentifier(callee.expression) ||
+        callee.expression.text !== 'expr') {
+        return;
+    }
+    const helper = callee.name.text;
+    // The one renamed: an entity's clock is `currentTimestamp`.
+    const value = helper === 'now' ? 'currentTimestamp' : EXPR_VALUES.has(helper) ? helper : undefined;
+    const [sql] = call.arguments;
+    if (value) {
+        ctx.edits.push(replaced(call, value));
+        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`...`');
+    }
+    else {
+        ctx.unresolved.push(`${ctx.describe(call)}: expr.${helper}() is gone: declare the column with m.raw(...), or use a stamp on the entity`);
+        return;
+    }
+    ctx.rewritten.expr += 1;
+}
 /** Rewrites the `where` of the migration builder's `t.index()`, `t.unique()`, `t.addIndex()` and `m.createIndex()`. */
 function rewriteBuilderCall(call, ctx) {
     const at = ts.isPropertyAccessExpression(call.expression)
@@ -458,6 +489,31 @@ function rewriteBuilderCall(call, ctx) {
     const options = call.arguments[at];
     rewriteIndexWhere(options && ts.isObjectLiteralExpression(options) ? options : undefined, 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.
+ */
+function rewriteUpsertCall(call, ctx) {
+    const callee = call.expression;
+    const name = ts.isPropertyAccessExpression(callee) ? callee.name : callee;
+    const options = call.arguments[3];
+    const update = options && upsertUpdate(options);
+    if (ts.isIdentifier(name) && UPSERT_CALLS.has(name.text) && options && update) {
+        ctx.edits.push(replaced(options, update.getText()));
+    }
+}
+/** The value of options holding `update` alone, `{ update: value }` or `{ update }`. */
+function upsertUpdate(options) {
+    const [property] = ts.isObjectLiteralExpression(options) && options.properties.length === 1 ? options.properties : [];
+    if (property && ts.isPropertyAssignment(property) && propertyKey(property.name) === 'update') {
+        return property.initializer;
+    }
+    return property && ts.isShorthandPropertyAssignment(property) && property.name.text === 'update'
+        ? property.name
+        : undefined;
+}
 /**
  * `owner` is the declaring class's parameter and `target` the related one's, read off the `entity`
  * getter unless the caller knows it from the property's type.
@@ -556,13 +612,7 @@ function unwrapRelationAlias(node, ctx) {
         declared.typeName.text === 'Relation' &&
         declared.typeArguments?.length === 1) {
         ctx.edits.push(replaced(declared, declared.typeArguments[0].getText()));
-        ctx.relationAlias.unwrapped += 1;
-    }
-}
-/** Counts `Relation<T>` wherever it appears, including the places this codemod does not rewrite. */
-function countRelationAlias(node, ctx) {
-    if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && node.typeName.text === 'Relation') {
-        ctx.relationAlias.seen += 1;
+        ctx.rewritten.Relation += 1;
     }
 }
 /** Removes a statement together with the rest of its line, so nothing is left blank behind it. */
@@ -573,17 +623,25 @@ function removeStatement(node) {
     return { start: node.getStart(), end: nextLineStart ?? node.getEnd(), text: '' };
 }
 /**
- * Names `uql-orm` no longer exports and that the codemod does remove: only `Relation`, and only once
- * every usage was unwrapped. A removed *decorator* keeps its import on purpose (see
+ * Names `uql-orm` no longer exports and that the codemod does remove: `Relation` once every usage was
+ * unwrapped, and `expr` once every default was rewritten. A removed *decorator* keeps its import on purpose (see
  * {@link REMOVED_DECORATORS}).
  */
 function deadImportNames(source, ctx) {
-    const { seen, unwrapped } = ctx.relationAlias;
-    if (seen > unwrapped) {
-        ctx.unresolved.push(`${source.fileName}: ${seen - unwrapped} 'Relation<T>' reference(s) are somewhere this codemod does ` +
-            'not rewrite; unwrap them and drop the import by hand');
+    const imported = uqlImports(source, true);
+    // Every use of the name the file imports, the places no rewrite reaches included.
+    const uses = (name) => {
+        const element = imported.find((specifier) => importedName(specifier) === name);
+        return element ? usesOf(source, element.name, ctx.checker).length : 0;
+    };
+    const { rewritten } = ctx;
+    const relations = uses('Relation');
+    if (relations > rewritten.Relation) {
+        ctx.unresolved.push(`${source.fileName}: ${relations - rewritten.Relation} 'Relation<T>' reference(s) are somewhere this codemod ` +
+            'does not rewrite; unwrap them and drop the import by hand');
     }
-    return new Set(seen > 0 && seen === unwrapped ? ['Relation'] : []);
+    const names = ['Relation', 'expr'];
+    return new Set(names.filter((name) => rewritten[name] > 0 && rewritten[name] === uses(name)));
 }
 /**
  * Removes `import 'reflect-metadata'`, since the polyfill only ever fed `design:type`, and each `dead` name
@@ -1037,16 +1095,16 @@ export function transformFile(source, checker) {
         unresolved: [],
         notes: [],
         imports: new Map(),
-        relationAlias: { seen: 0, unwrapped: 0 },
+        rewritten: { Relation: 0, expr: 0 },
         describe: (node) => `${source.fileName}:${lineOf(node) + 1}`,
     };
     const lineOf = (node) => source.getLineAndCharacterOfPosition(node.getStart()).line;
     const rewritesRaw = uqlImports(source).some((element) => importedName(element) === 'raw');
     // The builder's methods are known by name alone, so they are read only in a file that imports uql-orm.
     const importsUql = uqlImportDeclarations(source, true).length > 0;
+    const importsExpr = uqlImports(source, true).some((element) => importedName(element) === 'expr');
     const visit = (node) => {
         reportRemovedDecorators(node, ctx);
-        countRelationAlias(node, ctx);
         if (rewritesRaw) {
             rewriteRawCall(node, ctx, source);
         }
@@ -1059,9 +1117,13 @@ export function transformFile(source, checker) {
         }
         if (ts.isCallExpression(node)) {
             rewriteDefineCall(node, ctx);
+            rewriteUpsertCall(node, ctx);
             if (importsUql) {
                 rewriteBuilderCall(node, ctx);
             }
+            if (importsExpr) {
+                rewriteExprCall(node, ctx);
+            }
         }
         if (ts.isPropertyAssignment(node)) {
             rewriteStatementKeys(node, ctx);

package/package.json

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