uql-codemod 0.39.0 → 0.39.1

package/README.md

@@ -45,7 +45,7 @@ Reported with what to do, never guessed:
 - An export removed with no one-to-one replacement (`setQuerierPool`, `getQuerier`, `augmentWhere`, `AbstractPgQuerier`, ...).
 - A value it cannot read: options passed as a variable or a spread, a list that is not a literal, a key under a computed name.
 - A to-one onto a composite key: declare a column per key and pair each with it in `references`.
-- A to-one in `defineEntity`/`defineRelation` whose entity has no foreign key column: declare it with `defineField`.
+- A to-one whose `<relation>Id` is not a declared column: an undecorated property, a `defineEntity` whose `fields` leave it out, or a `defineRelation` whose entity has no such member.
 - A partial-index `where` string that interpolates, since `raw` would bind what the template spliced in.
 - A `col()` whose entity it cannot tell: a raw built apart from its query, one under a relation filter, or a column no field maps.
 - SQL in a definition that names a column by hand, as a note: a rename reaches a callback's refs, ``(user) => raw`lower(${user.email})` ``, and never the text.

package/dist/transform.js

@@ -157,8 +157,12 @@ function noteHandNamedColumns(sql, owner, ctx) {
 }
 /** The names of the members of the entity `node` declares or names. */
 function memberNames(node, checker) {
+    return propertyNames(instanceTypeOf(node, checker));
+}
+/** The instance type of the entity `node` declares or names. */
+function instanceTypeOf(node, checker) {
     const type = checker.getTypeAtLocation(node);
-    return propertyNames(type.getConstructSignatures()[0]?.getReturnType() ?? type);
+    return type.getConstructSignatures()[0]?.getReturnType() ?? type;
 }
 function propertyNames(type) {
     return new Set(type.getProperties().map(({ name }) => name));
@@ -228,11 +232,11 @@ function addRelationEntity(decorator, node, ctx) {
     });
 }
 /**
- * Names the foreign key a to-one found by name alone, `references: (post) => post.authorId` beside `author`.
- * A key the entity neither declares nor inherits is declared first, on a decorated property, typed as the
- * target's key; elsewhere it is reported.
+ * Names the foreign key a to-one used to find by name, `references: (post) => post.authorId` beside `author`.
+ * `site` says where the entity declares its columns: the decorated property, ahead of which a missing column
+ * is declared, or `defineEntity`'s `fields`. A column it cannot see declared is reported instead.
  */
