uql-codemod 0.36.0 → 0.37.0

package/README.md

@@ -27,11 +27,11 @@ Only `--flag=value` is read, and anything unrecognised is an error. It exits `0`
 - `type` on a `@Field`/`@Id` that has none, from the property's declared type; not beside `references`, whose column comes from the key it points at.
 - `entity: () => X` on a bare relation decorator, and `Relation<T>` to `T`, its import going with the last use.
 - `virtual` to `computed` (on `@Field` and in `defineEntity`'s `fields`), a check's `expression` and a filter's `condition` to `where` (`@Entity`/`defineEntity`, `@Filter`, `defineFilter`), `raw('sql')` to the tagged template, and a `raw` alias argument onto `.as()`.
-- Members named by string to key-map callbacks: `mappedBy: 'author'` to `(post) => post.author`, and `@Index`, `include`, `references` and `@Entity`/`defineEntity`'s `indexes` and `hooks` likewise: `@Index((post) => [post.title])`.
-- An index expression to the callback an index takes, as an entry or a `column`: ``raw`lower("email")` `` to ``() => raw`lower("email")` ``, and a partial-index `where` string to `raw`, importing it; on entities and in the migration builder.
+- Members named by string to callbacks: `mappedBy: 'author'` to `(post) => post.author`, and `@Index`, `include`, `references` and `@Entity`/`defineEntity`'s `indexes` and `hooks` likewise: `@Index((post) => [post.title])`.
+- 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`, and the removed driver classes to the one each extended: `PgDialect`/`NeonDialect`/`PgliteDialect` to `PostgresDialect`, `CrdbQuerier`/`NeonQuerier` to `PgQuerier`, `LibsqlQuerier`/`TursoQuerier` to `HranaQuerier`, `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` and `buildSqlQuerierMigrationModule` to `buildMigrationModule`, 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/entitySql.d.ts

@@ -3,12 +3,6 @@ import { type Edit } from './edits.js';
 /** `raw\`...\`` or `raw(...)`. */
 type RawSql = ts.TaggedTemplateExpression | ts.CallExpression;
 export declare function isRaw(node: ts.Node): node is RawSql;
-/**
- * `() => ` before each expression a column list indexes, which an index takes as a callback now. One that
- * interpolates takes the list callback's parameter as its refs: `(user) => [raw\`lower(${user.email})\`]`
- * spliced in the key `'email'`, where the ref it reads now renders the column.
- */
-export declare function expressionEntryEdits(list: ts.Expression | undefined): readonly Edit[];
 /** The expressions of a column list, written as one or returned by its callback: each entry or `column` that is `raw`. */
 export declare function columnExpressions(list: ts.Expression | undefined): readonly RawSql[];
 /** SQL text as a `raw` tagged template, escaping what would end or interpolate it. */

package/dist/entitySql.js

@@ -9,16 +9,6 @@ export function isRaw(node) {
             : undefined;
     return callee !== undefined && ts.isIdentifier(callee) && callee.text === 'raw';
 }
-/**
- * `() => ` before each expression a column list indexes, which an index takes as a callback now. One that
- * interpolates takes the list callback's parameter as its refs: `(user) => [raw\`lower(${user.email})\`]`
- * spliced in the key `'email'`, where the ref it reads now renders the column.
- */
-export function expressionEntryEdits(list) {
-    const param = list && ts.isArrowFunction(list) ? list.parameters[0]?.name : undefined;
-    const refs = param && ts.isIdentifier(param) ? param.text : '';
-    return columnExpressions(list).map((sql) => inserted(sql, `(${interpolates(sql) ? refs : ''}) => `));
-}
 /** The expressions of a column list, written as one or returned by its callback: each entry or `column` that is `raw`. */
 export function columnExpressions(list) {
     const body = list && ts.isArrowFunction(list) ? list.body : list;
@@ -28,9 +18,6 @@ export function columnExpressions(list) {
         return sql && isRaw(sql) ? [sql] : [];
     });
 }
