uql-orm 0.20.2 → 0.22.0

package/dist/migrate/schemaGenerator.js

@@ -4,11 +4,7 @@ import { areTypesEqual, canonicalToSql, fieldOptionsToCanonical, isVectorCategor
 import { SchemaASTBuilder } from '../schema/schemaASTBuilder.js';
 import { escapeSqlId, getKeys, isAutoIncrement } from '../util/index.js';
 import { formatDefaultValue } from './builder/expressions.js';
-/** Maps UQL distance metric names to inline DDL keywords (e.g. MariaDB `DISTANCE=euclidean`). */
-const INLINE_VECTOR_DISTANCE_MAP = new Map([
-    ['cosine', 'cosine'],
-    ['l2', 'euclidean'],
-]);
+import { indexNodeToSchema } from './generator/indexNodeToSchema.js';
 /**
  * Unified SQL schema generator.
  * Parameterized by dialect to handle Postgres, MySQL, MariaDB, and SQLite.
@@ -53,15 +49,7 @@ export class SqlSchemaGenerator {
     getCanonicalType(field, fieldType) {
         return fieldOptionsToCanonical(field, fieldType);
     }
-    /**
-     * Convert CanonicalType to SQL type string for this dialect.
-     * Also handles legacy string types for backward compatibility.
-     */
     canonicalTypeToSql(type) {
-        // Handle legacy string types
-        if (typeof type === 'string') {
-            return type;
-        }
         return canonicalToSql(type, this.dialect);
     }
     // ============================================================================
@@ -73,10 +61,10 @@ export class SqlSchemaGenerator {
         const tableNode = ast.getTables()[0];
         return this.generateCreateTableFromNode(tableNode, options);
     }
-    generateDropTable(entity) {
-        const meta = getMeta(entity);
-        const tableName = this.dialect.resolveTableName(entity, meta);
-        return `DROP TABLE IF EXISTS ${this.escapeId(tableName)};`;
+    generateDropTable(tableName, options = {}) {
+        const ifExists = options.ifExists ? 'IF EXISTS ' : '';
+        const cascade = options.cascade && this.features.dropTableCascade ? ' CASCADE' : '';
+        return `DROP TABLE ${ifExists}${this.escapeId(tableName)}${cascade};`;
     }
     generateAlterTable(diff) {
         const statements = [];
@@ -145,48 +133,7 @@ export class SqlSchemaGenerator {
         return statements;
     }
     generateCreateIndex(tableName, index, options = {}) {
-        const unique = index.unique ? 'UNIQUE ' : '';
-        const ifNotExists = (options.ifNotExists ?? this.features.indexIfNotExists) ? 'IF NOT EXISTS ' : '';
-        const opsClassMap = this.dialect.vectorOpsClass;
-        // CockroachDB's native vector index has one algorithm (no hnsw/ivfflat choice), so `type: 'vector'`
-        // is its trigger - same generic value MariaDB's inline style already uses (see `isInlineVectorIdx`).
-        const isNativeVectorIndex = this.features.vectorIndexStyle === 'native' && index.type === 'vector';
-        const hasOpsClass = opsClassMap && (isNativeVectorIndex || index.type === 'hnsw' || index.type === 'ivfflat');
-        // For pgvector/CockroachDB vector indexes: append operator class to the column. Throws rather
-        // than silently omitting the operator class for an unsupported distance - e.g. a bare
-        // `CREATE VECTOR INDEX ... (col)` on CockroachDB would build using its default distance
-        // metric instead of the one actually requested, with no error to signal the mismatch.
-        const columns = index.columns
-            .map((c) => {
-            const escaped = this.escapeId(c);
-            if (!opsClassMap || !hasOpsClass || !index.distance) {
-                return escaped;
-            }
-            const opsClass = opsClassMap.get(index.distance);
-            if (!opsClass) {
-                throw new TypeError(`${this.dialect.dialectName} does not support vector distance metric: ${index.distance} (index "${index.name}")`);
-            }
-            return `${escaped} ${opsClass}`;
-        })
-            .join(', ');
-        // CockroachDB has no access-method keyword: `CREATE VECTOR INDEX ... (col)`, not
-        // `CREATE INDEX ... USING vector (col)`.
-        const indexKeyword = isNativeVectorIndex ? 'VECTOR INDEX' : 'INDEX';
-        const using = !isNativeVectorIndex && index.type ? ` USING ${index.type}` : '';
-        // Build WITH params for pgvector indexes with operator class support. CockroachDB's native
-        // vector index has its own, differently-named tuning knobs - not generated here.
-        let withClause = '';
-        if (hasOpsClass && !isNativeVectorIndex) {
-            const withParams = [];
-            if (index.m !== undefined)
-                withParams.push(`m = ${index.m}`);
-            if (index.efConstruction !== undefined)
-                withParams.push(`ef_construction = ${index.efConstruction}`);
-            if (index.lists !== undefined)
-                withParams.push(`lists = ${index.lists}`);
-            withClause = withParams.length > 0 ? ` WITH (${withParams.join(', ')})` : '';
-        }
-        return `CREATE ${unique}${indexKeyword} ${ifNotExists}${this.escapeId(index.name)} ON ${this.escapeId(tableName)}${using} (${columns})${withClause};`;
+        return this.dialect.getCreateIndexStatement(tableName, index, options);
     }
     generateDropIndex(tableName, indexName) {
         if (this.dialect.dropIndexSyntax === 'on-table') {
@@ -195,19 +142,15 @@ export class SqlSchemaGenerator {
         return `DROP INDEX IF EXISTS ${this.escapeId(indexName)};`;
     }
     /**
-     * Generate column definition from a ColumnSchema object
+     * Generate a column definition from a {@link ColumnSchema}, whose type is the engine's own spelling
+     * and may already carry its precision (or even `PRIMARY KEY`, for a serial).
      */
     generateColumnDefinitionFromSchema(column, options = {}) {
         const { includePrimaryKey = true, includeUnique = true } = options;
         let type = column.type;
         if (!type.includes('(')) {
             if (column.precision !== undefined) {
-                if (column.scale !== undefined) {
-                    type += `(${column.precision}, ${column.scale})`;
-                }
-                else {
-                    type += `(${column.precision})`;
-                }
+                type += column.scale === undefined ? `(${column.precision})` : `(${column.precision}, ${column.scale})`;
             }
             else if (column.length !== undefined) {
                 type += `(${column.length})`;
@@ -216,23 +159,38 @@ export class SqlSchemaGenerator {
         if (!includePrimaryKey) {
             type = type.replace(/\s+PRIMARY\s+KEY/i, '');
         }
-        let definition = `${this.escapeId(column.name)} ${type}`;
-        if (includePrimaryKey && column.isPrimaryKey && !type.includes('PRIMARY KEY')) {
-            definition += ' PRIMARY KEY';
+        // `includePrimaryKey: false` suppresses the keyword, not the fact: the column is still the primary
+        // key, so it must not pick up `NOT NULL` (implied) or `UNIQUE` (redundant) on the way out.
+        return this.renderColumn({
+            ...column,
+            type,
+            isUnique: column.isUnique && includeUnique,
+            declaresPrimaryKey: includePrimaryKey && column.isPrimaryKey,
+        });
+    }
+    /**
+     * The one place a column definition is spelled. Both callers reach it - the `ColumnSchema` path above
+     * and the `ColumnNode` path below - because the clause order and the "no NOT NULL on a primary key"
+     * rules are the same everywhere, and having them written twice is how the two paths drifted.
+     */
+    renderColumn(column) {
+        let def = `${this.escapeId(column.name)} ${column.type}`;
+        if (column.declaresPrimaryKey && !column.type.includes('PRIMARY KEY')) {
+            def += ' PRIMARY KEY';
         }
         if (!column.nullable && !column.isPrimaryKey) {
-            definition += ' NOT NULL';
+            def += ' NOT NULL';
         }
-        if (includeUnique && column.isUnique && !column.isPrimaryKey) {
-            definition += ' UNIQUE';
+        if (column.isUnique && !column.isPrimaryKey) {
+            def += ' UNIQUE';
         }
         if (column.defaultValue !== undefined) {
-            definition += ` DEFAULT ${this.formatDefaultValue(column.defaultValue)}`;
+            def += ` DEFAULT ${this.formatDefaultValue(column.defaultValue)}`;
         }
         if (column.comment) {
-            definition += this.generateColumnComment(column.name, column.comment);
+            def += this.generateColumnComment(column.name, column.comment);
         }
-        return definition;
+        return def;
     }
     getSqlType(field, fieldType) {
         // If field has a reference, inherit type from the target primary key
@@ -250,12 +208,6 @@ export class SqlSchemaGenerator {
         }
         return this.canonicalTypeToSql(canonical);
     }
-    /**
-     * Get the boolean type for this database
-     */
-    getBooleanType() {
-        return this.canonicalTypeToSql({ category: 'boolean' });
-    }
     /**
      * Generate ALTER COLUMN statements (database-specific)
      */
@@ -286,12 +238,6 @@ export class SqlSchemaGenerator {
         }
         return [`ALTER TABLE ${table} ${this.dialect.alterColumnSyntax} ${newDefinition};`];
     }
-    /**
-     * Get table options (e.g., ENGINE for MySQL)
-     */
-    getTableOptions(_meta) {
-        return this.dialect.tableOptions ? ` ${this.dialect.tableOptions}` : '';
-    }
     /**
      * Generate column comment clause (if supported)
      */
@@ -372,7 +318,8 @@ export class SqlSchemaGenerator {
         };
     }
     /**
-     * Convert field options to ColumnSchema
+     * Convert field options to ColumnSchema. Both sides of a diff are the engine's SQL spelling: what it
+     * would create for this field, against what it reported for the existing column.
      */
     fieldToColumnSchema(fieldKey, field, meta) {
         const isPrimaryKey = field.isId === true && meta.id === fieldKey;
@@ -410,12 +357,16 @@ export class SqlSchemaGenerator {
         return false;
     }
     /**
-     * Compare two column types for equality using the canonical type system
+     * Whether two column types are the same *as this engine stores them*.
+     *
+     * Both sides are SQL spellings, parsed back to canonical so that `INT` and `INTEGER`, or `DATETIME`
+     * and `TIMESTAMP`, do not read as a change. Do not "simplify" this into comparing the entity's
+     * canonical type against the column's: several canonical types share one storage type per engine
+     * (`boolean` is `TINYINT(1)` on MySQL and `INTEGER` on SQLite), so that comparison reports an
+     * alteration for those columns on every single sync.
      */
     isTypeEqual(current, desired) {
-        const typeA = sqlToCanonical(current.type);
-        const typeB = sqlToCanonical(desired.type);
-        return areTypesEqual(typeA, typeB);
+        return areTypesEqual(sqlToCanonical(current.type), sqlToCanonical(desired.type));
     }
     /**
      * Compare two default values for equality
@@ -445,8 +396,14 @@ export class SqlSchemaGenerator {
     generateCreateTableFromNode(table, options = {}) {
         const columns = [];
         const constraints = [];
+        const isInlineVectorIdx = this.features.inlineVectorIndex;
+        const vectorIndexes = isInlineVectorIdx ? table.indexes.filter((idx) => idx.type === 'vector') : [];
+        const regularIndexes = isInlineVectorIdx ? table.indexes.filter((idx) => idx.type !== 'vector') : table.indexes;
+        // MariaDB rejects a `VECTOR INDEX` whose column is nullable ("All parts of a VECTOR index must
+        // be NOT NULL"), so being indexed decides it rather than the entity's own nullability.
+        const indexedVectorColumns = new Set(vectorIndexes.flatMap((idx) => idx.columns.map((col) => col.name)));
         for (const col of table.columns.values()) {
-            const colDef = this.generateColumnFromNode(col);
+            const colDef = this.generateColumnFromNode(indexedVectorColumns.has(col.name) ? { ...col, nullable: false } : col);
             columns.push(colDef);
         }
         if (table.primaryKey.length > 1) {
@@ -469,12 +426,11 @@ export class SqlSchemaGenerator {
             createSql += ',\n';
             createSql += constraints.map((c) => `  ${c}`).join(',\n');
         }
-        const isInlineVectorIdx = this.features.vectorIndexStyle === 'inline';
-        const vectorIndexes = isInlineVectorIdx ? table.indexes.filter((idx) => idx.type === 'vector') : [];
-        const regularIndexes = isInlineVectorIdx ? table.indexes.filter((idx) => idx.type !== 'vector') : table.indexes;
         if (vectorIndexes.length > 0) {
             createSql += ',\n';
-            createSql += vectorIndexes.map((idx) => `  ${this.generateInlineVectorIndex(idx)}`).join(',\n');
+            createSql += vectorIndexes
+                .map((idx) => `  ${this.dialect.getInlineVectorIndexDeclaration(indexNodeToSchema(idx))}`)
+                .join(',\n');
         }
         createSql += '\n)';
         if (this.dialect.tableOptions) {
@@ -495,73 +451,22 @@ export class SqlSchemaGenerator {
         return statements;
     }
     /**
-     * Generate a column definition from a ColumnNode.
+     * Generate a column definition from a ColumnNode. A composite key is declared as a table constraint,
+     * so only a lone primary key column carries `PRIMARY KEY` inline.
      */
     generateColumnFromNode(col) {
-        const colName = this.escapeId(col.name);
-        let sqlType = this.canonicalTypeToSql(col.type);
-        if (col.isPrimaryKey && col.isAutoIncrement) {
-            sqlType = this.serialPrimaryKeyType;
-        }
-        let def = `${colName} ${sqlType}`;
-        if (!col.nullable && !col.isPrimaryKey) {
-            def += ' NOT NULL';
-        }
-        if (col.isPrimaryKey && col.table.primaryKey.length === 1 && !sqlType.includes('PRIMARY KEY')) {
-            def += ' PRIMARY KEY';
-        }
-        if (col.isUnique && !col.isPrimaryKey) {
-            def += ' UNIQUE';
-        }
-        if (col.defaultValue !== undefined) {
-            def += ` DEFAULT ${this.formatDefaultValue(col.defaultValue)}`;
-        }
-        if (col.comment) {
-            def += this.generateColumnComment(col.name, col.comment);
-        }
-        return def;
-    }
-    /**
-     * Generate an inline VECTOR INDEX clause for use inside CREATE TABLE.
-     * Syntax: `VECTOR INDEX (col) M=n DISTANCE=metric`
-     */
-    generateInlineVectorIndex(index) {
-        const columns = index.columns.map((c) => this.escapeId(c.name)).join(', ');
-        let clause = `VECTOR INDEX (${columns})`;
-        if (index.m !== undefined) {
-            clause += ` M=${index.m}`;
-        }
-        if (index.distance) {
-            const metric = INLINE_VECTOR_DISTANCE_MAP.get(index.distance);
-            if (!metric) {
-                throw new TypeError(`${this.dialect.dialectName} does not support vector distance metric: ${index.distance} (index "${index.name}")`);
-            }
-            clause += ` DISTANCE=${metric}`;
-        }
-        return clause;
+        return this.renderColumn({
+            ...col,
+            type: col.isPrimaryKey && col.isAutoIncrement ? this.serialPrimaryKeyType : this.canonicalTypeToSql(col.type),
+            declaresPrimaryKey: col.isPrimaryKey && col.table.primaryKey.length === 1,
+        });
     }
     /**
      * Generate CREATE INDEX SQL from an IndexNode.
      * Delegates to `generateCreateIndex` for unified SQL assembly.
      */
     generateCreateIndexFromNode(index, options = { ifNotExists: false }) {
-        return this.generateCreateIndex(index.table.name, {
-            name: index.name,
-            columns: index.columns.map((c) => c.name),
-            unique: index.unique,
-            type: index.type,
-            distance: index.distance,
-            m: index.m,
-            efConstruction: index.efConstruction,
-            lists: index.lists,
-        }, options);
-    }
-    /**
-     * Generate DROP TABLE SQL from a TableNode.
-     */
-    generateDropTableFromNode(table, options = {}) {
-        const ifExists = options.ifExists ? 'IF EXISTS ' : '';
-        return `DROP TABLE ${ifExists}${this.escapeId(table.name)};`;
+        return this.generateCreateIndex(index.table.name, indexNodeToSchema(index), options);
     }
     // ============================================================================
     // Phase 3: Builder Operation Methods (Moved forward for unification)
@@ -570,12 +475,6 @@ export class SqlSchemaGenerator {
         const tableNode = this.tableDefinitionToNode(table);
         return this.generateCreateTableFromNode(tableNode, options);
     }
-    generateDropTableSql(tableName, options) {
-        const ifExists = options?.ifExists ? 'IF EXISTS ' : '';
-        // Use dialect-specific cascade support from config
-        const cascade = options?.cascade && this.features.dropTableCascade ? ' CASCADE' : '';
-        return `DROP TABLE ${ifExists}${this.escapeId(tableName)}${cascade};`;
-    }
     generateRenameTableSql(oldName, newName) {
         if (this.dialect.renameTableSyntax === 'rename-table') {
             return `RENAME TABLE ${this.escapeId(oldName)} TO ${this.escapeId(newName)};`;
@@ -587,8 +486,8 @@ export class SqlSchemaGenerator {
         return `ALTER TABLE ${this.escapeId(tableName)} ADD COLUMN ${colSql};`;
     }
     generateAlterColumnSql(tableName, columnName, column) {
-        const colSql = this.generateColumnFromNode(this.fullColumnDefinitionToNode(column, tableName));
-        return this.generateAlterColumnStatements(tableName, { name: columnName, type: '' }, colSql).join('\n');
+        const node = this.fullColumnDefinitionToNode(column, tableName);
+        return this.generateAlterColumnStatements(tableName, { ...this.columnNodeToSchema(node), name: columnName }, this.generateColumnFromNode(node)).join('\n');
     }
     generateDropColumnSql(tableName, columnName) {
         return `ALTER TABLE ${this.escapeId(tableName)} DROP COLUMN ${this.escapeId(columnName)};`;
@@ -596,12 +495,6 @@ export class SqlSchemaGenerator {
     generateRenameColumnSql(tableName, oldName, newName) {
         return `ALTER TABLE ${this.escapeId(tableName)} RENAME COLUMN ${this.escapeId(oldName)} TO ${this.escapeId(newName)};`;
     }
-    generateCreateIndexSql(tableName, index) {
-        return this.generateCreateIndex(tableName, index);
-    }
-    generateDropIndexSql(tableName, indexName) {
-        return this.generateDropIndex(tableName, indexName);
-    }
     generateAddForeignKeySql(tableName, foreignKey) {
         const fkCols = foreignKey.columns.map((c) => this.escapeId(c)).join(', ');
         const refCols = foreignKey.referencesColumns.map((c) => this.escapeId(c)).join(', ');
@@ -645,10 +538,12 @@ export class SqlSchemaGenerator {
         table.primaryKey = finalPrimaryKey;
         for (const idxDef of def.indexes) {
             const indexNode = {
-                name: idxDef.name,
+                ...idxDef,
                 table,
-                columns: idxDef.columns.map((name) => columns.get(name)).filter((c) => c !== undefined),
-                unique: idxDef.unique,
+                columns: idxDef.columns
+                    .map((entry) => (entry.expression ? undefined : columns.get(entry.column)))
+                    .filter((c) => c !== undefined),
+                entries: idxDef.columns,
             };
             table.indexes.push(indexNode);
         }
@@ -703,10 +598,9 @@ export class SqlSchemaGenerator {
  * Synchronous factory for SQL schema generators only.
  * For MongoDB, use `createSchemaGeneratorAsync` from `./schemaGeneratorAsync.js` so the optional `mongodb` peer is not loaded at import time.
  */
-export function createSchemaGenerator(dialect, namingStrategy, defaultForeignKeyAction) {
+export function createSchemaGenerator(dialect, defaultForeignKeyAction) {
     if (!(dialect instanceof AbstractSqlDialect)) {
         return undefined;
     }
     return new SqlSchemaGenerator(dialect, defaultForeignKeyAction);
 }
-//# sourceMappingURL=schemaGenerator.js.map

package/dist/migrate/schemaGeneratorAsync.d.ts

@@ -1,9 +1,8 @@
 import type { AbstractDialect } from '../dialect/abstractDialect.js';
 import type { ForeignKeyAction } from '../schema/types.js';
-import type { NamingStrategy, SchemaGenerator } from '../type/index.js';
+import type { SchemaGenerator } from '../type/index.js';
 /**
  * Async factory for schema generators. Use this for MongoDB so the optional peer
  * `mongodb` is only loaded when this path runs. SQL dialects delegate to {@link createSchemaGenerator}.
  */
-export declare function createSchemaGeneratorAsync(dialect: AbstractDialect, namingStrategy?: NamingStrategy, defaultForeignKeyAction?: ForeignKeyAction): Promise<SchemaGenerator | undefined>;
-//# sourceMappingURL=schemaGeneratorAsync.d.ts.map
+export declare function createSchemaGeneratorAsync(dialect: AbstractDialect, defaultForeignKeyAction?: ForeignKeyAction): Promise<SchemaGenerator | undefined>;

package/dist/migrate/schemaGeneratorAsync.js

@@ -3,11 +3,10 @@ import { createSchemaGenerator } from './schemaGenerator.js';
  * Async factory for schema generators. Use this for MongoDB so the optional peer
  * `mongodb` is only loaded when this path runs. SQL dialects delegate to {@link createSchemaGenerator}.
  */
-export async function createSchemaGeneratorAsync(dialect, namingStrategy, defaultForeignKeyAction) {
+export async function createSchemaGeneratorAsync(dialect, defaultForeignKeyAction) {
     if (dialect.dialectName === 'mongodb') {
         const { MongoSchemaGenerator } = await import('./generator/mongoSchemaGenerator.js');
-        return new MongoSchemaGenerator(namingStrategy, defaultForeignKeyAction);
+        return new MongoSchemaGenerator(dialect.namingStrategy, defaultForeignKeyAction);
     }
-    return createSchemaGenerator(dialect, namingStrategy, defaultForeignKeyAction);
+    return createSchemaGenerator(dialect, defaultForeignKeyAction);
 }
-//# sourceMappingURL=schemaGeneratorAsync.js.map

package/dist/migrate/storage/databaseStorage.d.ts

@@ -22,4 +22,3 @@ export declare class DatabaseMigrationStorage implements MigrationStorage {
      */
     unlogWithQuerier(querier: SqlQuerier, migrationName: string): Promise<void>;
 }
-//# sourceMappingURL=databaseStorage.d.ts.map

package/dist/migrate/storage/databaseStorage.js

@@ -31,7 +31,7 @@ export class DatabaseMigrationStorage {
     }
     async createTableIfNotExists(querier) {
         const { dialect } = querier;
-        const sql = `
+        const sql = /*sql*/ `
       CREATE TABLE IF NOT EXISTS ${dialect.escapeId(this.tableName)} (
         ${dialect.escapeId('name')} VARCHAR(255) PRIMARY KEY,
         ${dialect.escapeId('executed_at')} TIMESTAMP DEFAULT CURRENT_TIMESTAMP
@@ -48,7 +48,7 @@ export class DatabaseMigrationStorage {
         }
         try {
             const { dialect } = querier;
-            const sql = `SELECT ${dialect.escapeId('name')} FROM ${dialect.escapeId(this.tableName)} ORDER BY ${dialect.escapeId('name')} ASC`;
+            const sql = /*sql*/ `SELECT ${dialect.escapeId('name')} FROM ${dialect.escapeId(this.tableName)} ORDER BY ${dialect.escapeId('name')} ASC`;
             const results = await querier.all(sql);
             return results.map((r) => r.name);
         }
@@ -62,7 +62,7 @@ export class DatabaseMigrationStorage {
     async logWithQuerier(querier, migrationName) {
         await this.ensureStorage();
         const { dialect } = querier;
-        const sql = `INSERT INTO ${dialect.escapeId(this.tableName)} (${dialect.escapeId('name')}) VALUES (${dialect.placeholder(1)})`;
+        const sql = /*sql*/ `INSERT INTO ${dialect.escapeId(this.tableName)} (${dialect.escapeId('name')}) VALUES (${dialect.placeholder(1)})`;
         await querier.run(sql, [migrationName]);
     }
     /**
@@ -71,8 +71,7 @@ export class DatabaseMigrationStorage {
     async unlogWithQuerier(querier, migrationName) {
         await this.ensureStorage();
         const { dialect } = querier;
-        const sql = `DELETE FROM ${dialect.escapeId(this.tableName)} WHERE ${dialect.escapeId('name')} = ${dialect.placeholder(1)}`;
+        const sql = /*sql*/ `DELETE FROM ${dialect.escapeId(this.tableName)} WHERE ${dialect.escapeId('name')} = ${dialect.placeholder(1)}`;
         await querier.run(sql, [migrationName]);
     }
 }
-//# sourceMappingURL=databaseStorage.js.map

package/dist/migrate/storage/index.d.ts

@@ -1,3 +1,2 @@
 export * from './databaseStorage.js';
 export * from './jsonStorage.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/migrate/storage/index.js

@@ -1,3 +1,2 @@
 export * from './databaseStorage.js';
 export * from './jsonStorage.js';
-//# sourceMappingURL=index.js.map

package/dist/migrate/storage/jsonStorage.d.ts

@@ -13,4 +13,3 @@ export declare class JsonMigrationStorage implements MigrationStorage {
     unlogWithQuerier(_querier: SqlQuerier, migrationName: string): Promise<void>;
     private save;
 }
-//# sourceMappingURL=jsonStorage.d.ts.map

package/dist/migrate/storage/jsonStorage.js

@@ -40,4 +40,3 @@ export class JsonMigrationStorage {
         await fs.writeFile(this.filePath, JSON.stringify(this.executedMigrations, null, 2), 'utf-8');
     }
 }
-//# sourceMappingURL=jsonStorage.js.map

package/dist/mongo/index.d.ts

@@ -3,4 +3,3 @@ export * from './mongoDialect.js';
 export * from './mongodbNativeDialect.js';
 export * from './mongodbQuerier.js';
 export * from './mongodbQuerierPool.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/mongo/index.js

@@ -3,4 +3,3 @@ export * from './mongoDialect.js';
 export * from './mongodbNativeDialect.js';
 export * from './mongodbQuerier.js';
 export * from './mongodbQuerierPool.js';
-//# sourceMappingURL=index.js.map

package/dist/mongo/mongoDialect.d.ts

@@ -1,19 +1,77 @@
 import { type Document, type Filter, ObjectId, type Sort, type UpdateFilter } from 'mongodb';
 import { AbstractDialect } from '../dialect/abstractDialect.js';
-import type { DialectFeatures, EntityMeta, FieldValue, Query, QueryAggMap, QueryAggregate, QueryExclude, QueryGroupMap, QueryOptions, QuerySelectValue, QuerySortMap, QueryVectorSearch, QueryWhere, RelationKey, Type } from '../type/index.js';
+import type { DialectFeatures, EntityMeta, FieldValue, Query, QueryAggMap, QueryAggregate, QueryExclude, QueryGroupMap, QueryOptions, QuerySelectValue, QuerySortMap, QueryVectorSearch, QueryWhere, Type } from '../type/index.js';
 import { type CallbackKey, type RelationRequestSummary } from '../util/index.js';
 /** Default {@link DialectFeatures} for MongoDB; shared by {@link MongoDialect} and its schema generator. */
 export declare const mongoDialectFeatures: DialectFeatures;
 export declare class MongoDialect extends AbstractDialect {
+    #private;
     protected readonly featureDefaults: DialectFeatures;
     readonly dialectName = "mongodb";
     readonly insertIdSource = "returning";
     private static readonly ID_KEY;
+    /** Temporary lookup fields for relation conditions, dropped with `$unset` after the `$match`. */
+    private static readonly REL_TEMP_PREFIX;
+    private static readonly REL_COUNT_KEY;
+    private static readonly REL_NESTED_KEY;
     private static readonly VECTOR_INDEX_TYPES;
+    /** Atlas rejects a `$vectorSearch` asking for more candidates than this. */
+    private static readonly MAX_NUM_CANDIDATES;
     private static readonly AGGREGATE_OP_MAP;
+    /**
+     * MongoDB stores the primary key as `_id`; everything else resolves as usual. Projections, sorts,
+     * `$group` refs and `$where` keys all map through here, so no read path can address a property name
+     * the document does not use.
+     */
+    columnOf<E>(meta: EntityMeta<E>, key: string): string;
     where<E extends Document>(entity: Type<E>, where?: QueryWhere<E>, opts?: QueryOptions): Filter<E>;
-    /** Renders a `$where` tree without applying entity filters (used for same-scope `$and`/`$or` recursion). */
+    /**
+     * A `$where` that may constrain relations, split into the `$lookup` stages it needs and the `$match`
+     * filter that consumes them. Each relation condition becomes one correlated lookup into a temporary
+     * field plus an ordinary condition on that field, so the caller's boolean structure survives intact
+     * (a relation inside `$or` still means what it says) and nothing depends on materializing ids.
+     * `unset` names the temporary fields, which the caller drops once the match is done.
+     */
+    whereWithRelations<E extends Document>(entity: Type<E>, where?: QueryWhere<E>, opts?: QueryOptions): {
+        readonly stages: MongoAggregationPipelineEntry<Document>[];
+        readonly filter: Filter<E>;
+        readonly unset: string[];
+    };
+    /** Whether a `$where` constrains any relation, and so needs the aggregation path rather than a cursor. */
+    constrainsRelations<E extends Document>(entity: Type<E>, where: QueryWhere<E> | undefined): boolean;
+    /**
+     * Renders a `$where` tree without applying entity filters (used for same-scope `$and`/`$or`
+     * recursion). Relation keys need `$lookup` stages, so they are only accepted when `lookups` is
+     * given - a plain `find`/`updateMany` filter has nowhere to put them.
+     */
     private renderFilter;
+    /**
+     * Emits the correlated `$lookup` for one relation condition and returns the condition that tests its
+     * result: presence of a row for a plain relation filter, a comparison against the row count for
+     * `$size`. The target's (and, for ManyToMany, the junction's) own filters scope the lookup, so a
+     * relation subquery can no more read out-of-scope rows than a direct query on the target can.
+     */
+    private appendRelationLookup;
+    /**
+     * ManyToMany counts/tests junction rows, so the target is reached from inside the junction's own
+     * lookup - the junction's filters apply too, since a soft-deleted link is not a link.
+     */
+    private junctionLookup;
+    /**
+     * Compares the looked-up row count, which is `[{ n: <count> }]` or `[]` when nothing matched - hence
+     * the `$ifNull` fallback to 0, so `{ $size: 0 }` matches parents with no related row at all.
+     */
+    private compareRelationCount;
+    /** Whether a query subtracts `key` from the projection, via `$exclude` or a negative `$select`. */
+    private subtractsKey;
+    /** `raw()` renders SQL, so it has no MongoDB equivalent - say so instead of emitting `{}`. */
+    private assertNoRaw;
+    /**
+     * A dotted key addresses an embedded path, whose root must still be a declared field - otherwise it
+     * is a typo (or an injected key) that would silently match nothing, the same guard the SQL dialects
+     * apply to JSON paths.
+     */
+    private assertKnownPathRoot;
     protected mapTableNameRow(row: {
         table_name: string;
     }): string;
@@ -30,9 +88,35 @@ export declare class MongoDialect extends AbstractDialect {
      * else is a per-field map whose operator objects each need mapping.
      */
     private transformElemMatch;
-    select<E extends Document>(entity: Type<E>, select?: QuerySelectValue<E>, exclude?: QueryExclude<E>): Record<string, 1>;
+    select<E extends Document>(entity: Type<E>, select?: QuerySelectValue<E>, exclude?: QueryExclude<E>): Record<string, 0 | 1>;
     sort<E extends Document>(entity: Type<E>, sort?: QuerySortMap<E>): Sort;
+    /**
+     * Aggregate results are keyed by `$group`/`$agg` alias rather than by column, so an aggregate
+     * `$sort` addresses those aliases as-is - the same reason the SQL dialects sort by alias there.
+     */
+    private aliasSort;
+    /** Shared direction normalization; `mapKey` decides whether keys are columns or aggregate aliases. */
+    private sortBy;
+    /**
+     * {@link columnOf} for a possibly dotted key: only the root is a field key, the rest addresses an
+     * embedded path (`kind.city` -> `<kind's column>.city`).
+     */
+    private pathOf;
     aggregationPipeline<E extends Document>(entity: Type<E>, q: Query<E>, relationSummary?: RelationRequestSummary<E>, opts?: QueryOptions): MongoAggregationPipelineEntry<E>[];
+    /**
+     * `$lookup`/`$unwind` stages for the joinable relations a query populates. Shared by the plain
+     * aggregation pipeline and the `$vectorSearch` one, so relations load the same way in both.
+     */
+    relationStages<E extends Document>(entity: Type<E>, q: Query<E>, relationSummary?: RelationRequestSummary<E>, opts?: QueryOptions): MongoAggregationPipelineEntry<E>[];
+    /**
+     * The correlated join for a single-valued or one-to-many relation. MongoDB runs a lookup's `pipeline`
+     * after its own localField/foreignField match, so the target's filters layer on top of the join
+     * condition with no `let`/`$expr` rewrite: m1 joins the parent's FK to the target's `_id`, every other
+     * direction joins the parent's `_id` to the target's FK.
+     */
+    private joinKeys;
+    /** `[column, key]` for the fields whose stored name differs from their property name, memoized per entity. */
+    private renamedColumns;
     normalizeIds<E extends Document>(meta: EntityMeta<E>, docs: E[] | undefined): E[] | undefined;
     normalizeId<E extends Document>(meta: EntityMeta<E>, doc: E | undefined): E | undefined;
     getIdValue<T extends IdValue>(value: T): T;
@@ -87,6 +171,10 @@ export type MongoAggregationPipelineEntry<E extends Document> = {
     $unwind?: MongoAggregationUnwind;
     $group?: Record<string, unknown>;
     $project?: Record<string, unknown>;
+    $addFields?: Record<string, unknown>;
+    $vectorSearch?: Record<string, unknown>;
+    $count?: string;
+    $unset?: string | string[];
     $skip?: number;
     $limit?: number;
 };
@@ -95,7 +183,8 @@ type MongoAggregationLookup<E extends Document> = {
     readonly foreignField?: string;
     readonly localField?: string;
     readonly pipeline?: MongoAggregationPipelineEntry<FieldValue<E>>[];
-    readonly as?: RelationKey<E>;
+    /** A relation key when populating, a temporary field when a relation condition is being tested. */
+    readonly as?: string;
 };
 type MongoAggregationUnwind = {
     readonly path?: string;
@@ -108,4 +197,3 @@ export type ExtractedVectorSort<E> = {
     readonly regularSort: QuerySortMap<E>;
 };
 export {};
-//# sourceMappingURL=mongoDialect.d.ts.map