-function addForeignKeyReference(relation, key, owner, ctx, property) {
+function addForeignKeyReference(relation, key, owner, ctx, site) {
     const options = { kind: 'literal', node: relation };
     const cardinality = propertyValue(relation, 'cardinality');
     const toOne = !cardinality || (ts.isStringLiteralLike(cardinality) && TO_ONE_CARDINALITIES.has(cardinality.text));
@@ -242,49 +246,58 @@ function addForeignKeyReference(relation, key, owner, ctx, property) {
         return;
     }
     const column = `${key}Id`;
-    if (!memberNames(owner.entity, ctx.checker).has(column)) {
-        if (!property) {
-            ctx.unresolved.push(`${ctx.describe(relation)}: declare the foreign key column '${column}' and name it in 'references'`);
-            return;
-        }
-        const declared = foreignKeyColumn(property, column, relation, ctx);
-        if (!declared) {
-            return;
-        }
-        ctx.edits.push(declared);
+    const declaration = columnDeclaration(column, relation, owner, ctx.checker, site);
+    if (typeof declaration === 'string') {
+        ctx.unresolved.push(`${ctx.describe(site && ts.isPropertyDeclaration(site) ? site : relation)}: ${declaration}`);
+        return;
+    }
+    if (declaration) {
+        ctx.edits.push(declaration);
+        ctx.imports.set('Field', 'the foreign key column');
     }
     ctx.edits.push(appended(last, `, references: (${owner.param}) => ${memberAccess(owner.param, column)}`));
 }
+const undeclaredColumn = (column) => `declare the foreign key column '${column}' and name it in 'references'`;
+/** Nothing where `column` is declared, the declaration to write where a decorated class lacks it, or why neither. */
+function columnDeclaration(column, relation, owner, checker, site) {
+    const member = instanceTypeOf(owner.entity, checker).getProperty(column);
+    if (site && ts.isPropertyDeclaration(site)) {
+        if (!member) {
+            return foreignKeyColumn(site, column, relation, checker);
+        }
+        return member.declarations?.some(isFieldProperty) ? undefined : undeclaredColumn(column);
+    }
+    const declared = site ? objectProperties(site).some(({ name }) => propertyKey(name) === column) : member;
+    return declared ? undefined : undeclaredColumn(column);
+}
 /** `@Field({ references: () => Target }) <column>?: <key type>;` ahead of the relation, or why it cannot be written. */
-function foreignKeyColumn(property, column, relation, ctx) {
-    const { checker } = ctx;
+function foreignKeyColumn(property, column, relation, checker) {
     const targetType = checker.getNonNullableType(checker.getTypeAtLocation(property));
     const target = entityGetterTarget(relation) ?? relationTargetFor(targetType, checker);
     const keys = targetType.getProperties().filter((member) => member.declarations?.some(isIdProperty));
-    const [soleKey] = keys;
-    if (!target || !soleKey || keys.length > 1) {
-        const advice = keys.length > 1
-            ? `'${target}' has a composite key: declare a column per key and pair each in 'references'`
-            : `declare the foreign key column '${column}' and name it in 'references'`;
-        ctx.unresolved.push(`${ctx.describe(property)}: ${advice}`);
-        return undefined;
+    if (keys.length > 1) {
+        return `'${target}' has a composite key: declare a column per key and pair each in 'references'`;
+    }
+    const [key] = keys;
+    if (!target || !key) {
+        return undeclaredColumn(column);
     }
-    const source = property.getSourceFile();
-    const indent = ' '.repeat(source.getLineAndCharacterOfPosition(property.getStart()).character);
-    ctx.imports.set('Field', 'the foreign key column');
-    return inserted(property, `@Field({ references: () => ${target} }) ${column}?: ${keyTypeSource(soleKey, property, ctx)};\n${indent}`);
+    const indent = ' '.repeat(property.getSourceFile().getLineAndCharacterOfPosition(property.getStart()).character);
+    const type = keyTypeSource(key, property, checker);
+    return inserted(property, `@Field({ references: () => ${target} }) ${column}?: ${type};\n${indent}`);
 }
 /** The key's type as written where that is in scope, the same file, or as the checker spells it out. */
-function keyTypeSource(key, at, ctx) {
+function keyTypeSource(key, at, checker) {
     const written = key.declarations?.find(isIdProperty)?.type;
     if (written && written.getSourceFile() === at.getSourceFile()) {
         return written.getText();
     }
-    return ctx.checker.typeToString(ctx.checker.getNonNullableType(ctx.checker.getTypeOfSymbolAtLocation(key, at)), at);
-}
-function isIdProperty(node) {
-    return ts.isPropertyDeclaration(node) && decoratorsOf(node).some((decorator) => decoratorName(decorator) === 'Id');
+    return checker.typeToString(checker.getNonNullableType(checker.getTypeOfSymbolAtLocation(key, at)), at);
 }
+/** Whether a declaration is a property carrying one of `names` as a decorator. */
+const decoratedWith = (names) => (node) => ts.isPropertyDeclaration(node) && decoratorsOf(node).some((decorator) => names.has(decoratorName(decorator) ?? ''));
+const isIdProperty = decoratedWith(new Set(['Id']));
+const isFieldProperty = decoratedWith(FIELD_DECORATORS);
 /**
  * Writes the edits `rewrite` reads off `value`, which still names members as strings, or reports it
  * where it could not be read: what it holds is only known at runtime. A callback or an object literal
@@ -352,6 +365,7 @@ function rewriteDefineCall(call, ctx) {
     }
 }
 function rewriteEntityOptions(options, owner, ctx) {
+    const fields = propertyValue(options, 'fields');
     for (const index of arrayElements(propertyValue(options, 'indexes'))) {
         if (ts.isObjectLiteralExpression(index)) {
             rewriteIndexOptions(index, owner, ctx);
@@ -360,7 +374,7 @@ function rewriteEntityOptions(options, owner, ctx) {
     for (const check of arrayElements(propertyValue(options, 'checks'))) {
         renameSqlOption(optionsOf(check), 'expression', 'where', check, owner, ctx);
     }
-    for (const field of objectProperties(propertyValue(options, 'fields'))) {
+    for (const field of objectProperties(fields)) {
         renameSqlOption(optionsOf(field.initializer), 'virtual', 'computed', field, owner, ctx);
     }
     for (const filter of objectProperties(propertyValue(options, 'filters'))) {
@@ -369,10 +383,11 @@ function rewriteEntityOptions(options, owner, ctx) {
     for (const hook of objectProperties(propertyValue(options, 'hooks'))) {
         rewriteKeyList(hook.initializer, owner.param, hook, 'a hook list', ctx);
     }
+    const declared = fields && ts.isObjectLiteralExpression(fields) ? fields : undefined;
     for (const relation of objectProperties(propertyValue(options, 'relations'))) {
         if (ts.isObjectLiteralExpression(relation.initializer)) {
             rewriteRelationOptions(relation.initializer, owner.param, ctx);
-            addForeignKeyReference(relation.initializer, propertyKey(relation.name), owner, ctx);
+            addForeignKeyReference(relation.initializer, propertyKey(relation.name), owner, ctx, declared);
         }
     }
 }
@@ -605,7 +620,7 @@ function isIdKeyBrand(member) {
  * One written makes `idKey` a value the file has to import, which is recorded for {@link addImports}.
  */
 function brandIdKey(node, ctx) {
-    const ids = node.members.filter((m) => ts.isPropertyDeclaration(m) && decoratorsOf(m).some((d) => decoratorName(d) === 'Id'));
+    const ids = node.members.filter(isIdProperty);
     if (!ids.length || node.members.some(isIdKeyBrand)) {
         return;
     }
@@ -666,9 +681,9 @@ function rewriteProperty(node, ctx) {
         if (RELATION_DECORATORS.has(name) && options.kind === 'literal') {
             const target = relationTargetFor(ctx.checker.getTypeAtLocation(node), ctx.checker);
             rewriteRelationOptions(options.node, owner.param, ctx, paramFor(target));
-        }
-        if (TO_ONE_DECORATORS.has(name) && options.kind === 'literal') {
-            addForeignKeyReference(options.node, propertyKey(node.name), owner, ctx, node);
+            if (TO_ONE_DECORATORS.has(name)) {
+                addForeignKeyReference(options.node, propertyKey(node.name), owner, ctx, node);
+            }
         }
     }
     if (decorators.length) {
@@ -969,9 +984,9 @@ export function transformFile(source, checker) {
         }
         if (ts.isCallExpression(node)) {
             rewriteDefineCall(node, ctx);
-        }
-        if (importsUql && ts.isCallExpression(node)) {
-            rewriteBuilderCall(node, ctx);
+            if (importsUql) {
+                rewriteBuilderCall(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.39.0",
+  "version": "0.39.1",
   "type": "module",
   "engines": {
     "node": ">=24"