uql-codemod 0.26.0 → 0.28.0

package/README.md

@@ -14,11 +14,11 @@ npx uql-codemod --dry-run
 npx uql-codemod
 ```
 
-| Flag | |
-|---|---|
+| Flag               |                                                                                                                                                                                                                                                       |
+| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `--project=<path>` | `tsconfig.json` to read, defaulting to `./tsconfig.json`. It is a real program and not a parser, because the codemod writes down the types `design:type` used to report at runtime, so a config that covers your entities is what makes the run work. |
-| `--dry-run` | Report what would change and touch nothing. |
-| `--include=<a,b>` | Only files whose path contains one of these fragments. |
+| `--dry-run`        | Report what would change and touch nothing.                                                                                                                                                                                                           |
+| `--include=<a,b>`  | Only files whose path contains one of these fragments.                                                                                                                                                                                                |
 
 Only the `--flag=value` form is read, and anything unrecognised is an error: a misspelled `--dry-run` would otherwise rewrite the project for real. It exits `0` when nothing is left for you, `1` when something is, and `2` when it could not start at all - a bad argument, or a project it cannot read.
 
@@ -39,11 +39,11 @@ It reports rather than guesses, and exits non-zero when anything is left for you
 - **`@Log()`, `@Serialized()`, `@Transactional()` and `@InjectQuerier()`** are reported and left in place. They no longer exist, and what to do instead is a judgement call - a `@Transactional()` method becomes a `pool.transaction(async (querier) => { ... })` around its body, and the codemod cannot know which pool.
 - **Options it cannot read** (`@Field(sharedOptions)`, a spread, or a `@Field` never called at all) are left exactly as written. Replacing an argument it cannot parse would silently drop the options.
 - **A property whose type it cannot map to a column** (a `Json<T>`, a vector, a union that disagrees with itself) is reported as `needs a decision`. Those always had to declare `type` by hand anyway, because `design:type` reported the useless `Object`/`Array` for them.
-- **A branded string id**, e.g. `type UUID = \`${string}-${string}\``, gets `type: String` plus a `worth a look` note. That is a real fork: `String` generates a text column, `'uuid'` generates a native one, and only you know which the database has.
+- **A branded string id**, e.g. `type UUID = \`${string}-${string}\``, gets `type: String`plus a`worth a look`note. That is a real fork:`String`generates a text column,`'uuid'` generates a native one, and only you know which the database has.
 
 ## After it runs
 
-`tsc` is the rest of the migration, and that is the point: the annotations the codemod inserts are now *checked* against the properties they describe, so anything it got wrong is a compile error rather than a silently wrong column. See the [upgrade guide](https://uql-orm.dev/upgrade-guide).
+`tsc` is the rest of the migration, and that is the point: the annotations the codemod inserts are now _checked_ against the properties they describe, so anything it got wrong is a compile error rather than a silently wrong column. See the [upgrade guide](https://uql-orm.dev/upgrade-guide).
 
 ## Why TypeScript 6
 

package/dist/transform.js

@@ -14,6 +14,15 @@ const REMOVED_DECORATORS = new Map([
     ['Transactional', 'wrap the body in `pool.transaction(async (querier) => { ... })`'],
     ['InjectQuerier', 'take the querier from the enclosing `pool.transaction()` callback'],
 ]);
+/**
+ * Exports that no longer exist, mapped to what to do instead. Reported rather than rewritten, for the
+ * same reason as the decorators: which pool belongs at a given call site is a judgement call.
+ */
+const REMOVED_EXPORTS = new Map([
+    ['setQuerierPool', 'pass the pool where it is used: `createFetchHandler({ pool })`, `querierMiddleware({ pool })`'],
+    ['getQuerierPool', 'take the pool from the module that builds it, or from Nest DI'],
+    ['getQuerier', 'use `pool.withQuerier(...)` / `pool.transaction(...)`, which release the connection'],
+]);
 function decoratorName(node) {
     const call = ts.isCallExpression(node.expression) ? node.expression : undefined;
     const target = call?.expression ?? node.expression;
@@ -227,6 +236,65 @@ function reportRemovedDecorators(node, ctx) {
         }
     }
 }
+/** Names an export that no longer exists, where it is imported from the package. */
+function reportRemovedExports(node, ctx) {
+    if (!ts.isImportDeclaration(node) || !ts.isStringLiteral(node.moduleSpecifier)) {
+        return;
+    }
+    if (node.moduleSpecifier.text !== 'uql-orm') {
+        return;
+    }
+    const bindings = node.importClause?.namedBindings;
+    if (!bindings || !ts.isNamedImports(bindings)) {
+        return;
+    }
+    for (const element of bindings.elements) {
+        const name = (element.propertyName ?? element.name).text;
+        const advice = REMOVED_EXPORTS.get(name);
+        if (advice) {
+            ctx.unresolved.push(`${ctx.describe(element)}: '${name}' was removed; ${advice}`);
+        }
+    }
+}
+/** Whether this file's `raw` is the ORM's, so another library's function of that name is left alone. */
+function importsRaw(source) {
+    return source.statements.some((statement) => {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) {
+            return false;
+        }
+        if (statement.moduleSpecifier.text !== 'uql-orm') {
+            return false;
+        }
+        const bindings = statement.importClause?.namedBindings;
+        return (!!bindings &&
+            ts.isNamedImports(bindings) &&
+            bindings.elements.some((element) => (element.propertyName ?? element.name).text === 'raw'));
+    });
+}
+/**
+ * Rewrites `raw('sql')` into the tagged template, and a second alias argument into `.as()`. Only a
+ * string-literal first argument qualifies: the callback form is unchanged, and a computed string is
+ * left alone because a template cannot be built from a value that is not known here.
+ */
+function rewriteRawCall(node, ctx, source) {
+    if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression) || node.expression.text !== 'raw') {
+        return;
+    }
+    const [expression, alias] = node.arguments;
+    if (!expression || !ts.isStringLiteral(expression) || node.arguments.length > 2) {
+        return;
+    }
+    const suffix = alias ? `.as(${alias.getText(source)})` : '';
+    ctx.edits.push({
+        start: node.getStart(source),
+        end: node.getEnd(),
+        text: `raw\`${escapeForTemplate(expression.text)}\`${suffix}`,
+    });
+}
+/** A backtick or a `${` inside the old string literal would end or interpolate the template. */
+function escapeForTemplate(text) {
+    return text.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+}
 /** Rewrites one source file for the standard decorator spec. */
 export function transformFile(source, checker) {
     const ctx = {
@@ -238,9 +306,14 @@ export function transformFile(source, checker) {
         describe: (node) => `${source.fileName}:${lineOf(node) + 1}`,
     };
     const lineOf = (node) => source.getLineAndCharacterOfPosition(node.getStart()).line;
+    const rewritesRaw = importsRaw(source);
     const visit = (node) => {
         reportRemovedDecorators(node, ctx);
+        reportRemovedExports(node, ctx);
         countRelationAlias(node, ctx);
+        if (rewritesRaw) {
+            rewriteRawCall(node, ctx, source);
+        }
         if (ts.isPropertyDeclaration(node)) {
             rewriteProperty(node, ctx);
         }

package/package.json

@@ -2,7 +2,7 @@
   "name": "uql-codemod",
   "description": "Migrates uql-orm entities from legacy decorators to the TC39 standard spec",
   "license": "MIT",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "type": "module",
   "engines": {
     "node": ">=24"