uql-orm 0.56.0 → 0.58.0

package/dist/querier/abstractSqlQuerier.d.ts

@@ -1,6 +1,5 @@
 import type { AbstractSqlDialect } from '../dialect/index.js';
 import type { EntityData, ExtraOptions, Query, QueryAggMap, QueryAggregate, QueryAggregateResult, QueryConflictPaths, QueryFilter, QueryGroupMap, QueryOptions, QuerySearch, QueryUpdateResult, SqlQuerier, TransactionOptions, Type, UpdatePayload } from '../type/index.js';
-import { type ParentPartition } from '../util/index.js';
 import type { BuildUpdateResultPayload } from '../util/sql.util.js';
 import { AbstractQuerier } from './abstractQuerier.js';
 export declare abstract class AbstractSqlQuerier extends AbstractQuerier implements SqlQuerier {
@@ -58,19 +57,6 @@ export declare abstract class AbstractSqlQuerier extends AbstractQuerier impleme
      */
     private applyVectorTuning;
     protected internalFindMany<E extends object>(entity: Type<E>, q: Query<E>, opts?: QueryOptions): Promise<E[]>;
-    /**
-     * One bounded subquery per parent, concatenated with `UNION ALL`, so each parent gets its own
-     * `$limit` rather than a share of one. Universal, and reads `parents x (skip + limit)` rows where a
-     * `ROW_NUMBER` window reads every matching child. [The design](../../../../architecture/populate-limits.md).
-     *
-     * Each branch is a wrapped derived table: SQLite rejects `ORDER BY`/`LIMIT` on a bare parenthesised
-     * compound branch, and the wrapper costs nothing elsewhere.
-     *
-     * Unlike {@link selectRows} this asserts no lock and tunes no vector search: `$lock` and
-     * `$candidates` describe the statement, and `parseRelationQueryValue` refuses both on a relation
-     * query, so neither can reach here.
-     */
-    protected internalFindManyPerParent<E extends object>(entity: Type<E>, q: Query<E>, partition: ParentPartition): Promise<E[]>;
     /**
      * How to count when the total cannot ride along in the read's own `COUNT(*) OVER ()` column, or
      * `undefined` when it can. Two clauses rule the window out: `$distinct`, because a window counts
@@ -107,9 +93,10 @@ export declare abstract class AbstractSqlQuerier extends AbstractQuerier impleme
      */
     private hydrateAll;
     /**
-     * One row of {@link hydrateAll}. `visited` guards a populated graph that points back at itself, and
-     * makes a node two paths reach decode once. Only a populated relation can lead the walk back, so the
-     * guard is created at the first one a row carries: rows that populated nothing never allocate one.
+     * One row of {@link hydrateAll}. A related row arrives as its parent's statement read it: a to-one
+     * joined and unflattened, there only when its key is, since an unmatched join still fills a computed
+     * column or a to-many's empty array; a to-many as a JSON array, which a driver may hand over as text.
+     * Each is an object of its own, so the walk reaches none twice.
      */
     private hydrateFields;
     /**

package/dist/querier/abstractSqlQuerier.js

@@ -1,7 +1,8 @@
 import { COUNT_ALIAS, TOTAL_ALIAS } from '../dialect/aliases.js';
 import { decodeColumn } from '../dialect/hydrateColumn.js';
 import { getMeta, idOf, namesKey } from '../entity/index.js';
-import { buildUpdateResult, cascadesOnDelete, clone, getInsertFieldKeys, insertShapeOf, getRelationRequestSummary, idOnlyQuery, isAutoIncrement, isPagedQuery, obtainAttrsPaths, throwNoPendingTransaction, throwPendingTransaction, unflatObject, unflatObjects, whereIds, withoutSoftDeleteFilter, } from '../util/index.js';
+import { COUNT_RESULT_KEY } from '../type/index.js';
+import { buildUpdateResult, cascadesOnDelete, clone, getInsertFieldKeys, insertShapeOf, idOnlyQuery, isAutoIncrement, isPagedQuery, isRecord, obtainAttrsPaths, throwNoPendingTransaction, throwPendingTransaction, unflatObject, unflatObjects, whereIds, withoutSoftDeleteFilter, } from '../util/index.js';
 import { AbstractQuerier } from './abstractQuerier.js';
 import { enrichError } from './queryError.js';
 /**
@@ -153,24 +154,7 @@ export class AbstractSqlQuerier extends AbstractQuerier {
         }
     }
     async internalFindMany(entity, q, opts) {
-        return this.hydrateRows(entity, q, await this.selectRows(entity, q, opts));
-    }
-    /**
-     * One bounded subquery per parent, concatenated with `UNION ALL`, so each parent gets its own
-     * `$limit` rather than a share of one. Universal, and reads `parents x (skip + limit)` rows where a
-     * `ROW_NUMBER` window reads every matching child. [The design](../../../../architecture/populate-limits.md).
-     *
-     * Each branch is a wrapped derived table: SQLite rejects `ORDER BY`/`LIMIT` on a bare parenthesised
-     * compound branch, and the wrapper costs nothing elsewhere.
-     *
-     * Unlike {@link selectRows} this asserts no lock and tunes no vector search: `$lock` and
-     * `$candidates` describe the statement, and `parseRelationQueryValue` refuses both on a relation
-     * query, so neither can reach here.
-     */
-    async internalFindManyPerParent(entity, q, partition) {
-        const ctx = this.dialect.createContext();
-        this.dialect.findPerParent(ctx, entity, q, partition);
-        return this.hydrateRows(entity, q, await this.all(ctx.sql, ctx.values));
+        return this.hydrateRows(entity, await this.selectRows(entity, q, opts));
     }
     /**
      * How to count when the total cannot ride along in the read's own `COUNT(*) OVER ()` column, or
@@ -208,7 +192,7 @@ export class AbstractSqlQuerier extends AbstractQuerier {
         for (const row of rows) {
             delete row[TOTAL_ALIAS];
         }
-        return [await this.hydrateRows(entity, q, rows), total];
+        return [this.hydrateRows(entity, rows), total];
     }
     async selectRows(entity, q, opts, totalAlias) {
         this.assertLockable(entity, q);
@@ -222,12 +206,9 @@ export class AbstractSqlQuerier extends AbstractQuerier {
         this.dialect.find(ctx, entity, q, opts, totalAlias);
         return this.all(ctx.sql, ctx.values);
     }
-    async hydrateRows(entity, q, rows) {
+    hydrateRows(entity, rows) {
         const founds = unflatObjects(rows);
         this.hydrateAll(entity, founds);
-        if (q.$populate) {
-            await this.fillToManyRelations(entity, founds, q.$populate);
-        }
         return founds;
     }
     async *internalFindManyStream(entity, q, opts) {
@@ -237,10 +218,6 @@ export class AbstractSqlQuerier extends AbstractQuerier {
             await this.applyVectorTuning(entity, q);
         }
         const meta = getMeta(entity);
-        const { toManyKeys } = getRelationRequestSummary(meta, q.$populate);
-        if (toManyKeys.length) {
-            throw new TypeError(`findManyStream does not load to-many relations (${toManyKeys.join(', ')}). Use findMany so fillToManyRelations can run, or omit those keys from the stream query.`);
-        }
         // The one path that does not go through `all`/`run`, so it connects on its own: streaming first on
         // a freshly acquired querier used to reach `getConn()` with nothing acquired.
         await this.lazyConnect();
@@ -276,23 +253,20 @@ export class AbstractSqlQuerier extends AbstractQuerier {
      * rows; the per-cell decode is `decodeColumn`. Both live with the dialect, because a `sparsevec` is
      * only sparse on Postgres.
      */
-    hydrateAll(entity, dtos, visited) {
+    hydrateAll(entity, dtos) {
         const meta = getMeta(entity);
         const fields = this.dialect.hydratableFields(entity);
         for (const dto of dtos) {
-            this.hydrateFields(meta, fields, dto, visited);
+            this.hydrateFields(meta, fields, dto);
         }
     }
     /**
-     * One row of {@link hydrateAll}. `visited` guards a populated graph that points back at itself, and
-     * makes a node two paths reach decode once. Only a populated relation can lead the walk back, so the
-     * guard is created at the first one a row carries: rows that populated nothing never allocate one.
+     * One row of {@link hydrateAll}. A related row arrives as its parent's statement read it: a to-one
+     * joined and unflattened, there only when its key is, since an unmatched join still fills a computed
+     * column or a to-many's empty array; a to-many as a JSON array, which a driver may hand over as text.
+     * Each is an object of its own, so the walk reaches none twice.
      */
-    hydrateFields(meta, fields, dto, visited) {
-        if (!dto || typeof dto !== 'object' || visited?.has(dto)) {
-            return;
-        }
-        visited?.add(dto);
+    hydrateFields(meta, fields, dto) {
         const row = dto;
         for (const [key, kind] of fields) {
             const value = row[key];
@@ -300,23 +274,39 @@ export class AbstractSqlQuerier extends AbstractQuerier {
                 row[key] = decodeColumn(value, kind);
             }
         }
+        // A tally read inside the statement comes back as its driver reads a COUNT, which on some is text.
+        const counts = row[COUNT_RESULT_KEY];
+        if (isRecord(counts)) {
+            for (const relKey in counts) {
+                counts[relKey] = Number(counts[relKey]);
+            }
+        }
         // The value is read before the relation's target is resolved: a query that populated nothing
         // still walks every relation the entity declares, and `rel.entity()` is a call per row per
         // relation that only the populated ones need.
         for (const key in meta.relations) {
             const value = row[key];
-            if (!value || typeof value !== 'object')
+            if (!value)
                 continue;
             const rel = meta.relations[key];
             if (!rel)
                 continue;
-            visited ??= new WeakSet([dto]);
             const relEntity = rel.entity();
-            if (Array.isArray(value)) {
-                this.hydrateAll(relEntity, value, visited);
-                continue;
+            if (typeof value === 'string' || Array.isArray(value)) {
+                // A to-many's rows, as flat as a statement's own.
+                const rows = unflatObjects(typeof value === 'string' ? JSON.parse(value) : value);
+                row[key] = rows;
+                this.hydrateAll(relEntity, rows);
+            }
+            else if (isRecord(value)) {
+                const relMeta = getMeta(relEntity);
+                if (value[relMeta.ids[0]] == null) {
+                    delete row[key];
+                }
+                else {
+                    this.hydrateFields(relMeta, this.dialect.hydratableFields(relEntity), value);
+                }
             }
-            this.hydrateFields(getMeta(relEntity), this.dialect.hydratableFields(relEntity), value, visited);
         }
     }
     /**
@@ -339,17 +329,17 @@ export class AbstractSqlQuerier extends AbstractQuerier {
     async internalAggregate(entity, q, opts) {
         const ctx = this.dialect.createContext();
         this.dialect.aggregate(ctx, entity, q, opts);
-        // oxlint-disable-next-line typescript/no-explicit-any -- raw DB rows satisfy QueryAggregateResult at runtime but TS can't verify
-        const res = await this.all(ctx.sql, ctx.values);
+        const rows = await this.all(ctx.sql, ctx.values);
         const hydratable = this.dialect.hydratableAggregates(entity, q);
-        for (const row of res) {
+        for (const row of rows) {
+            const cells = row;
             for (const [alias, kind] of hydratable) {
-                if (row[alias] != null) {
-                    row[alias] = decodeColumn(row[alias], kind);
+                if (cells[alias] != null) {
+                    cells[alias] = decodeColumn(cells[alias], kind);
                 }
             }
         }
-        return res;
+        return rows;
     }
     async internalInsertMany(entity, rows) {
         const meta = getMeta(entity);

package/dist/schema/canonicalType.js

@@ -6,7 +6,7 @@
  * - Canonical types (dialect-agnostic)
  * - TypeScript types (for entity generation)
  */
-import { columnFamily } from '../util/field.util.js';
+import { columnFamily, isIntegerColumn } from '../util/field.util.js';
 /** Whether a category is one of the vector types, narrowing it to the cast pgvector names use. */
 export function isVectorCategory(category) {
     return category === 'vector' || category === 'halfvec' || category === 'sparsevec';
@@ -395,9 +395,9 @@ export function fieldOptionsToCanonical(options) {
         case 'numeric':
             // BIGINT for every `Number` without a scale, key or not: a 32-bit column is a migration waiting
             // to happen, and the pools decode it back to a JS number at the wire (see `pgNumericTypes`).
-            return type === Number && (options.precision || options.scale)
-                ? { category: 'decimal', precision: options.precision, scale: options.scale }
-                : { category: 'integer', size: 'big' };
+            return isIntegerColumn(options)
+                ? { category: 'integer', size: 'big' }
+                : { category: 'decimal', precision: options.precision, scale: options.scale };
         case 'boolean':
             return { category: 'boolean' };
         case 'date':

package/dist/schema/indexDifferences.js

@@ -61,20 +61,20 @@ export function describeIndexDifferences(source, target, facets) {
     if (comparableEntries) {
         const [sourceColumns, targetColumns] = [source.entries, target.entries].map((entries) => entries.map((entry) => entrySignature(entry, facets)).join(', '));
         if (sourceColumns !== targetColumns) {
-            differences.push(`columns: (${targetColumns}) → (${sourceColumns})`);
+            differences.push(`columns: (${targetColumns}) -> (${sourceColumns})`);
         }
     }
     if (source.unique !== target.unique) {
-        differences.push(`unique: ${target.unique} → ${source.unique}`);
+        differences.push(`unique: ${target.unique} -> ${source.unique}`);
     }
     if (facets.has('accessMethod') && (source.type ?? 'btree') !== (target.type ?? 'btree')) {
-        differences.push(`type: ${target.type ?? 'btree'} → ${source.type ?? 'btree'}`);
+        differences.push(`type: ${target.type ?? 'btree'} -> ${source.type ?? 'btree'}`);
     }
     if (facets.has('include')) {
         // Order carries no meaning in an `INCLUDE` list, so it is compared as a set.
         const [sourceInclude, targetInclude] = [source.include ?? [], target.include ?? []].map((columns) => [...columns].sort().join(', '));
         if (sourceInclude !== targetInclude) {
-            differences.push(`include: (${targetInclude}) → (${sourceInclude})`);
+            differences.push(`include: (${targetInclude}) -> (${sourceInclude})`);
         }
     }
     return differences;

package/dist/schema/schemaASTBuilder.d.ts

@@ -15,9 +15,9 @@ import { type CanonicalType, type ForeignKeyAction } from './types.js';
  */
 export interface BuildSchemaASTOptions {
     /** Custom resolver for a table's own name, unqualified. */
-    resolveTableName?: (meta: EntityMeta<unknown>) => string;
+    resolveTableName?: (meta: EntityMeta<object>) => string;
     /** Custom resolver for the schema a table lives in; `undefined` leaves it unqualified. */
-    resolveSchema?: (meta: EntityMeta<unknown>) => string | undefined;
+    resolveSchema?: (meta: EntityMeta<object>) => string | undefined;
     /** Custom column name resolver */
     resolveColumnName?: (key: string, field: FieldOptions) => string;
     /** Naming strategy to use */
@@ -31,7 +31,7 @@ export interface BuildSchemaASTOptions {
  * Three passes, because each needs the one before it to have finished for *every* entity: a relation
  * resolves against a table another entity declares, and an index against the columns of its own.
  */
-export declare function buildSchemaAST(entities: readonly Type<unknown>[], options?: BuildSchemaASTOptions): SchemaAST;
+export declare function buildSchemaAST(entities: readonly Type<object>[], options?: BuildSchemaASTOptions): SchemaAST;
 /**
  * Resolve the canonical type for a field, inheriting from the referenced
  * entity's primary key when the field is a foreign-key reference

package/dist/schema/schemaASTBuilder.js

@@ -168,8 +168,8 @@ function addRelationshipsFromEntity(ctx, meta) {
     }
 }
 /**
- * Add indexes from field options (`@Field({ index })`) and from `@Index([...])`, which have nothing
- * in common beyond their target table.
+ * Add indexes from field options (`@Field({ index })`), from `@Index`, and for every foreign
+ * key none of those already serves.
  */
 function addIndexesFromEntity(ctx, meta) {
     const table = tableOf(ctx, meta);
@@ -194,6 +194,35 @@ function addIndexesFromEntity(ctx, meta) {
     for (const idxMeta of meta.indexes ?? []) {
         addCompositeIndex(ctx, table, meta, idxMeta);
     }
+    addForeignKeyIndexes(ctx, meta, table);
+}
+/**
+ * An index over each foreign key the table owns, unless one already leads with its columns or a field
+ * of it says `index: false`. A relation looks its rows up by these columns, and MySQL alone indexes
+ * them on its own. Last, so it sees every index the entity declared.
+ */
+function addForeignKeyIndexes(ctx, meta, table) {
+    const optedOut = new Set(definedEntries(meta.fields).flatMap(([key, field]) => field.index === false ? [ctx.resolveColumnName(key, field)] : []));
+    for (const { from } of table.outgoingRelations) {
+        const columns = from.columns.map((column) => column.name);
+        if (columns.some((column) => optedOut.has(column)) || isIndexedBy(table, columns))
+            continue;
+        ctx.ast.addIndex({
+            name: derivedIndexName(table.name, columns),
+            table,
+            entries: columns.map((column) => ({ column })),
+            unique: false,
+            source: 'entity',
+            syncStatus: 'entity_only',
+        });
+    }
+}
+/** Whether the key, a unique column or an index already leads with `columns`, which is all a lookup needs. */
+function isIndexedBy(table, columns) {
+    const leads = (indexed) => columns.every((column, at) => indexed[at] === column);
+    return (leads(table.primaryKey.map((column) => column.name)) ||
+        (columns.length === 1 && table.columns.get(columns[0])?.isUnique === true) ||
+        table.indexes.some((index) => leads(index.entries.map((entry) => entry.expression || entry.jsonPath || entry.jsonArray ? undefined : entry.column))));
 }
 /** An `include` column is named like any other, so a naming strategy has to reach it too. */
 function resolveIncludeColumn(ctx, meta, column) {
@@ -201,7 +230,7 @@ function resolveIncludeColumn(ctx, meta, column) {
     return field ? ctx.resolveColumnName(column, field) : column;
 }
 /**
- * One `@Index([...])`. Its entries keep the authored form (expression, prefix length, order) with
+ * One `@Index`. Its entries keep the authored form (expression, prefix length, order) with
  * names resolved, so the generator renders exactly what was declared; `columns` is the resolvable
  * subset, which is what diffing and introspection compare.
  */

package/dist/schema/schemaASTDiffer.js

@@ -179,7 +179,7 @@ function diffColumn(tableName, source, target, opts) {
     const impliedNotNull = source.isPrimaryKey && target.isPrimaryKey;
     const typeChanged = !generatedType && !areTypesEqual(opts.normalizeType(source.type), opts.normalizeType(target.type));
     if (typeChanged) {
-        differences.push(`type: ${formatType(source.type)} → ${formatType(target.type)}`);
+        differences.push(`type: ${formatType(source.type)} -> ${formatType(target.type)}`);
     }
     // Signedness is the one thing compared on a generated key, because it is the one part of the serial
     // spelling that does round trip - and a key left unsigned refuses every foreign key pointing at it,
@@ -187,14 +187,14 @@ function diffColumn(tableName, source, target, opts) {
     // a database created before the serial became signed could never gain a foreign key.
     const signednessChanged = generatedType && !!source.type.unsigned !== !!target.type.unsigned;
     if (signednessChanged) {
-        differences.push(`type: ${formatType(source.type)} → ${formatType(target.type)}`);
+        differences.push(`type: ${formatType(source.type)} -> ${formatType(target.type)}`);
     }
     if (!impliedNotNull && source.nullable !== target.nullable) {
-        differences.push(`nullable: ${target.nullable} → ${source.nullable}`);
+        differences.push(`nullable: ${target.nullable} -> ${source.nullable}`);
     }
     // Compare unique constraint
     if (source.isUnique !== target.isUnique) {
-        differences.push(`unique: ${target.isUnique} → ${source.isUnique}`);
+        differences.push(`unique: ${target.isUnique} -> ${source.isUnique}`);
     }
     // Four things are deliberately not compared, all for one reason: a difference here could only be
     // reported, never settled, because no statement this generator emits would change it.
@@ -206,7 +206,7 @@ function diffColumn(tableName, source, target, opts) {
     // The same rule `describeIndexDifferences` follows for what it cannot read.
     // Compare default values (if both defined)
     if (!opts.defaultsEqual(source.defaultValue, target.defaultValue)) {
-        differences.push(`default: ${target.defaultValue ?? 'NULL'} → ${source.defaultValue ?? 'NULL'}`);
+        differences.push(`default: ${target.defaultValue ?? 'NULL'} -> ${source.defaultValue ?? 'NULL'}`);
     }
     if (differences.length === 0) {
         return undefined;

package/dist/sqlite/sqliteDialect.d.ts

@@ -1,4 +1,4 @@
-import { AbstractSqlDialect } from '../dialect/abstractSqlDialect.js';
+import { AbstractSqlDialect, type DerivedRelation, type HydrateKind, type RelationRows } from '../dialect/abstractSqlDialect.js';
 import type { DialectFeatures, EntityMeta, FieldOptions, QueryContext, QueryPager, QuerySizeComparisonOps, QueryTextSearchOptions, Type, VectorDistance, VectorMetric } from '../type/index.js';
 export declare class SqliteDialect extends AbstractSqlDialect {
     /** Default {@link DialectFeatures} for SQLite and SQLite-derived dialects. */
@@ -16,6 +16,8 @@ export declare class SqliteDialect extends AbstractSqlDialect {
     /** SQLite locks the whole database, not rows, so `$lock` has nothing to map onto. */
     readonly supportsRowLocks = false;
     readonly booleanLiteral = "integer";
+    /** A function call takes 127 arguments before SQLite 3.48, as libSQL and Turso embed. */
+    readonly maxFunctionArgs: number;
     readonly insertIdSource = "returning";
     /**
      * The [sqlite-vec](https://github.com/asg017/sqlite-vec) functions, which need that extension
@@ -36,6 +38,23 @@ export declare class SqliteDialect extends AbstractSqlDialect {
      * SQLite's own spelling of "no limit", where the MySQL family uses its largest `BIGINT`.
      */
     pager(ctx: QueryContext, opts: QueryPager): void;
+    /** `json_group_array` of each row's object, ordered by the sort terms carried out beside them. */
+    protected appendRelationArray(ctx: QueryContext, rows: RelationRows): void;
+    /**
+     * `json_object` of each key and its column. A row wider than one call takes inserts the rest into it,
+     * addressing each key as one path segment.
+     */
+    protected jsonObject(pairs: DerivedRelation['pairs']): string;
+    /**
+     * An integer crosses JSON as its exact text, which JSON would round past 2^53, and bytes as hex, which
+     * `json_object` cannot hold at all. A real stays a number, since SQLite writes one to text with 15 digits.
+     */
+    protected readonly carriedFields: {
+        numeric: (expr: string, field: FieldOptions) => string;
+        blob: (expr: string) => string;
+    };
+    /** A date reads back as SQLite stored it, a number or text, which JSON carries unchanged. */
+    protected hydrateKind(field: FieldOptions | undefined): HydrateKind | undefined;
     /**
      * FTS5 matches the table itself rather than its columns, so this only works when the table *is* an
      * FTS5 virtual table (UQL does not create those; declare it outside your entities).

package/dist/sqlite/sqliteDialect.js

@@ -1,7 +1,9 @@
-import { AbstractSqlDialect } from '../dialect/abstractSqlDialect.js';
-import { JSON_ELEM_ALIAS_PREFIX, JSON_PULL_ALIAS } from '../dialect/aliases.js';
-import { jsonAssignCall, jsonElemExists, jsonPath, jsonRemoveCall, jsonSetTarget } from '../dialect/jsonSql.js';
+import { AbstractSqlDialect, } from '../dialect/abstractSqlDialect.js';
+import { JSON_ELEM_ALIAS, JSON_PULL_ALIAS } from '../dialect/aliases.js';
+import { BYTES_PREFIX } from '../dialect/hydrateColumn.js';
+import { chainedCall, groupsPerCall, jsonAssignCall, jsonElemExists, jsonPath, jsonRemoveCall, jsonSetTarget, } from '../dialect/jsonSql.js';
 import { textSearchFields } from '../util/dialect.util.js';
+import { columnFamily, isIntegerColumn } from '../util/field.util.js';
 export class SqliteDialect extends AbstractSqlDialect {
     /** Default {@link DialectFeatures} for SQLite and SQLite-derived dialects. */
     featureDefaults = {
@@ -37,6 +39,8 @@ export class SqliteDialect extends AbstractSqlDialect {
     /** SQLite locks the whole database, not rows, so `$lock` has nothing to map onto. */
     supportsRowLocks = false;
     booleanLiteral = 'integer';
+    /** A function call takes 127 arguments before SQLite 3.48, as libSQL and Turso embed. */
+    maxFunctionArgs = 127;
     // SQLite supports `RETURNING` (including on `INSERT ... ON CONFLICT`), so IDs are exact per row.
     insertIdSource = 'returning';
     /**
@@ -82,6 +86,33 @@ export class SqliteDialect extends AbstractSqlDialect {
         }
         super.pager(ctx, opts);
     }
+    /** `json_group_array` of each row's object, ordered by the sort terms carried out beside them. */
+    appendRelationArray(ctx, rows) {
+        const { from, pairs, order } = this.derivedRelation(ctx, rows);
+        ctx.append(`(SELECT json_group_array(${this.jsonObject(pairs)}${order ? ` ORDER BY ${order}` : ''}) FROM ${from})`);
+    }
+    /**
+     * `json_object` of each key and its column. A row wider than one call takes inserts the rest into it,
+     * addressing each key as one path segment.
+     */
+    jsonObject(pairs) {
+        const perCall = groupsPerCall(this.maxFunctionArgs, 2);
+        const object = `json_object(${this.jsonObjectArgs(pairs.slice(0, perCall))})`;
+        const inserts = pairs.slice(perCall).map(([key, sql]) => `${this.escape(`$."${key}"`)}, ${sql}`);
+        return chainedCall('json_insert', object, inserts, 2, this.maxFunctionArgs);
+    }
+    /**
+     * An integer crosses JSON as its exact text, which JSON would round past 2^53, and bytes as hex, which
+     * `json_object` cannot hold at all. A real stays a number, since SQLite writes one to text with 15 digits.
+     */
+    carriedFields = {
+        numeric: (expr, field) => (isIntegerColumn(field) ? `CAST(${expr} AS TEXT)` : expr),
+        blob: (expr) => `${this.escape(BYTES_PREFIX)} || hex(${expr})`,
+    };
+    /** A date reads back as SQLite stored it, a number or text, which JSON carries unchanged. */
+    hydrateKind(field) {
+        return columnFamily(field?.type) === 'date' ? undefined : super.hydrateKind(field);
+    }
     /**
      * FTS5 matches the table itself rather than its columns, so this only works when the table *is* an
      * FTS5 virtual table (UQL does not create those; declare it outside your entities).
@@ -104,7 +135,7 @@ export class SqliteDialect extends AbstractSqlDialect {
      * vs `"a"`), flattens booleans to 0/1, and stringifies objects.
      */
     jsonAll(ctx, jsonField, value) {
-        const alias = ctx.nextAlias(JSON_ELEM_ALIAS_PREFIX);
+        const alias = ctx.claimAlias(JSON_ELEM_ALIAS);
         const from = this.jsonElemFrom(jsonField, [], alias);
         const conditions = value.map((val) => jsonElemExists(from, [`${jsonField} -> ${alias}.fullkey = ${this.jsonScalarParam(ctx, val)}`]));
         return `(${conditions.join(' AND ')})`;
@@ -143,7 +174,7 @@ export class SqliteDialect extends AbstractSqlDialect {
         return `JSON_REPLACE(${expr}, ${path}, (${kept}))`;
     }
     jsonSet(ctx, expr, set, field) {
-        return jsonAssignCall((value) => this.jsonScalarParam(ctx, value), 'JSON_SET', jsonSetTarget(expr, field, `'{}'`), set);
+        return jsonAssignCall((value) => this.jsonScalarParam(ctx, value), 'JSON_SET', jsonSetTarget(expr, field, `'{}'`), set, this.maxFunctionArgs);
     }
     /**
      * `[#]` appends, creating the array when the key is absent.
@@ -153,9 +184,9 @@ export class SqliteDialect extends AbstractSqlDialect {
      * so it silently drops the element when the array already exists.
      */
     jsonPush(ctx, expr, push) {
-        return jsonAssignCall((value) => this.jsonScalarParam(ctx, value), 'JSON_SET', expr, push, '[#]');
+        return jsonAssignCall((value) => this.jsonScalarParam(ctx, value), 'JSON_SET', expr, push, this.maxFunctionArgs, '[#]');
     }
     jsonUnset(_ctx, expr, unset) {
-        return jsonRemoveCall('JSON_REMOVE', expr, unset);
+        return jsonRemoveCall('JSON_REMOVE', expr, unset, this.maxFunctionArgs);
     }
 }

package/dist/turso/tursoDialect.d.ts

@@ -12,4 +12,6 @@ import type { VectorDistance, VectorMetric } from '../type/index.js';
 export declare class TursoDialect extends LibsqlDialect {
     /** The Rust engine adds a dot-product distance to libSQL's cosine and L2. */
     readonly vectorMetrics: ReadonlyMap<VectorDistance, VectorMetric>;
+    /** The Rust engine takes no `ORDER BY` inside an aggregate. */
+    protected readonly orderedAggregates = false;
 }

package/dist/turso/tursoDialect.js

@@ -15,4 +15,6 @@ export class TursoDialect extends LibsqlDialect {
         ['l2', { fn: 'vector_distance_l2' }],
         ['inner', { fn: 'vector_distance_dot' }],
     ]);
+    /** The Rust engine takes no `ORDER BY` inside an aggregate. */
+    orderedAggregates = false;
 }

package/dist/type/config.d.ts

@@ -1,5 +1,5 @@
-import type { AbstractDialect } from '../dialect/abstractDialect.js';
 import type { ForeignKeyAction } from '../schema/types.js';
+import type { MigratorDialect } from './migratorDialect.js';
 import type { Querier } from './querier.js';
 import type { QuerierPool } from './querierPool.js';
 import type { Type } from './utility.js';
@@ -12,12 +12,12 @@ export interface Config {
      * This is required for both the application and the migrations CLI.
      * Must expose {@link QuerierPool.dialect}; migrations and the CLI read `pool.dialect.dialectName`.
      */
-    pool: QuerierPool<Querier, AbstractDialect>;
+    pool: QuerierPool<Querier, MigratorDialect>;
     /**
      * List of entity classes to be managed by the ORM.
      * If omitted, classes that completed `defineEntity` (including via `@Entity()`) are discovered via `getEntities()`.
      */
-    entities?: Type<unknown>[];
+    entities?: Type<object>[];
     /**
      * The directory where migration files are stored.
      * @default './migrations'

package/dist/type/dialect.d.ts

@@ -33,12 +33,11 @@ export interface QueryContext {
     addValue(value: unknown): this;
     pushValue(...values: unknown[]): this;
     /**
-     * A fresh derived-table/subquery alias, unique within this query: `nextAlias('_uql_elem')` returns
-     * `'_uql_elem_1'`, then `'_uql_elem_2'`, etc. Needed wherever a hook (e.g. exploding a JSON array)
-     * might recurse into itself at a deeper nesting level within the same query - a fixed, reused
-     * alias would let the inner occurrence shadow the outer one it needs to correlate against.
+     * An alias for a table or row source the statement reads: `name`, or `name_2`, `name_3`... - the
+     * first no other took, so a nested one never shadows what it correlates against, and never `parent`,
+     * the one a correlated subquery compares against. Compared without case, as MySQL does on macOS.
      */
-    nextAlias(prefix: string): string;
+    claimAlias(name: string, parent?: string): string;
     /**
      * A context for a fragment of this same statement: it renders its own SQL in isolation while
      * sharing the bound values and the generated aliases, so both stay unique and correctly numbered