uql-orm 0.72.0 → 0.72.2

package/dist/dialect/pgLikeSqlDialect.d.ts

@@ -1,5 +1,5 @@
 import type { IndexType } from '../schema/types.js';
-import { type DriverCapabilities, type EntityMeta, type FieldOptions, type JsonColumnType, type Query, type QueryContext, type QueryTextSearchOptions, type SqlDialectFeatures, type Type, type VectorDistance, type VectorMetric } from '../type/index.js';
+import { type DriverCapabilities, type EntityMeta, type FieldOptions, type JsonColumnType, type Query, type QueryContext, type QueryTextSearchOptions, type SqlDialectFeatures, type VectorDistance, type VectorMetric } from '../type/index.js';
 import type { DialectOptions } from './abstractDialect.js';
 import { AbstractSqlDialect, type RelationRows } from './abstractSqlDialect.js';
 import { type JsonAccessMode, type JsonSlot } from './jsonSql.js';
@@ -63,10 +63,13 @@ export declare abstract class PgLikeSqlDialect extends AbstractSqlDialect {
      * index over these fields, which the planner serves it from. `WEBSEARCH_TO_TSQUERY` takes free-form
      * input (quoted phrases, `or`, `-negation`) and never raises a syntax error, unlike `TO_TSQUERY`.
      */
-    protected appendTextSearch<E>(ctx: QueryContext, _entity: Type<E>, meta: EntityMeta<E>, search: QueryTextSearchOptions<E>): void;
-    /** `TS_RANK` of the document the predicate matches, against the same search. */
-    protected appendTextRank<E>(ctx: QueryContext, meta: EntityMeta<E>, search: QueryTextSearchOptions<E>): void;
-    /** The document a search reads and the search itself, open for its value. */
+    protected appendTextSearch<E>(ctx: QueryContext, meta: EntityMeta<E>, search: QueryTextSearchOptions<E>, prefix: string | undefined): void;
+    /** `TS_RANK` of the document over `keys` against the same search the match reads. */
+    protected appendTextScore<E>(ctx: QueryContext, meta: EntityMeta<E>, search: QueryTextSearchOptions<E>, keys: readonly string[], prefix: string | undefined): void;
+    /**
+     * The document over `keys` and the search itself, open for its value, under the `$config` asked for,
+     * else that of the fulltext index over every field searched, which is what serves the match.
+     */
     private textSearchParts;
     /**
      * The document, `TO_TSVECTOR('english'::regconfig, COALESCE("a", '') || ' ' || COALESCE("b", ''))`, a

package/dist/dialect/pgLikeSqlDialect.js

@@ -36,6 +36,7 @@ export const PG_FEATURES = {
     rowLocks: true,
     rowLockWithWindow: false,
     rowLockOf: true,
+    textScoreIndexes: false,
     orderedUpsertReturning: true,
     orderedJsonAggregates: true,
     narrowVectorTypes: false,
@@ -128,27 +129,29 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
      * index over these fields, which the planner serves it from. `WEBSEARCH_TO_TSQUERY` takes free-form
      * input (quoted phrases, `or`, `-negation`) and never raises a syntax error, unlike `TO_TSQUERY`.
      */
-    appendTextSearch(ctx, _entity, meta, search) {
-        const { document, query } = this.textSearchParts(meta, search);
+    appendTextSearch(ctx, meta, search, prefix) {
+        const { document, query } = this.textSearchParts(meta, search, prefix);
         ctx.append(`${document} @@ ${query}`);
         ctx.addValue(search.$value);
         ctx.append(')');
     }
-    /** `TS_RANK` of the document the predicate matches, against the same search. */
-    appendTextRank(ctx, meta, search) {
-        const { document, query } = this.textSearchParts(meta, search);
+    /** `TS_RANK` of the document over `keys` against the same search the match reads. */
+    appendTextScore(ctx, meta, search, keys, prefix) {
+        const { document, query } = this.textSearchParts(meta, search, prefix, keys);
         ctx.append(`TS_RANK(${document}, ${query}`);
         ctx.addValue(search.$value);
         ctx.append('))');
     }
-    /** The document a search reads and the search itself, open for its value. */
-    textSearchParts(meta, search) {
-        const keys = textSearchFields(meta, search);
-        const index = fulltextIndexOver(meta, keys);
+    /**
+     * The document over `keys` and the search itself, open for its value, under the `$config` asked for,
+     * else that of the fulltext index over every field searched, which is what serves the match.
+     */
+    textSearchParts(meta, search, prefix, keys) {
+        const fields = textSearchFields(meta, search);
+        const index = fulltextIndexOver(meta, fields);
         const config = search.$config ?? (index && fulltextConfig(index));
-        const columns = keys.map((key) => this.escapeId(this.resolveColumnName(key, meta.fields[key])));
         return {
-            document: this.textSearchTarget(columns, config),
+            document: this.textSearchTarget(this.textColumns(meta, keys ?? fields, prefix), config),
             query: `${this.textQueryFn}(${this.textConfigArg(config)}`,
         };
     }

package/dist/dialect/queryJoins.d.ts

@@ -1,4 +1,5 @@
-import type { EntityMeta, Query, QueryGroupMap, QuerySortMap, QueryWhere, RelationMeta, RelationQuery, Type } from '../type/index.js';
+import type { EntityMeta, FieldMeta, Query, QueryGroupMap, QuerySortMap, QueryWhere, RelationMeta, RelationQuery, Type } from '../type/index.js';
+import { type ParsedGroupEntry } from '../util/index.js';
 /**
  * One relation a statement joins, keyed by the alias its columns are addressed by (`tax`,
  * `tax.category`). `projected` tells a `$populate` join, whose columns are selected, from one only
@@ -56,6 +57,15 @@ export declare function groupPathField(joins: QueryJoins, path: readonly string[
     readonly key: string;
     readonly join: QueryJoin | undefined;
 };
+/**
+ * The field an aggregate's column reads as, and the join it reads it through, none for the entity's own:
+ * a group key's, or the one a `$sum`, `$min` or `$max` aggregates. None at all for `$count` and `$avg`,
+ * which the engine widens to a number whatever they read.
+ */
+export declare function aggregateColumnField<E>(meta: EntityMeta<E>, joins: QueryJoins, entry: ParsedGroupEntry<E>): {
+    readonly field: FieldMeta | undefined;
+    readonly join?: QueryJoin;
+} | undefined;
 /**
  * Whether a join drops parents that have no match, which is the one thing a join does to *how many*
  * rows a read returns rather than how wide they are. A count that skips the joins has to be told, or

package/dist/dialect/queryJoins.js

@@ -53,6 +53,20 @@ export function groupPathField(joins, path) {
     }
     return { key, join };
 }
+/**
+ * The field an aggregate's column reads as, and the join it reads it through, none for the entity's own:
+ * a group key's, or the one a `$sum`, `$min` or `$max` aggregates. None at all for `$count` and `$avg`,
+ * which the engine widens to a number whatever they read.
+ */
+export function aggregateColumnField(meta, joins, entry) {
+    if (entry.kind === 'fn') {
+        return entry.op === '$count' || entry.op === '$avg'
+            ? undefined
+            : { field: meta.fields[entry.fieldRef] };
+    }
+    const { key, join } = groupPathField(joins, entry.path);
+    return join ? { field: join.meta.fields[key], join } : { field: meta.fields[key] };
+}
 /**
  * Whether a join drops parents that have no match, which is the one thing a join does to *how many*
  * rows a read returns rather than how wide they are. A count that skips the joins has to be told, or

package/dist/dialect/vectorSqlDialect.d.ts

@@ -51,11 +51,6 @@ export declare abstract class VectorSqlDialect extends AbstractDialect {
      * rather than naming a type the engine does not define.
      */
     supportedVectorType(cast: VectorCast): VectorCast;
-    /**
-     * The distance a vector `$sort` projects, which the projection names after `$project`. Delegates to
-     * `appendVectorDistance` so each dialect's distance syntax is written once.
-     */
-    protected appendVectorProjection<E>(ctx: QueryContext, meta: EntityMeta<E>, key: string, search: QueryVectorSearch): void;
     /**
      * The distance expression, in whichever of the two shapes this dialect spells it. One method for
      * both, so the metric lookup and its refusal exist once rather than per shape.

package/dist/dialect/vectorSqlDialect.js

@@ -1,6 +1,5 @@
 import { DEFAULT_VECTOR_DISTANCE, unsupportedVectorMetric } from '../type/vector.js';
 import { findVectorIndex, findVectorSort, vectorCandidates } from '../util/dialect.util.js';
-import { entityName } from '../util/object.util.js';
 import { AbstractDialect } from './abstractDialect.js';
 import { encodeFloat32s } from './vectorCast.js';
 /**
@@ -69,20 +68,6 @@ export class VectorSqlDialect extends AbstractDialect {
     supportedVectorType(cast) {
         return this.features.narrowVectorTypes ? cast : 'vector';
     }
-    /**
-     * The distance a vector `$sort` projects, which the projection names after `$project`. Delegates to
-     * `appendVectorDistance` so each dialect's distance syntax is written once.
-     */
-    appendVectorProjection(ctx, meta, key, search) {
-        const alias = search.$project;
-        // `$project` names a new column, so it cannot be one the entity already has: both come back
-        // under that name and the driver keeps whichever it read last. Checked here rather than in the
-        // type because TypeScript cannot say "any string except these".
-        if (meta.fields[alias]) {
-            throw new TypeError(`$project '${alias}' collides with a field of '${entityName(meta)}'`);
-        }
-        this.appendVectorDistance(ctx, meta, key, search);
-    }
     /**
      * The distance expression, in whichever of the two shapes this dialect spells it. One method for
      * both, so the metric lookup and its refusal exist once rather than per shape.

package/dist/entity/metadata/definition.js

@@ -1,6 +1,6 @@
 import { RelationAggregate, SOFT_DELETE_FILTER } from '../../type/index.js';
 import { isInlinedExpression } from '../../util/field.util.js';
-import { entitySql, entityWhere, fieldOptionConflict, getKeys, hasKeys, isToManyRelation, memberRefs, normalizeIndexColumn, definedEntries, } from '../../util/index.js';
+import { entitySql, entityWhere, fieldOptionConflict, getKeys, hasKeys, isToManyRelation, memberRefs, fulltextWeights, normalizeIndexColumn, definedEntries, } from '../../util/index.js';
 import { ownRegistrations } from '../decorator/bag.js';
 /**
  * A map held on `globalThis` through the global symbol registry, so a single one survives multiple
@@ -101,11 +101,13 @@ export function defineHook(entity, methodName, event) {
 export function defineIndex(entity, index) {
     const meta = ensureWritableMeta(entity);
     const refs = memberRefs();
+    const columns = index.columns(refs).map(normalizeIndexColumn);
+    fulltextWeights({ type: index.type, entries: columns });
     (meta.indexes ??= []).push({
         ...index,
         unique: index.unique ?? false,
         where: index.where && entityWhere(index.where),
-        columns: index.columns(refs).map(normalizeIndexColumn),
+        columns,
         include: index.include?.(refs).map((ref) => ref.key),
     });
     return meta;

package/dist/migrate/cli.js

@@ -239,7 +239,8 @@ export async function runDriftCheck(migrator, config) {
     }
     else {
         console.log('\nChecking for schema drift...');
-        const expectedAST = buildEntityAST(await migrator.getSchemaGenerator(), config.entities);
+        const generator = await migrator.getSchemaGenerator();
+        const expectedAST = generator.buildAST?.(config.entities) ?? buildEntityAST(generator, config.entities);
         // Build actual schema from database
         const actualAST = await migrator.schemaIntrospector.introspect();
         // Detect drift. The dialect renders canonical types as SQL - without it every type formats as

package/dist/migrate/ddl/indexDdl.d.ts

@@ -15,6 +15,8 @@ export declare class IndexDdl<D extends AbstractSqlDialect = AbstractSqlDialect>
     getCreateIndexStatement(tableName: string, index: IndexSchema, opts?: {
         ifNotExists?: boolean;
     }): string;
+    /** What an index added to a table that has rows needs run after it to serve queries; nothing, mostly. */
+    settleStatements(_tableName: string, _index: IndexSchema): string[];
     /**
      * Index features this dialect can express. Everything here is supported by at least one engine and
      * refused by at least one other, so an index asking for a missing one is rejected rather than

package/dist/migrate/ddl/indexDdl.js

@@ -50,6 +50,10 @@ export class IndexDdl {
             `ON ${this.dialect.escapeId(tableName)}${this.indexAccessMethod(index)} (${columns})` +
             `${this.indexInclude(index)}${this.indexTuning(index)}${this.indexPredicate(index)};`);
     }
+    /** What an index added to a table that has rows needs run after it to serve queries; nothing, mostly. */
+    settleStatements(_tableName, _index) {
+        return [];
+    }
     /**
      * Index features this dialect can express. Everything here is supported by at least one engine and
      * refused by at least one other, so an index asking for a missing one is rejected rather than

package/dist/migrate/ddl/mysqlIndexDdl.d.ts

@@ -6,6 +6,11 @@ export declare class MysqlLikeIndexDdl extends IndexDdl {
     protected readonly indexFeatures: Set<"expression" | "include" | "jsonArray" | "jsonPath" | "nullsOrder" | "opsClass" | "partial" | "prefixLength">;
     protected readonly indexTypes: ReadonlySet<IndexType>;
     protected readonly indexTypeKeywords: ReadonlyMap<IndexType, string>;
+    /**
+     * InnoDB fills a fulltext index added beside another on a loaded table only once the table is optimized:
+     * until then MariaDB scores it 0 and MySQL can fail a `MATCH` over it (MySQL 26.7, MariaDB 12.3).
+     */
+    settleStatements(tableName: string, index: IndexSchema): string[];
     /** ` USING btree|hash` trails the columns: between the table and them, it is a syntax error here. */
     protected indexTuning(index: IndexSchema): string;
 }

package/dist/migrate/ddl/mysqlIndexDdl.js

@@ -11,6 +11,13 @@ export class MysqlLikeIndexDdl extends IndexDdl {
     indexFeatures = new Set(['expression', 'prefixLength']);
     indexTypes = new Set(['btree', 'hash', 'fulltext']);
     indexTypeKeywords = MYSQL_LIKE_INDEX_KEYWORDS;
+    /**
+     * InnoDB fills a fulltext index added beside another on a loaded table only once the table is optimized:
+     * until then MariaDB scores it 0 and MySQL can fail a `MATCH` over it (MySQL 26.7, MariaDB 12.3).
+     */
+    settleStatements(tableName, index) {
+        return index.type === 'fulltext' ? [`OPTIMIZE TABLE ${this.dialect.escapeId(tableName)};`] : [];
+    }
     /** ` USING btree|hash` trails the columns: between the table and them, it is a syntax error here. */
     indexTuning(index) {
         return index.type && !this.indexTypeKeywords.has(index.type) ? ` USING ${index.type}` : '';

package/dist/migrate/generator/mongoCommand.d.ts

@@ -5,6 +5,10 @@ export type MongoIndexOptions = {
     readonly unique: boolean;
     readonly name: string;
     readonly partialFilterExpression?: Readonly<Record<string, unknown>>;
+    /** A text index's weight per field, which `textScore` multiplies a match in it by. */
+    readonly weights?: Readonly<Record<string, number>>;
+    /** The language a text index stems and drops stop words in, a search's own `$language` aside. */
+    readonly default_language?: string;
 };
 /** A field of an Atlas vector search index: the vector itself, or one its `filter` pre-filters on. */
 export type MongoVectorSearchField = {

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -1,8 +1,9 @@
 import { getMeta } from '../../entity/index.js';
-import { MongoDialect } from '../../mongo/mongoDialect.js';
+import { MongoDialect, textLanguage } from '../../mongo/mongoDialect.js';
 import { QueryRaw, } from '../../type/index.js';
 import { indexDistance, unsupportedVectorMetric } from '../../type/vector.js';
 import { declaredIndexes, declaredIndexName, renderIndexColumn } from '../../util/ddlExpression.util.js';
+import { fulltextConfig, fulltextWeights } from '../../util/dialect.util.js';
 import { assertIndexFeatures, assertIndexType } from '../ddl/indexDdl.js';
 import { assertIndexPredicate, refusedIndexPredicate } from '../indexPredicate.js';
 import { renderIndexDefinition } from './definitionToNode.js';
@@ -121,6 +122,7 @@ export class MongoSchemaGenerator extends MongoDialect {
         for (const entry of index.entries) {
             key[entry.column] = index.type === 'fulltext' ? 'text' : entry.order === 'desc' ? -1 : 1;
         }
+        const weights = fulltextWeights(index);
         return serializeMongoCommand({
             action: 'createIndex',
             collection: tableName,
@@ -130,6 +132,8 @@ export class MongoSchemaGenerator extends MongoDialect {
                 unique: index.unique,
                 name: index.name,
                 partialFilterExpression: index.where && JSON.parse(index.where),
+                weights: weights && Object.fromEntries(index.entries.map((entry, at) => [entry.column, weights[at]])),
+                default_language: index.type === 'fulltext' ? textLanguage(fulltextConfig(index)) : undefined,
             },
         });
     }

package/dist/migrate/introspection/mongoIntrospector.d.ts

@@ -7,7 +7,7 @@ import { type QuerierPool, type SchemaIntrospector, type TableSchema } from '../
  */
 export declare class MongoSchemaIntrospector implements SchemaIntrospector {
     private readonly pool;
-    /** `listIndexes` reports keys and uniqueness; a `partialFilterExpression` is no SQL predicate. */
+    /** `listIndexes` reports keys, uniqueness and text weights; a `partialFilterExpression` is no SQL predicate. */
     readonly indexFacets: ReadonlySet<IndexFacet>;
     constructor(pool: QuerierPool);
     introspect(tables?: readonly string[]): Promise<SchemaAST>;

package/dist/migrate/introspection/mongoIntrospector.js

@@ -1,3 +1,4 @@
+import { textConfigOf } from '../../mongo/mongoDialect.js';
 import { createTableNode, SchemaAST } from '../../schema/schemaAST.js';
 import { isMongoQuerier, } from '../../type/index.js';
 /** What a server without Atlas Search answers a search index command with. */
@@ -8,8 +9,8 @@ const SEARCH_NOT_ENABLED = 31082;
  */
 export class MongoSchemaIntrospector {
     pool;
-    /** `listIndexes` reports keys and uniqueness; a `partialFilterExpression` is no SQL predicate. */
-    indexFacets = new Set();
+    /** `listIndexes` reports keys, uniqueness and text weights; a `partialFilterExpression` is no SQL predicate. */
+    indexFacets = new Set(['textIndex']);
     constructor(pool) {
         this.pool = pool;
     }
@@ -38,10 +39,16 @@ export class MongoSchemaIntrospector {
                 name: tableName,
                 columns: [],
                 indexes: [
-                    ...indexes.map((idx) => ({
-                        name: idx.name ?? Object.keys(idx.key).join('_'),
-                        entries: Object.keys(idx.key).map((column) => ({ column })),
-                        unique: !!idx.unique,
+                    ...indexes.map(({ name, key, unique, weights, default_language }) => ({
+                        name: name ?? Object.keys(key).join('_'),
+                        unique: !!unique,
+                        ...(weights
+                            ? {
+                                entries: Object.entries(weights).map(textIndexEntry),
+                                type: 'fulltext',
+                                config: default_language && textConfigOf(default_language),
+                            }
+                            : { entries: Object.keys(key).map((column) => ({ column })) }),
                     })),
                     ...searchIndexes
                         .filter((idx) => idx.type === 'vectorSearch')
@@ -75,6 +82,10 @@ export class MongoSchemaIntrospector {
         });
     }
 }
+/** A text index field as an entity declares it: its weight stated only where it is not the default 1. */
+function textIndexEntry([column, weight]) {
+    return weight === 1 ? { column } : { column, weight };
+}
 /** A collection's Atlas search indexes, none where the server has no Atlas Search. */
 async function listSearchIndexes(collection) {
     try {

package/dist/migrate/schemaGenerator.d.ts

@@ -1,5 +1,6 @@
 import type { AbstractSqlDialect } from '../dialect/index.js';
 import type { SchemaAST } from '../schema/schemaAST.js';
+import { type BuildSchemaASTOptions } from '../schema/schemaASTBuilder.js';
 import { type DiffOptions } from '../schema/schemaASTDiffer.js';
 import type { CanonicalType, ColumnNode, ForeignKeyAction, IndexNode, TableNode } from '../schema/types.js';
 import type { ColumnSchema, CreateSchemaOptions, DialectFeatures, DropSchemaOptions, EntityMeta, EntityWhereMeta, FieldMeta, FieldOptions, ForeignKeySchema, IndexSchema, NamingStrategy, SchemaDiff, SchemaGenerator, Type } from '../type/index.js';
@@ -65,6 +66,8 @@ export declare class SqlSchemaGenerator implements SchemaGenerator {
     generateCreateIndex(tableName: string, index: IndexSchema, options?: {
         ifNotExists?: boolean;
     }): string;
+    /** An index added to a table that may already have rows: its `CREATE`, then what the engine needs after. */
+    private addIndexStatements;
     /**
      * `schema` is the table's, because that is where its indexes live. MySQL takes it from the table
      * operand instead, which is already qualified.
@@ -175,4 +178,4 @@ export declare class SqlSchemaGenerator implements SchemaGenerator {
  * The entities as an AST, named by `generator`'s resolvers rather than a naming strategy, which would
  * also rename an explicit `@Entity({ name })` and so compare each table under another name.
  */
-export declare function buildEntityAST(generator: Pick<SchemaGenerator, 'resolveTableAlias' | 'resolveSchema' | 'resolveColumnName' | 'compileDdl' | 'compileIndexPredicate'>, entities: readonly Type<object>[], defaultForeignKeyAction?: ForeignKeyAction): SchemaAST;
+export declare function buildEntityAST(generator: Pick<SchemaGenerator, 'resolveTableAlias' | 'resolveSchema' | 'resolveColumnName' | 'compileDdl' | 'compileIndexPredicate'>, entities: readonly Type<object>[], options?: Pick<BuildSchemaASTOptions, 'defaultForeignKeyAction' | 'textScoreIndexes'>): SchemaAST;

package/dist/migrate/schemaGenerator.js

@@ -74,7 +74,10 @@ export class SqlSchemaGenerator {
     }
     /** The entity side as an AST, carrying this generator's default referential action. */
     buildAST(entities) {
-        return buildEntityAST(this, entities, this.defaultForeignKeyAction);
+        return buildEntityAST(this, entities, {
+            defaultForeignKeyAction: this.defaultForeignKeyAction,
+            textScoreIndexes: this.dialect.features.textScoreIndexes,
+        });
     }
     /**
      * Every `CREATE TABLE` for `entities`, then their foreign keys, since a relation graph is routinely
@@ -115,7 +118,7 @@ export class SqlSchemaGenerator {
      * resolves instead of being silently dropped.
      */
     orderedTables(entities, direction, only) {
-        const ast = buildEntityAST(this, entities, this.defaultForeignKeyAction);
+        const ast = this.buildAST(entities);
         const tables = direction === 'create' ? ast.getCreateOrder() : ast.getDropOrder();
         if (!only) {
             return tables;
@@ -166,7 +169,7 @@ export class SqlSchemaGenerator {
         // Add indexes
         if (diff.indexesToAdd?.length) {
             for (const index of diff.indexesToAdd) {
-                statements.push(this.generateCreateIndex(diff.tableName, index));
+                statements.push(...this.addIndexStatements(diff.tableName, index));
             }
         }
         // Drop indexes
@@ -243,6 +246,10 @@ export class SqlSchemaGenerator {
     generateCreateIndex(tableName, index, options = {}) {
         return this.indexDdl.getCreateIndexStatement(tableName, index, options);
     }
+    /** An index added to a table that may already have rows: its `CREATE`, then what the engine needs after. */
+    addIndexStatements(tableName, index) {
+        return [this.generateCreateIndex(tableName, index), ...this.indexDdl.settleStatements(tableName, index)];
+    }
     /**
      * `schema` is the table's, because that is where its indexes live. MySQL takes it from the table
      * operand instead, which is already qualified.
@@ -338,7 +345,7 @@ export class SqlSchemaGenerator {
         }
         // Keyed by the qualified name this generator resolves, which is the key the AST stores the table
         // under.
-        const desired = (desiredAst ?? buildEntityAST(this, [entity], this.defaultForeignKeyAction)).getTable(tableName);
+        const desired = (desiredAst ?? this.buildAST([entity])).getTable(tableName);
         if (!desired) {
             return undefined;
         }
@@ -556,7 +563,7 @@ export class SqlSchemaGenerator {
             case 'alterColumn':
                 return this.generateAlterColumnSql(operation.tableName, operation.columnName, operation.changes);
             case 'createIndex':
-                return [this.generateCreateIndexFromDefinition(operation.tableName, operation.index)];
+                return this.addIndexStatements(operation.tableName, renderIndexDefinition(operation.index, (sql) => this.dialect.compileDdl(sql)));
             case 'dropIndex':
                 return [this.generateDropIndex(operation.tableName, operation.indexName)];
             case 'addForeignKey':
@@ -693,7 +700,7 @@ function foreignKeyOf(relation) {
  * The entities as an AST, named by `generator`'s resolvers rather than a naming strategy, which would
  * also rename an explicit `@Entity({ name })` and so compare each table under another name.
  */
-export function buildEntityAST(generator, entities, defaultForeignKeyAction) {
+export function buildEntityAST(generator, entities, options = {}) {
     return buildSchemaAST(entities, {
         // The alias, not `resolveTableName`: a node holds its schema separately, so that a name derived
         // from it stays a single identifier.
@@ -702,6 +709,6 @@ export function buildEntityAST(generator, entities, defaultForeignKeyAction) {
         resolveColumnName: (key, field) => generator.resolveColumnName(key, field),
         compileDdl: (sql, entity) => generator.compileDdl(sql, entity),
         compileIndexPredicate: (where, entity, indexName) => generator.compileIndexPredicate(where, entity, indexName),
-        defaultForeignKeyAction,
+        ...options,
     });
 }

package/dist/mongo/mongoDialect.d.ts

@@ -7,14 +7,25 @@ type MongoReadStages = {
     /** Ordering, which runs after the lookups when it reads one of their fields. */
     readonly sort?: Sort;
     readonly pager?: MongoAggregationPipelineEntry<Document>[];
-    /** Keys merged into the query's projection, when it has one: a vector search's score. */
-    readonly project?: Record<string, 1>;
+    /** A score the read answers as a field, a vector search's or a text search's; a temporary one leaves again. */
+    readonly score?: {
+        readonly field: string;
+        readonly meta: 'vectorSearchScore' | 'textScore';
+        readonly temporary?: boolean;
+    };
 };
 /** Accumulator threaded through `$where` rendering: the relation lookups it needs, and their temp fields. */
 type RelationLookups = {
     readonly stages: MongoAggregationPipelineEntry<Document>[];
     readonly temps: string[];
 };
+/**
+ * A text-search config as MongoDB names the language: the same word for each language both know, and
+ * `'none'` for the no-stemming parser Postgres calls `'simple'`. {@link textConfigOf} reads one back.
+ */
+export declare function textLanguage(config: string): string;
+/** A MongoDB language as the text-search config it is, the inverse of {@link textLanguage}. */
+export declare function textConfigOf(language: string): string;
 /** Default {@link DialectFeatures} for MongoDB. */
 export declare const mongoDialectFeatures: DialectFeatures;
 export declare class MongoDialect extends AbstractDialect {
@@ -220,6 +231,8 @@ export declare class MongoDialect extends AbstractDialect {
     normalizeIds<E extends Document>(meta: EntityMeta<E>, docs: Document[]): E[];
     /** `doc` is the wire shape - `_id`, stored names, `ObjectId`s - and what comes back is the code's. */
     normalizeId<E extends Document>(meta: EntityMeta<E>, doc: Document | undefined): E | undefined;
+    /** An aggregate's rows with each 64-bit integer decoded as a document's is: a `bigint` only where the column reads a `BigInt` field. */
+    normalizeAggregateRows<E extends Document, const G extends QueryGroupMap<E>, const A extends QueryAggMap<E>, R extends Document>(entity: Type<E>, q: QueryAggregate<E, G, A>, rows: R[]): R[];
     /**
      * A key as MongoDB stores it: a 24-hex string as an `ObjectId`, so a write matches the filter looking for
      * it, and anything else as given. Only 24-hex, not any 12-byte string. Arrays convert element-wise.

package/dist/mongo/mongoDialect.js

@@ -1,13 +1,25 @@
 import { ObjectId } from 'mongodb';
 import { AbstractDialect } from '../dialect/abstractDialect.js';
 import { AGGREGATE_VALUE_ALIAS, REL_NESTED_KEY, REL_TEMP_PREFIX, SUM_COUNT_ALIAS, sortCountField, TEXT_SCORE_ALIAS, } from '../dialect/aliases.js';
-import { groupPathField, resolveGroupJoins, resolveQueryJoins, resolveSortableJoin, } from '../dialect/queryJoins.js';
+import { aggregateColumnField, groupPathField, resolveGroupJoins, resolveQueryJoins, resolveSortableJoin, } from '../dialect/queryJoins.js';
 import { assertSoleId, fieldOf, getMeta, relationOf, soleIdOf } from '../entity/index.js';
 import { COUNT_RESULT_KEY } from '../type/query.js';
 import { QueryRaw } from '../type/queryRaw.js';
-import { aggregateOf, asSelectMap, assertAggregateColumns, assertNonNegativeInteger, columnFamily, countedRelations, entityName, fieldUpdateOf, fillOnFields, filterFieldKeys, findVectorIndex, findVectorSort, getKeys, getRelationRequestSummary, hasKeys, isFieldUpdateOp, isJsonObject, isJsonUpdateOp, isOperatorMap, isOperatorObject, isRecord, isVectorSearch, normalizeScalarFieldSelection, parentJoins, parseGroupMap, parseRelationAtKey, parseRelationSize, parseSortByCount, rankedTextSearch, someKey, targetKeyColumns, } from '../util/index.js';
+import { aggregateOf, asSelectMap, assertAggregateColumns, assertNonNegativeInteger, columnFamily, countedRelations, entityName, fieldUpdateOf, fillOnFields, filterFieldKeys, findVectorIndex, findVectorSort, getKeys, getRelationRequestSummary, hasKeys, isFieldUpdateOp, isJsonObject, isJsonUpdateOp, isOperatorMap, isOperatorObject, isRecord, isVectorSearch, normalizeScalarFieldSelection, parentJoins, parseGroupMap, parseRelationAtKey, parseRelationSize, parseSortByCount, rankedTextSearch, someKey, targetKeyColumns, textSortOf, } from '../util/index.js';
+import { decodeBigIntsExcept } from '../util/wideNumber.js';
 /** A scalar field's operator as the aggregation operator computing it. */
 const MONGO_ARITHMETIC = { $inc: '$add', $mul: '$multiply' };
+/**
+ * A text-search config as MongoDB names the language: the same word for each language both know, and
+ * `'none'` for the no-stemming parser Postgres calls `'simple'`. {@link textConfigOf} reads one back.
+ */
+export function textLanguage(config) {
+    return config === 'simple' ? 'none' : config;
+}
+/** A MongoDB language as the text-search config it is, the inverse of {@link textLanguage}. */
+export function textConfigOf(language) {
+    return language === 'none' ? 'simple' : language;
+}
 /** Default {@link DialectFeatures} for MongoDB. */
 export const mongoDialectFeatures = {
     ifNotExists: false,
@@ -99,7 +111,8 @@ export class MongoDialect extends AbstractDialect {
             else if (key === '$text') {
                 // MongoDB's text index declares which fields it covers, so `$fields` cannot narrow the search
                 // the way it does elsewhere - the same shape as `$distance` being index-defined here.
-                filter['$text'] = { $search: val.$value };
+                const { $value, $config } = val;
+                filter['$text'] = { $search: $value, ...($config && { $language: textLanguage($config) }) };
             }
             else if (meta.relations[key]) {
                 this.assertNoRaw(val);
@@ -477,7 +490,8 @@ export class MongoDialect extends AbstractDialect {
                 if (path) {
                     throw new TypeError(`$sort by $text is only supported on the queried entity, not on relation '${path.slice(0, -1)}'`);
                 }
-                out[TEXT_SCORE_ALIAS] = { $meta: 'textScore' };
+                const { order, project } = textSortOf(sort);
+                out[project ?? TEXT_SCORE_ALIAS] = sortDirection(order);
                 continue;
             }
             if (!relation) {
@@ -679,11 +693,14 @@ export class MongoDialect extends AbstractDialect {
         return this.columnOf(meta, key.slice(0, dot)) + key.slice(dot);
     }
     aggregationPipeline(entity, q, opts) {
+        // Sorted as a field, which goes either way where a `$meta` sort only descends.
+        const text = textSortOf(q.$sort);
         return [
             ...this.matchStages(entity, q.$where, opts, this.aggregateKeys(entity, q)),
             ...this.readStages(entity, q, {
                 sort: this.sort(entity, q),
                 pager: this.pagerStages(q),
+                score: text && { field: text.project ?? TEXT_SCORE_ALIAS, meta: 'textScore', temporary: !text.project },
             }),
         ];
     }
@@ -709,10 +726,17 @@ export class MongoDialect extends AbstractDialect {
         const related = this.relationReadStages(entity, q);
         const sort = hasKeys(extra.sort) ? [{ $sort: extra.sort }] : [];
         const pager = extra.pager ?? [];
-        // Merged into the query's own projection rather than standing in for one: a query that asked
-        // for no columns wants the whole document, not just the field this adds to it.
+        // The score becomes a real field before anything reads it, so the lookups, the sort and the projection
+        // that follow treat it like any other; merged into the query's own projection rather than standing in
+        // for one, since a query that asked for no columns wants the whole document as well.
+        const { score } = extra;
+        if (score && !score.temporary) {
+            this.assertProjectable(meta, score.field);
+        }
+        const scored = score ? [{ $addFields: { [score.field]: { $meta: score.meta } } }] : [];
+        const unscored = score?.temporary ? [{ $unset: [score.field] }] : [];
         const projection = this.pipelineProjection(entity, q);
-        const projected = projection ? { ...projection, ...extra.project } : undefined;
+        const projected = projection && score ? { ...projection, [score.field]: 1 } : projection;
         const project = projected ? [{ $project: projected }] : [];
         // A `$lookup` the ordering asked for puts a field on the document the caller never requested,
         // which is the one way this differs from a SQL join. Taken back out once the `$sort` that needed
@@ -734,7 +758,7 @@ export class MongoDialect extends AbstractDialect {
         // ordering and the page have to run after it to address the set the caller actually receives.
         const dedup = q.$distinct ? this.distinctStages(projected) : [];
         if (dedup.length) {
-            return [...lookups, ...related, ...project, ...dedup, ...sort, ...pager];
+            return [...scored, ...lookups, ...related, ...project, ...dedup, ...sort, ...pager, ...unscored];
         }
         // A `$required` relation drops parents when it unwinds, and an ordering may read a field only a
         // lookup produces: either one puts the lookups first, as an INNER JOIN does. Otherwise paging
@@ -742,10 +766,12 @@ export class MongoDialect extends AbstractDialect {
         const lookupsFirst = this.sortsRelations(entity, q.$sort) ||
             lookups.some((stage) => stage.$unwind?.preserveNullAndEmptyArrays === false);
         return [
+            ...scored,
             ...(lookupsFirst ? [...lookups, ...sort, ...pager] : [...sort, ...pager, ...lookups]),
             ...related,
             ...unset,
             ...project,
+            ...unscored,
         ];
     }
     /**
@@ -894,6 +920,9 @@ export class MongoDialect extends AbstractDialect {
                 res[key] = this.fromWireId(res[key]);
             }
         }
+        // A 64-bit integer, which the pool reads as a `bigint`: kept for a `BigInt` field, and elsewhere the
+        // number it is where exact and its exact text past 2^53, as every SQL driver decodes one.
+        decodeBigIntsExcept(res, (key) => meta.fields[key]?.type === BigInt);
         const relKeys = getKeys(meta.relations).filter((key) => res[key]);
         for (const relKey of relKeys) {
             const relMeta = getMeta(relationOf(meta, relKey).entity());
@@ -903,6 +932,18 @@ export class MongoDialect extends AbstractDialect {
         }
         return res;
     }
+    /** An aggregate's rows with each 64-bit integer decoded as a document's is: a `bigint` only where the column reads a `BigInt` field. */
+    normalizeAggregateRows(entity, q, rows) {
+        const meta = getMeta(entity);
+        const { joins } = resolveGroupJoins(meta, q);
+        const exact = new Set(parseGroupMap(q.$group, q.$select)
+            .filter((entry) => aggregateColumnField(meta, joins, entry)?.field?.type === BigInt)
+            .map((entry) => entry.alias));
+        for (const row of rows) {
+            decodeBigIntsExcept(row, (key) => exact.has(key));
+        }
+        return rows;
+    }
     /**
      * A key as MongoDB stores it: a 24-hex string as an `ObjectId`, so a write matches the filter looking for
      * it, and anything else as given. Only 24-hex, not any 12-byte string. Arrays convert element-wise.