uql-codemod 0.28.0 → 0.30.0

package/README.md

@@ -27,6 +27,7 @@ Only the `--flag=value` form is read, and anything unrecognised is an error: a m
 - `@Field()` and `@Field({ ... })` with no `type`, and `@Id()`: inserts the `type` the property's declared TypeScript type implies. Skipped when `references` is present, because schema generation resolves that column from the referenced primary key.
 - Bare relation decorators: inserts `entity: () => X`, unwrapping arrays and the old `Relation<T>` alias.
 - `Relation<T>` becomes `T`, and its import goes with the last usage - `uql-orm` no longer exports it. A usage somewhere the codemod does not reach, such as a type alias, keeps the import and is reported.
+- `@Field({ virtual })` becomes `@Field({ computed })`, the name it was renamed to - written as a plain key, a quoted one, or a shorthand, which becomes `computed: virtual` so it keeps referring to the same local. A decorator given both names is reported instead, because which one wins is your call.
 - `import 'reflect-metadata'` goes. Removing the package from your `package.json` is left to you.
 - `tsconfig.json`: removes `experimentalDecorators` and `emitDecoratorMetadata`, keeping the rest of the file - comments and formatting included - exactly as written.
 

package/dist/transform.js

@@ -45,9 +45,45 @@ function decoratorOptions(node) {
         ? { kind: 'opaque', reason: 'its options object spreads another' }
         : { kind: 'literal', node: first };
 }
-function hasProperty(options, name) {
-    return (options.kind === 'literal' &&
-        options.node.properties.some((prop) => prop.name && ts.isIdentifier(prop.name) && prop.name.text === name));
+/**
+ * The property `name` in the decorator's options, whether its key is plain, quoted or a shorthand.
+ *
+ * All three forms, because both callers care about the option being *there*: one to leave an option
+ * alone that is already stated, the other to rename it. Matching only the plain key inserted a second
+ * `type` beside a quoted one, and left a shorthand `virtual` behind while reporting nothing.
+ */
+function findProperty(options, name) {
+    if (options.kind !== 'literal') {
+        return undefined;
+    }
+    return options.node.properties.find((prop) => (ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop)) && propertyKey(prop.name) === name);
+}
+/** A key's name where it is spelled out, which is every form but a computed one (`{ [k]: v }`). */
+function propertyKey(name) {
+    return ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : undefined;
+}
+/**
+ * Renames the `virtual` option to `computed`, the one it was renamed to.
+ *
+ * Only the key is replaced, so the expression, its formatting and any comment inside the options
+ * object survive untouched. A shorthand has no value to keep, so it becomes `computed: virtual` -
+ * renaming the key alone would rebind it to a local that does not exist.
+ */
+function renameVirtualOption(decorator, ctx, node) {
+    const options = decoratorOptions(decorator);
+    const virtual = findProperty(options, 'virtual');
+    if (!virtual) {
+        if (options.kind === 'opaque' && /\bvirtual\b/.test(decorator.getText())) {
+            ctx.unresolved.push(`${ctx.describe(node)}: ${options.reason}`);
+        }
+        return;
+    }
+    if (findProperty(options, 'computed')) {
+        ctx.unresolved.push(`${ctx.describe(node)}: gives both 'virtual' and 'computed'; keep 'computed'.`);
+        return;
+    }
+    const text = ts.isShorthandPropertyAssignment(virtual) ? 'computed: virtual' : 'computed';
+    ctx.edits.push({ start: virtual.name.getStart(), end: virtual.name.getEnd(), text });
 }
 /** Inserts `option` into the decorator's options object, creating one when the call has no arguments. */
 function insertOption(options, option) {
@@ -70,7 +106,7 @@ function insertOption(options, option) {
  */
 function addInferredOption(decorator, node, ctx, spec) {
     const options = decoratorOptions(decorator);
-    if (spec.satisfiedBy.some((name) => hasProperty(options, name))) {
+    if (spec.satisfiedBy.some((name) => findProperty(options, name))) {
         return undefined;
     }
     if (options.kind === 'opaque') {
@@ -213,6 +249,7 @@ function rewriteProperty(node, ctx) {
         }
         if (FIELD_DECORATORS.has(name)) {
             addFieldType(decorator, node, ctx);
+            renameVirtualOption(decorator, ctx, node);
         }
         if (RELATION_DECORATORS.has(name)) {
             addRelationEntity(decorator, node, ctx);

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "uql-codemod",
-  "description": "Migrates uql-orm entities from legacy decorators to the TC39 standard spec",
+  "description": "Upgrade uql-orm across versions that introduce breaking changes",
   "license": "MIT",
-  "version": "0.28.0",
+  "version": "0.30.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -21,6 +21,7 @@
     "README.md"
   ],
   "scripts": {
+    "prepack": "bun run build",
     "build": "rimraf dist .tsconfig.tsbuildinfo && tsc -b tsconfig.build.json",
     "clean": "rimraf dist .tsconfig.tsbuildinfo"
   },