uql-codemod 0.39.1 → 0.40.0

package/README.md

@@ -32,7 +32,7 @@ Only `--flag=value` is read, and anything unrecognised is an error. It exits `0`
 - A partial-index `where` string to `raw`, importing it, on entities and in the migration builder.
 - `col('cost')` to the ref it names, ``(product) => raw`${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.
 - 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: `QueryWhereMap` to `QueryWhere`, `RelationKeyMap` to `KeyMap`, `FilterCondition` to `FilterWhere`, `SqlMigrationModuleOptions` to `MigrationModuleOptions`, `buildSqlQuerierMigrationModule` to `buildMigrationModule`, `QueryDialect` to `SqlQueryDialect`, `EngineFeatures` to `DialectFeatures`, `KnownMigratorDialect` to `DialectName` and `D1Preparer` to `D1Database`, 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`, moving the import to the entry that exports it.
+- Renamed exports, at the import and every use: `QueryWhereMap` to `QueryWhere`, `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`, moving the import to the entry that exports it.
 - The `[idKey]?: '...'` brand, and its import, on a key not called `id`, `_id` or `uuid` and on every composite.
 - `import 'reflect-metadata'`, and `experimentalDecorators`/`emitDecoratorMetadata` in `tsconfig.json`, comments and formatting kept.
 

package/dist/transform.js

@@ -81,7 +81,8 @@ const RENAMED_EXPORTS = new Map([
     ['QueryDialect', { to: 'SqlQueryDialect' }],
     ['EngineFeatures', { to: 'DialectFeatures' }],
     ['KnownMigratorDialect', { to: 'DialectName', from: 'uql-orm' }],
-    ['D1Preparer', { to: 'D1Database' }],
+    ['D1Preparer', { to: 'D1Queryable' }],
+    ['D1Database', { to: 'D1Queryable', from: 'uql-orm/d1' }],
 ]);
 /** A node's decorators, or none where it is a kind that cannot carry them. */
 function decoratorsOf(node) {
@@ -284,7 +285,8 @@ function foreignKeyColumn(property, column, relation, checker) {
     }
     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}`);
+    // `| null`, as on every column the codemod touches: a foreign key holds one like any other.
+    return inserted(property, `@Field({ references: () => ${target} }) ${column}?: ${type} | null;\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, checker) {
@@ -376,6 +378,7 @@ function rewriteEntityOptions(options, owner, ctx) {
     }
     for (const field of objectProperties(fields)) {
         renameSqlOption(optionsOf(field.initializer), 'virtual', 'computed', field, owner, ctx);
+        admitNullOnDefined(field, owner, ctx);
     }
     for (const filter of objectProperties(propertyValue(options, 'filters'))) {
         renameOption(optionsOf(filter.initializer), 'condition', 'where', filter, ctx);
@@ -668,6 +671,9 @@ function rewriteProperty(node, ctx) {
         }
         const options = decoratorOptions(decorator);
         if (FIELD_DECORATORS.has(name)) {
+            if (name === 'Field') {
+                admitNull(options, node, ctx);
+            }
             addFieldType(decorator, node, ctx);
             // Options it cannot read may still hold `virtual`, so they are reported where they mention it.
             if (options.kind === 'opaque' && /\bvirtual\b/.test(decorator.getText())) {
@@ -691,6 +697,64 @@ function rewriteProperty(node, ctx) {
     }
     unwrapRelationAlias(node, ctx);
 }
+/**
+ * A column holds `null` unless `nullable: false` says otherwise, and a read hydrates one, so the property
+ * says so too. A key is NOT NULL on every engine, and a relation aggregate is typed by the aggregate,
+ * which declares its own `null` or none, so neither is touched.
+ */
+function admitNull(options, node, ctx) {
+    // Options it cannot read may state `nullable` themselves, and appending to the property would then
+    // contradict the column. `addFieldType` already reports the same options, so this adds no second note.
+    if (options.kind === 'opaque') {
+        return;
+    }
+    if (declaresNotNull(options) ||
+        findProperty(options, 'isId') ||
+        (findProperty(options, 'computed') && !findProperty(options, 'type'))) {
+        return;
+    }
+    if (!node.type) {
+        ctx.notes.push(`${ctx.describe(node)}: declare '${propertyKey(node.name)}' as a type that admits 'null', which the column holds`);
+        return;
+    }
+    if (admitsNull(node.type)) {
+        return;
+    }
+    ctx.edits.push(appended(node.type, ' | null'));
+}
+/**
+ * The same null rule where `defineEntity` names the field: the property is on the class the call takes,
+ * so the declaration is found there rather than under a decorator.
+ */
+function admitNullOnDefined(field, owner, ctx) {
+    if (!ts.isPropertyAssignment(field)) {
+        return;
+    }
+    const key = propertyKey(field.name);
+    const declaration = key
+        ? instanceTypeOf(owner.entity, ctx.checker)
+            .getProperty(key)
+            ?.declarations?.find((it) => ts.isPropertyDeclaration(it))
+        : undefined;
+    if (declaration?.type) {
+        admitNull(optionsOf(field.initializer), declaration, ctx);
+    }
+}
+/** Whether the options say the column refuses `null`; `nullable: true` is the default said out loud. */
+function declaresNotNull(options) {
+    const nullable = findProperty(options, 'nullable');
+    return !!nullable && ts.isPropertyAssignment(nullable) && nullable.initializer.kind === ts.SyntaxKind.FalseKeyword;
+}
+/**
+ * Whether a written type already admits `null`, wherever it sits in the union. In a type position `null`
+ * parses as a literal type rather than a keyword, which is why the kind is read off `literal`.
+ */
+function admitsNull(type) {
+    if (ts.isLiteralTypeNode(type)) {
+        return type.literal.kind === ts.SyntaxKind.NullKeyword;
+    }
+    return ts.isUnionTypeNode(type) && type.types.some(admitsNull);
+}
 /** Names a decorator that no longer exists, wherever it appears. */
 function reportRemovedDecorators(node, ctx) {
     for (const decorator of decoratorsOf(node)) {

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.1",
+  "version": "0.40.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -32,7 +32,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rogerpadilla/uql.git",
-    "directory": "packages/uql-codemod"
+    "directory": "packages/codemod"
   },
   "keywords": [
     "uql",