-function interpolates(sql) {
-    return ts.isTaggedTemplateExpression(sql) && ts.isTemplateExpression(sql.template);
-}
 /** SQL text as a `raw` tagged template, escaping what would end or interpolate it. */
 export function rawTag(sql) {
     return `raw\`${sql.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${')}\``;

package/dist/keyMaps.d.ts

@@ -4,6 +4,8 @@ import { type Edit } from './edits.js';
 export type Edits = readonly Edit[] | undefined;
 /** A callback's parameter, named after the class it reads: `Post` -> `post`. */
 export declare function paramFor(className: string | undefined): string;
+/** `text` as a single-quoted string literal, escaping what would end it. */
+export declare function quoted(text: string): string;
 /** `post.title`, or `post['first-name']` for a key that is no identifier. */
 export declare function memberAccess(param: string, key: string): string;
 /** A key's name where it is spelled out, which is every form but a computed one (`{ [k]: v }`). */

package/dist/keyMaps.js

@@ -7,9 +7,13 @@ export function paramFor(className) {
 function isIdentifierName(key) {
     return /^[\p{ID_Start}$_][\p{ID_Continue}$\u200C\u200D]*$/u.test(key);
 }
+/** `text` as a single-quoted string literal, escaping what would end it. */
+export function quoted(text) {
+    return `'${text.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
 /** `post.title`, or `post['first-name']` for a key that is no identifier. */
 export function memberAccess(param, key) {
-    return isIdentifierName(key) ? `${param}.${key}` : `${param}['${key}']`;
+    return isIdentifierName(key) ? `${param}.${key}` : `${param}[${quoted(key)}]`;
 }
 /** A key's name where it is spelled out, which is every form but a computed one (`{ [k]: v }`). */
 export function propertyKey(name) {
@@ -26,7 +30,7 @@ export function fieldKeysEdits(value) {
     if (!names.every((name) => ts.isStringLiteralLike(name))) {
         return undefined;
     }
-    const keys = names.map(({ text }) => `${isIdentifierName(text) ? text : `'${text}'`}: true`);
+    const keys = names.map(({ text }) => `${isIdentifierName(text) ? text : quoted(text)}: true`);
     return [replaced(value, `{ ${keys.join(', ')} }`)];
 }
 /** Whether `value` is already a function, the form every rewrite here produces. */
@@ -61,7 +65,7 @@ export function entityGetterTarget(relation) {
     const getter = propertyValue(relation, 'entity');
     return getter && ts.isArrowFunction(getter) && ts.isIdentifier(getter.body) ? getter.body.text : undefined;
 }
-/** A column-list entry, its name read off the key map: an expression, or a `column` given otherwise, has none. */
+/** A column-list entry, its name read off the refs: an expression, or a `column` given otherwise, has none. */
 function keyListEntryEdits(entry, param) {
     if (ts.isStringLiteralLike(entry)) {
         return [replaced(entry, memberAccess(param, entry.text))];

package/dist/transform.js

@@ -1,8 +1,8 @@
 import ts from 'typescript';
 import { applyEdits, inserted, removeFromList, replaced } from './edits.js';
-import { columnExpressions, expressionEntryEdits, handNamedColumns, isRaw, rawTag, rawWhereEdit } from './entitySql.js';
+import { columnExpressions, handNamedColumns, isRaw, rawTag, rawWhereEdit } from './entitySql.js';
 import { fieldTypeFor, isBrandedString, relationTargetFor } from './fieldType.js';
-import { entityGetterTarget, fieldKeysEdits, isCallback, keyListEdits, mappedByEdits, memberAccess, paramFor, propertyKey, propertyValue, referencesEdits, } from './keyMaps.js';
+import { entityGetterTarget, fieldKeysEdits, isCallback, keyListEdits, mappedByEdits, memberAccess, paramFor, propertyKey, propertyValue, quoted, referencesEdits, } from './keyMaps.js';
 const FIELD_DECORATORS = new Set(['Field', 'Id']);
 const RELATION_DECORATORS = new Set(['OneToOne', 'ManyToOne', 'OneToMany', 'ManyToMany']);
 /**
@@ -31,6 +31,18 @@ const REMOVED_EXPORTS = new Map([
     ['augmentWhere', 'spread the two maps: `{ ...where, ...extra }`'],
     ['buildQueryWhereAsMap', 'a `$where` is a map already; name the key for ids: `{ id: [1, 2] }`'],
     ['AbstractPgQuerier', 'every pg-compatible pool returns `PgQuerier` (`uql-orm/postgres`), which is concrete'],
+    ['AbstractHranaQuerierPool', 'extend `AbstractSqlQuerierPool` and hand every querier a `HranaQuerier`'],
+    [
+        'PreparedSqliteQuerier',
+        'use `SqliteQuerier`, which takes any driver that prepares, or extend `AbstractSqliteQuerier`',
+    ],
+    ['toSqliteBindValues', 'pass the values as they are: every SQLite driver binds a `SqliteBindValue[]`'],
+    ['libsqlUseRemoteForMigrations', '`LibsqlQuerierPool.getMigrationQuerier()` decides it'],
+    ['SqlCallback', 'use `EntitySql<E>`, which holds the callback form'],
+    [
+        'IndexColumnOptions',
+        "an entity's index entry is `EntityIndexColumnInput<E>`, the migration builder's `IndexColumnInput`",
+    ],
 ]);
 /**
  * Exports renamed and nothing else - the driver classes were empty subclasses - so the import and every
@@ -49,6 +61,10 @@ const RENAMED_EXPORTS = new Map([
     ['MongodbNativeDialect', { to: 'MongoDialect', from: 'uql-orm/mongo' }],
     ['LibsqlQuerier', { to: 'HranaQuerier', from: 'uql-orm/sqlite' }],
     ['TursoQuerier', { to: 'HranaQuerier', from: 'uql-orm/sqlite' }],
+    ['TursoLocalQuerier', { to: 'SqliteQuerier', from: 'uql-orm/sqlite' }],
+    ['TursoDatabase', { to: 'SqliteDatabase', from: 'uql-orm/sqlite' }],
+    ['SqlMigrationModuleOptions', { to: 'MigrationModuleOptions' }],
+    ['buildSqlQuerierMigrationModule', { to: 'buildMigrationModule' }],
 ]);
 /** A node's decorators, or none where it is a kind that cannot carry them. */
 function decoratorsOf(node) {
@@ -212,11 +228,11 @@ function rewriteValue(value, rewrite, node, advice, ctx) {
     }
 }
 function rewriteKeyList(value, param, node, what, ctx) {
-    rewriteValue(value, (list) => keyListEdits(list, param), node, `write ${what} as a key-map callback`, ctx);
+    rewriteValue(value, (list) => keyListEdits(list, param), node, `write ${what} as a callback`, ctx);
 }
 /**
  * Rewrites a class's decorators - `@Index`, `@Filter` and `@Entity`'s options - for what they define now:
- * members named by string read off key maps named after the class, and SQL written as it is taken.
+ * members named by string read off a callback's parameter named after the class, and SQL written as it is taken.
  */
 function rewriteClassDecorators(node, ctx) {
     const owner = { param: paramFor(node.name?.text), entity: node };
@@ -288,23 +304,22 @@ function rewriteIndexOptions(index, owner, ctx) {
 }
 /**
  * An index, as `@Index(columns, options)` or a `defineIndex`/`indexes` entry holding both: its columns and
- * `include` read off the key map, its SQL written as {@link rewriteIndexSql} writes it, and noted.
+ * `include` read off the entity's refs, its `where` written as {@link rewriteIndexWhere} writes it, its SQL noted.
  */
 function rewriteIndex(columns, options, owner, node, what, ctx) {
     const literal = options && ts.isObjectLiteralExpression(options) ? options : undefined;
     rewriteKeyList(columns, owner.param, node, what, ctx);
     rewriteKeyList(literal && propertyValue(literal, 'include'), owner.param, node, "'include'", ctx);
-    rewriteIndexSql(columns, literal, ctx);
+    rewriteIndexWhere(literal, ctx);
     for (const sql of [...columnExpressions(columns), literal && propertyValue(literal, 'where')]) {
         noteHandNamedColumns(sql, owner, ctx);
     }
 }
 /**
- * An index's SQL as an index takes it now, on an entity and in the migration builder alike: each expression
- * a callback, and a `where` string `raw`. A string it cannot write as `raw` is reported.
+ * A partial-index `where` string as `raw`, on an entity and in the migration builder alike. A string it
+ * cannot write as `raw` is reported.
  */
-function rewriteIndexSql(columns, options, ctx) {
-    ctx.edits.push(...expressionEntryEdits(columns));
+function rewriteIndexWhere(options, ctx) {
     const where = options && propertyValue(options, 'where');
     if (!where || !isStringTyped(ctx.checker.getTypeAtLocation(where))) {
         return;
@@ -322,14 +337,14 @@ function rewriteIndexSql(columns, options, ctx) {
 function isStringTyped(type) {
     return type.isUnion() ? type.types.every(isStringTyped) : Boolean(type.flags & ts.TypeFlags.StringLike);
 }
-/** The migration builder's index methods, each with the position of the columns it takes. */
+/** The migration builder's index methods, each with the position of the options it takes. */
 const BUILDER_INDEX_METHODS = new Map([
-    ['index', 0],
-    ['unique', 0],
-    ['addIndex', 0],
-    ['createIndex', 1],
+    ['index', 1],
+    ['unique', 1],
+    ['addIndex', 1],
+    ['createIndex', 2],
 ]);
-/** Rewrites the SQL of the migration builder's `t.index()`, `t.unique()`, `t.addIndex()` and `m.createIndex()`. */
+/** 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)
         ? BUILDER_INDEX_METHODS.get(call.expression.name.text)
@@ -337,15 +352,15 @@ function rewriteBuilderCall(call, ctx) {
     if (at === undefined) {
         return;
     }
-    const options = call.arguments[at + 1];
-    rewriteIndexSql(call.arguments[at], options && ts.isObjectLiteralExpression(options) ? options : undefined, ctx);
+    const options = call.arguments[at];
+    rewriteIndexWhere(options && ts.isObjectLiteralExpression(options) ? options : undefined, ctx);
 }
 /**
  * `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.
  */
 function rewriteRelationOptions(relation, owner, ctx, target = paramFor(entityGetterTarget(relation))) {
-    const advice = (what) => `write '${what}' as a key-map callback`;
+    const advice = (what) => `write '${what}' as a callback`;
     const mappedBy = (value) => mappedByEdits(value, target);
     const references = (value) => referencesEdits(value, owner, target);
     rewriteValue(propertyValue(relation, 'mappedBy'), mappedBy, relation, advice('mappedBy'), ctx);
@@ -526,7 +541,7 @@ function brandIdKey(node, ctx) {
         return;
     }
     const indent = ' '.repeat(node.getSourceFile().getLineAndCharacterOfPosition(ids[0].getStart()).character);
-    const brand = names.map((name) => `'${name}'`).join(' | ');
+    const brand = names.map(quoted).join(' | ');
     const start = node.members.pos;
     ctx.edits.push({ start, end: start, text: `\n${indent}[idKey]?: ${brand};` });
     ctx.imports.set('idKey', 'the brand(s)');

package/package.json

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