uql-orm 0.70.0 → 0.71.0

package/dist/maria/mariaDialect.js

@@ -8,12 +8,14 @@ export class MariaDialect extends MysqlLikeSqlDialect {
     // MariaDB 10.5+ has `INSERT ... RETURNING`, so ids come back exact per row - the upsert's too.
     insertIdSource = 'returning';
     /**
-     * Unlike MySQL: `VECTOR(n)` takes its dimension, every column of a vector index has to be NOT NULL,
-     * `CREATE INDEX` takes `IF NOT EXISTS`, and a lock cannot be narrowed to one table of a join.
+     * Unlike MySQL: `VECTOR(n)` takes its dimension and binds as packed float32 bytes, every column of a
+     * vector index has to be NOT NULL, `CREATE INDEX` takes `IF NOT EXISTS`, and a lock cannot be narrowed
+     * to one table of a join.
      */
     features = {
         ...MYSQL_FEATURES,
         vectorSupportsLength: true,
+        vectorBytes: true,
         vectorIndexRequiresNotNull: true,
         indexIfNotExists: true,
         rowLockOf: false,
@@ -69,17 +71,6 @@ export class MariaDialect extends MysqlLikeSqlDialect {
         ['cosine', { fn: 'VEC_DISTANCE_COSINE', index: 'cosine' }],
         ['l2', { fn: 'VEC_DISTANCE_EUCLIDEAN', index: 'euclidean' }],
     ]);
-    /**
-     * A `VECTOR` column holds a packed little-endian float32 blob, and MariaDB refuses text where one
-     * belongs: inserting `'[1,2,3]'` fails with `Incorrect vector value`, and passing it to
-     * `VEC_DISTANCE_COSINE` with `Illegal parameter data type varchar`. `VEC_FromText` is the
-     * conversion, needed on both paths.
-     */
-    appendVectorValue(ctx, value) {
-        ctx.append('VEC_FromText(');
-        super.appendVectorValue(ctx, value);
-        ctx.append(')');
-    }
     /**
      * `mhnsw_ef_search` too, where a vector search is tuned. A setting scoped to one statement needs
      * neither a transaction nor a restore, and cannot leak to the next query on this pooled connection,

package/dist/maria/mariadbQuerier.js

@@ -1,19 +1,25 @@
 import { AbstractPoolQuerier } from '../querier/abstractPoolQuerier.js';
 import { decodeBigInts } from '../util/wideNumber.js';
+/** This driver binds only a `Buffer` as bytes: any other `Uint8Array` goes as the JSON of its indices. */
+function toBindValues(values) {
+    return values?.map((value) => value instanceof Uint8Array && !Buffer.isBuffer(value)
+        ? Buffer.from(value.buffer, value.byteOffset, value.byteLength)
+        : value);
+}
 export class MariadbQuerier extends AbstractPoolQuerier {
     async internalAll(query, values) {
-        const rows = await this.getConn().query(query, values);
+        const rows = await this.getConn().query(query, toBindValues(values));
         return Array.from(rows, decodeBigInts);
     }
     async internalRun(query, values) {
-        const res = await this.getConn().query(query, values);
+        const res = await this.getConn().query(query, toBindValues(values));
         // An OK packet reports `affectedRows`; a `RETURNING` statement answers rows instead, and counts by them.
         const changes = res.affectedRows ?? res.length;
         const rows = res.length ? Array.from(res, decodeBigInts) : [];
         return this.buildUpdateResult({ rows, changes, upsertStatus: res.affectedRows });
     }
     async *internalStream(query, values) {
-        const stream = this.getConn().queryStream(query, values);
+        const stream = this.getConn().queryStream(query, toBindValues(values));
         try {
             for await (const row of stream) {
                 yield decodeBigInts(row);

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

@@ -6,6 +6,7 @@ export { MsSqlIndexDdl } from './mssqlIndexDdl.js';
 export { MsSqlTableDdl } from './mssqlTableDdl.js';
 export { MariaIndexDdl, MySqlIndexDdl, MysqlLikeIndexDdl } from './mysqlIndexDdl.js';
 export { CockroachIndexDdl, PgIndexDdl } from './pgIndexDdl.js';
+export { SqliteIndexDdl } from './sqliteIndexDdl.js';
 export { TableDdl } from './tableDdl.js';
 export declare function indexDdlFor(dialect: AbstractSqlDialect): IndexDdl;
 /**

package/dist/migrate/ddl/index.js

@@ -3,16 +3,18 @@ import { MsSqlIndexDdl } from './mssqlIndexDdl.js';
 import { MsSqlTableDdl } from './mssqlTableDdl.js';
 import { MariaIndexDdl, MySqlIndexDdl } from './mysqlIndexDdl.js';
 import { CockroachIndexDdl, PgIndexDdl } from './pgIndexDdl.js';
+import { SqliteIndexDdl } from './sqliteIndexDdl.js';
 import { TableDdl } from './tableDdl.js';
 export { IndexDdl } from './indexDdl.js';
 export { MsSqlIndexDdl } from './mssqlIndexDdl.js';
 export { MsSqlTableDdl } from './mssqlTableDdl.js';
 export { MariaIndexDdl, MySqlIndexDdl, MysqlLikeIndexDdl } from './mysqlIndexDdl.js';
 export { CockroachIndexDdl, PgIndexDdl } from './pgIndexDdl.js';
+export { SqliteIndexDdl } from './sqliteIndexDdl.js';
 export { TableDdl } from './tableDdl.js';
 /**
  * Each engine's index DDL, by the `dialectName` a subclass inherits: by name, so this entry carries no
- * dialect, and exhaustive, so a new engine has to name its own. SQLite's is the portable form.
+ * dialect, and exhaustive, so a new engine has to name its own.
  */
 const INDEX_DDL = {
     postgres: PgIndexDdl,
@@ -20,7 +22,7 @@ const INDEX_DDL = {
     mysql: MySqlIndexDdl,
     mariadb: MariaIndexDdl,
     mssql: MsSqlIndexDdl,
-    sqlite: IndexDdl,
+    sqlite: SqliteIndexDdl,
 };
 export function indexDdlFor(dialect) {
     return new INDEX_DDL[dialect.dialectName](dialect);

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

@@ -37,6 +37,8 @@ export declare class IndexDdl<D extends AbstractSqlDialect = AbstractSqlDialect>
     protected readonly indexTypeKeywords: ReadonlyMap<IndexType, string>;
     /** The keyword an index type replaces `INDEX` with, or `INDEX` for the types that do not. */
     protected indexKeyword(index: IndexSchema): string;
+    /** What the index is over, between the parentheses: a fulltext one's columns as a search matches them, else its entries. */
+    protected indexTarget(index: IndexSchema): string;
     /** One index entry: what is indexed, its operator class if any, then its stored order. */
     protected indexColumn(entry: IndexColumnSchema, index: IndexSchema): string;
     /**

package/dist/migrate/ddl/indexDdl.js

@@ -1,7 +1,7 @@
 import { jsonTypeMode } from '../../dialect/jsonSql.js';
 import { INDEX_TYPES } from '../../schema/types.js';
 import { INDEX_FEATURE_LABELS, } from '../../type/index.js';
-import { getKeys } from '../../util/index.js';
+import { fulltextConfig, getKeys } from '../../util/index.js';
 /**
  * What in an index asks for each feature. A `Record` over the feature union rather than a list, so a
  * feature added to {@link INDEX_FEATURE_LABELS} cannot reach a dialect without the test that decides
@@ -45,7 +45,7 @@ export class IndexDdl {
         assertIndexFeatures(index, this.indexFeatures, this.dialect.dialectName);
         const unique = index.unique ? 'UNIQUE ' : '';
         const ifNotExists = (opts.ifNotExists ?? this.dialect.features.indexIfNotExists) ? 'IF NOT EXISTS ' : '';
-        const columns = index.entries.map((entry) => this.indexColumn(entry, index)).join(', ');
+        const columns = this.indexTarget(index);
         return (`CREATE ${unique}${this.indexKeyword(index)} ${ifNotExists}${this.dialect.escapeId(index.name)} ` +
             `ON ${this.dialect.escapeId(tableName)}${this.indexAccessMethod(index)} (${columns})` +
             `${this.indexInclude(index)}${this.indexTuning(index)}${this.indexPredicate(index)};`);
@@ -78,6 +78,14 @@ export class IndexDdl {
     indexKeyword(index) {
         return (index.type && this.indexTypeKeywords.get(index.type)) || 'INDEX';
     }
+    /** What the index is over, between the parentheses: a fulltext one's columns as a search matches them, else its entries. */
+    indexTarget(index) {
+        if (index.type === 'fulltext' && !index.entries.some((entry) => entry.expression)) {
+            const columns = index.entries.map((entry) => this.dialect.escapeId(entry.column));
+            return this.dialect.textSearchTarget(columns, fulltextConfig(index));
+        }
+        return index.entries.map((entry) => this.indexColumn(entry, index)).join(', ');
+    }
     /** One index entry: what is indexed, its operator class if any, then its stored order. */
     indexColumn(entry, index) {
         return `${this.indexColumnTarget(entry)}${this.indexColumnOpsClass(entry, index)}${this.indexColumnOrder(entry)}`;

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

@@ -2,9 +2,8 @@ import type { IndexColumnSchema, IndexSchema } from '../../type/index.js';
 import { IndexDdl } from './indexDdl.js';
 /** `CREATE INDEX ... USING hnsw ("embedding" vector_cosine_ops) WITH (m = ...)`, pgvector's form. */
 export declare class PgIndexDdl extends IndexDdl {
-    /** Postgres 18's `pg_am`, with pgvector's two. */
+    /** Postgres 18's `pg_am`, with pgvector's two, and `fulltext`, which builds a `gin` one. */
     protected readonly indexTypes: Set<"brin" | "btree" | "fulltext" | "gin" | "gist" | "hash" | "hnsw" | "ivfflat" | "vector" | "vectorSearch">;
-    protected readonly indexTypeHints: ReadonlyMap<"brin" | "btree" | "fulltext" | "gin" | "gist" | "hash" | "hnsw" | "ivfflat" | "vector" | "vectorSearch", string>;
     protected readonly indexFeatures: Set<"expression" | "include" | "jsonArray" | "jsonPath" | "nullsOrder" | "opsClass" | "partial" | "prefixLength">;
     /** pgvector's own index types; CockroachDB's native one widens this. */
     protected isVectorIndex(index: IndexSchema): boolean;
@@ -27,6 +26,6 @@ export declare class CockroachIndexDdl extends PgIndexDdl {
     protected isVectorIndex(index: IndexSchema): boolean;
     protected indexKeyword(index: IndexSchema): string;
     protected indexAccessMethod(index: IndexSchema): string;
-    /** None of pgvector's knobs: `WITH (m = 16)` answers "invalid storage parameter", `hnsw` included. */
-    protected indexTuning(): string;
+    /** Its build-time candidate list alone: pgvector's `WITH (m = 16)` answers "invalid storage parameter", `hnsw` included. */
+    protected indexTuning(index: IndexSchema): string;
 }

package/dist/migrate/ddl/pgIndexDdl.js

@@ -1,12 +1,8 @@
 import { unsupportedVectorMetric } from '../../type/vector.js';
 import { IndexDdl } from './indexDdl.js';
-/** `$text` computes its `TO_TSVECTOR` per row, which no index over the raw columns serves. */
-const PG_INDEX_TYPE_HINTS = new Map([
-    ['fulltext', '. $text needs none there; name the columns it searches with $fields.'],
-]);
 /** `CREATE INDEX ... USING hnsw ("embedding" vector_cosine_ops) WITH (m = ...)`, pgvector's form. */
 export class PgIndexDdl extends IndexDdl {
-    /** Postgres 18's `pg_am`, with pgvector's two. */
+    /** Postgres 18's `pg_am`, with pgvector's two, and `fulltext`, which builds a `gin` one. */
     indexTypes = new Set([
         'btree',
         'hash',
@@ -15,8 +11,8 @@ export class PgIndexDdl extends IndexDdl {
         'brin',
         'hnsw',
         'ivfflat',
+        'fulltext',
     ]);
-    indexTypeHints = PG_INDEX_TYPE_HINTS;
     indexFeatures = new Set([
         'expression',
         'partial',
@@ -30,6 +26,9 @@ export class PgIndexDdl extends IndexDdl {
         return index.type === 'hnsw' || index.type === 'ivfflat';
     }
     indexAccessMethod(index) {
+        if (index.type === 'fulltext') {
+            return ' USING gin';
+        }
         return index.type ? ` USING ${index.type}` : '';
     }
     /**
@@ -75,9 +74,8 @@ export class PgIndexDdl extends IndexDdl {
 export class CockroachIndexDdl extends PgIndexDdl {
     indexFeatures = new Set(['expression', 'partial', 'include', 'jsonPath']);
     /** v26.3 answers `hash` and `brin` "unimplemented", `ivfflat` "unrecognized"; `hnsw` builds its vector index. */
-    indexTypes = new Set(['btree', 'gin', 'gist', 'hnsw', 'vector']);
+    indexTypes = new Set(['btree', 'gin', 'gist', 'hnsw', 'vector', 'fulltext']);
     indexTypeHints = new Map([
-        ...PG_INDEX_TYPE_HINTS,
         ['ivfflat', "; declare type: 'vector' instead"],
     ]);
     isNativeVectorIndex(index) {
@@ -92,8 +90,10 @@ export class CockroachIndexDdl extends PgIndexDdl {
     indexAccessMethod(index) {
         return this.isNativeVectorIndex(index) ? '' : super.indexAccessMethod(index);
     }
-    /** None of pgvector's knobs: `WITH (m = 16)` answers "invalid storage parameter", `hnsw` included. */
-    indexTuning() {
-        return '';
+    /** Its build-time candidate list alone: pgvector's `WITH (m = 16)` answers "invalid storage parameter", `hnsw` included. */
+    indexTuning(index) {
+        return this.isVectorIndex(index) && index.efConstruction !== undefined
+            ? ` WITH (build_beam_size = ${index.efConstruction})`
+            : '';
     }
 }

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

@@ -0,0 +1,11 @@
+import type { IndexColumnSchema, IndexSchema } from '../../type/index.js';
+import { IndexDdl } from './indexDdl.js';
+/**
+ * SQLite's `CREATE INDEX`, which names no index type. A vector index is libSQL's DiskANN where the dialect
+ * can index its metric, and a plain index on an engine with none, so an entity written for Postgres migrates.
+ */
+export declare class SqliteIndexDdl extends IndexDdl {
+    protected indexColumn(entry: IndexColumnSchema, index: IndexSchema): string;
+    /** The metric libSQL's index names, or `undefined` where the index is no vector index or the engine has none. */
+    private vectorIndexMetric;
+}

package/dist/migrate/ddl/sqliteIndexDdl.js

@@ -0,0 +1,38 @@
+import { indexDistance, isVectorIndexType, unsupportedVectorMetric } from '../../type/vector.js';
+import { IndexDdl } from './indexDdl.js';
+/**
+ * SQLite's `CREATE INDEX`, which names no index type. A vector index is libSQL's DiskANN where the dialect
+ * can index its metric, and a plain index on an engine with none, so an entity written for Postgres migrates.
+ */
+export class SqliteIndexDdl extends IndexDdl {
+    indexColumn(entry, index) {
+        const metric = this.vectorIndexMetric(index);
+        if (metric === undefined) {
+            return super.indexColumn(entry, index);
+        }
+        const options = [
+            `metric=${metric}`,
+            ...(index.m === undefined ? [] : [`max_neighbors=${index.m}`]),
+            ...(index.efConstruction === undefined ? [] : [`insert_l=${index.efConstruction}`]),
+        ];
+        const args = [this.dialect.escapeId(entry.column), ...options.map((option) => this.dialect.escape(option))];
+        return `libsql_vector_idx(${args.join(', ')})`;
+    }
+    /** The metric libSQL's index names, or `undefined` where the index is no vector index or the engine has none. */
+    vectorIndexMetric(index) {
+        const { vectorMetrics, dialectName } = this.dialect;
+        if (!isVectorIndexType(index.type) || !this.dialect.hasVectorIndex()) {
+            return undefined;
+        }
+        const distance = indexDistance(index);
+        const metric = vectorMetrics.get(distance)?.index;
+        if (!metric) {
+            throw unsupportedVectorMetric(dialectName, distance, index.name);
+        }
+        // Its tables are named after the index, unquoted: any other name fails with "unable to initialize diskann".
+        if (!/^\w+$/.test(index.name) || index.entries.length !== 1) {
+            throw new TypeError(`libSQL names a vector index only by letters, digits and underscores, over one column (index "${index.name}")`);
+        }
+        return metric;
+    }
+}

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

@@ -6,6 +6,24 @@ export type MongoIndexOptions = {
     readonly name: string;
     readonly partialFilterExpression?: Readonly<Record<string, unknown>>;
 };
+/** A field of an Atlas vector search index: the vector itself, or one its `filter` pre-filters on. */
+export type MongoVectorSearchField = {
+    readonly type: 'vector';
+    readonly path: string;
+    readonly numDimensions: number;
+    readonly similarity: string;
+} | {
+    readonly type: 'filter';
+    readonly path: string;
+};
+/** An Atlas search index as `createSearchIndex` takes one. */
+export type MongoSearchIndex = {
+    readonly name: string;
+    readonly type: 'vectorSearch';
+    readonly definition: {
+        readonly fields: readonly MongoVectorSearchField[];
+    };
+};
 /** The commands {@link MongoSchemaGenerator} emits as JSON, one per statement. */
 export type MongoCommand = {
     readonly action: 'createCollection';
@@ -27,6 +45,14 @@ export type MongoCommand = {
     readonly action: 'dropIndex';
     readonly collection: string;
     readonly name: string;
+} | {
+    readonly action: 'createSearchIndex';
+    readonly collection: string;
+    readonly index: MongoSearchIndex;
+} | {
+    readonly action: 'dropSearchIndex';
+    readonly collection: string;
+    readonly name: string;
 };
 export declare function serializeMongoCommand(command: MongoCommand): string;
 /**
@@ -41,6 +67,8 @@ export type MongoCommandTarget = {
         drop(): Promise<unknown>;
         createIndex(key: MongoIndexKey, options: MongoIndexOptions): Promise<unknown>;
         dropIndex(name: string): Promise<unknown>;
+        createSearchIndex(index: MongoSearchIndex): Promise<unknown>;
+        dropSearchIndex(name: string): Promise<unknown>;
     };
 };
 /** Execute one emitted command. */

package/dist/migrate/generator/mongoCommand.js

@@ -25,6 +25,10 @@ export function runMongoCommand(db, statement) {
             return db.collection(command.collection).createIndex(command.key, command.options);
         case 'dropIndex':
             return db.collection(command.collection).dropIndex(command.name);
+        case 'createSearchIndex':
+            return db.collection(command.collection).createSearchIndex(command.index);
+        case 'dropSearchIndex':
+            return db.collection(command.collection).dropSearchIndex(command.name);
         default:
             // Unreachable for a command this module produced; a hand-written statement lands here rather
             // than being silently skipped.
@@ -46,6 +50,10 @@ export function mongoCommandSource(statement, db) {
             return `${db}.collection(${literal(command.collection)}).createIndex(${literal(command.key)}, ${literal(command.options)})`;
         case 'dropIndex':
             return `${db}.collection(${literal(command.collection)}).dropIndex(${literal(command.name)})`;
+        case 'createSearchIndex':
+            return `${db}.collection(${literal(command.collection)}).createSearchIndex(${literal(command.index)})`;
+        case 'dropSearchIndex':
+            return `${db}.collection(${literal(command.collection)}).dropSearchIndex(${literal(command.name)})`;
         default:
             throw unsupportedMongoCommand(statement);
     }

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

@@ -35,6 +35,8 @@ export declare class MongoSchemaGenerator extends MongoDialect implements Schema
     generateAlterTableDown(diff: SchemaDiff): string[];
     /** An index as MongoDB's key spec (`-1` descending, `'text'` full-text), refusing the SQL-only options. */
     generateCreateIndex(tableName: string, index: IndexSchema): string;
+    /** An Atlas vector search index: its vector field first, then each field a `$vectorSearch` pre-filters on. */
+    private generateCreateSearchIndex;
     generateDropIndex(tableName: string, indexName: string): string;
     /** A collection and its indexes, which is all a document store has: a column, a constraint or SQL throws. */
     generateOperation(operation: AnyMigrationOperation): string[];

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -1,16 +1,22 @@
 import { getMeta } from '../../entity/index.js';
 import { MongoDialect } from '../../mongo/mongoDialect.js';
 import { QueryRaw, } from '../../type/index.js';
-import { declaredIndexes, indexNameParts, renderIndexColumn } from '../../util/ddlExpression.util.js';
-import { derivedIndexName } from '../../util/sql.util.js';
+import { indexDistance, unsupportedVectorMetric } from '../../type/vector.js';
+import { declaredIndexes, declaredIndexName, renderIndexColumn } from '../../util/ddlExpression.util.js';
 import { assertIndexFeatures, assertIndexType } from '../ddl/indexDdl.js';
 import { assertIndexPredicate, refusedIndexPredicate } from '../indexPredicate.js';
 import { renderIndexDefinition } from './definitionToNode.js';
 import { serializeMongoCommand } from './mongoCommand.js';
-/** The index types a key spec can say: a plain key, or `'text'`. */
-const MONGO_INDEX_TYPES = new Set(['btree', 'fulltext']);
+/** The index types a key spec can say, a plain key or `'text'`, and Atlas's vector search index. */
+const MONGO_INDEX_TYPES = new Set(['btree', 'fulltext', 'vectorSearch']);
 /** A key spec's one feature beyond its keys: a partial filter. */
 const MONGO_INDEX_FEATURES = new Set(['partial']);
+/** Atlas's name for each metric a vector search index scores by. */
+const ATLAS_SIMILARITY = {
+    cosine: 'cosine',
+    l2: 'euclidean',
+    inner: 'dotProduct',
+};
 export class MongoSchemaGenerator extends MongoDialect {
     defaultForeignKeyAction;
     constructor(namingStrategy, defaultForeignKeyAction) {
@@ -51,7 +57,11 @@ export class MongoSchemaGenerator extends MongoDialect {
         const entries = index.columns
             .map((entry) => renderIndexColumn(entry, () => this.compileDdl()))
             .map((entry) => ({ ...entry, column: this.columnOf(meta, entry.column) }));
-        const name = index.name ?? derivedIndexName(collectionName, indexNameParts(entries));
+        const [first] = index.columns;
+        const vector = index.type === 'vectorSearch' && typeof first?.column === 'string' ? meta.fields[first.column] : undefined;
+        const name = vector
+            ? this.vectorSearchIndexName(index.name, entries[0].column)
+            : declaredIndexName(index.name, collectionName, entries);
         return {
             name,
             entries,
@@ -59,6 +69,8 @@ export class MongoSchemaGenerator extends MongoDialect {
             type: index.type,
             include: index.include,
             where: index.where && this.compileIndexPredicate(index.where, meta.entity, name),
+            distance: index.distance ?? vector?.distance,
+            dimensions: vector?.dimensions,
         };
     }
     /**
@@ -94,11 +106,16 @@ export class MongoSchemaGenerator extends MongoDialect {
         return (diff.indexesToAdd ?? []).map((index) => this.generateCreateIndex(diff.tableName, index));
     }
     generateAlterTableDown(diff) {
-        return (diff.indexesToAdd ?? []).map((index) => this.generateDropIndex(diff.tableName, index.name));
+        return (diff.indexesToAdd ?? []).map((index) => index.type === 'vectorSearch'
+            ? serializeMongoCommand({ action: 'dropSearchIndex', collection: diff.tableName, name: index.name })
+            : this.generateDropIndex(diff.tableName, index.name));
     }
     /** An index as MongoDB's key spec (`-1` descending, `'text'` full-text), refusing the SQL-only options. */
     generateCreateIndex(tableName, index) {
         assertIndexType(index, MONGO_INDEX_TYPES, this.dialectName);
+        if (index.type === 'vectorSearch') {
+            return this.generateCreateSearchIndex(tableName, index);
+        }
         assertIndexFeatures(index, MONGO_INDEX_FEATURES, this.dialectName);
         const key = {};
         for (const entry of index.entries) {
@@ -116,6 +133,33 @@ export class MongoSchemaGenerator extends MongoDialect {
             },
         });
     }
+    /** An Atlas vector search index: its vector field first, then each field a `$vectorSearch` pre-filters on. */
+    generateCreateSearchIndex(tableName, index) {
+        assertIndexFeatures(index, new Set(), this.dialectName);
+        const [vector, ...filters] = index.entries;
+        if (!vector || index.dimensions === undefined) {
+            throw new TypeError(`an Atlas vector search index states its field's dimensions (index "${index.name}")`);
+        }
+        const distance = indexDistance(index);
+        const similarity = ATLAS_SIMILARITY[distance];
+        if (!similarity) {
+            throw unsupportedVectorMetric(this.dialectName, distance, index.name);
+        }
+        return serializeMongoCommand({
+            action: 'createSearchIndex',
+            collection: tableName,
+            index: {
+                name: index.name,
+                type: 'vectorSearch',
+                definition: {
+                    fields: [
+                        { type: 'vector', path: vector.column, numDimensions: index.dimensions, similarity },
+                        ...filters.map((entry) => ({ type: 'filter', path: entry.column })),
+                    ],
+                },
+            },
+        });
+    }
     generateDropIndex(tableName, indexName) {
         return serializeMongoCommand({ action: 'dropIndex', collection: tableName, name: indexName });
     }

package/dist/migrate/introspection/mongoIntrospector.js

@@ -1,5 +1,7 @@
 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. */
+const SEARCH_NOT_ENABLED = 31082;
 /**
  * MongoDB schema introspector.
  * MongoDB doesn't have a fixed schema, so this primarily focuses on collections and indexes.
@@ -29,15 +31,27 @@ export class MongoSchemaIntrospector {
             }
             // Annotated rather than inferred: the driver's `indexes()` is overloaded and resolves to `any` on
             // some versions, which silently made every field below unchecked.
-            const indexes = await db.collection(tableName).indexes();
+            const collection = db.collection(tableName);
+            const indexes = await collection.indexes();
+            const searchIndexes = await listSearchIndexes(collection);
             return {
                 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: [
+                    ...indexes.map((idx) => ({
+                        name: idx.name ?? Object.keys(idx.key).join('_'),
+                        entries: Object.keys(idx.key).map((column) => ({ column })),
+                        unique: !!idx.unique,
+                    })),
+                    ...searchIndexes
+                        .filter((idx) => idx.type === 'vectorSearch')
+                        .map((idx) => ({
+                        name: idx.name,
+                        entries: idx.latestDefinition.fields.map(({ path }) => ({ column: path })),
+                        unique: false,
+                        type: 'vectorSearch',
+                    })),
+                ],
             };
         });
     }
@@ -61,6 +75,18 @@ export class MongoSchemaIntrospector {
         });
     }
 }
+/** A collection's Atlas search indexes, none where the server has no Atlas Search. */
+async function listSearchIndexes(collection) {
+    try {
+        return await collection.aggregate([{ $listSearchIndexes: {} }]).toArray();
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === SEARCH_NOT_ENABLED) {
+            return [];
+        }
+        throw error;
+    }
+}
 async function hasCollection(db, name) {
     const collections = await db.listCollections({ name, type: 'collection' }, { nameOnly: true }).toArray();
     return collections.length > 0;
@@ -83,7 +109,7 @@ function buildTable({ name, indexes = [] }) {
                 });
             }
         }
-        table.indexes.push({ name: index.name, table, entries: index.entries, unique: index.unique });
+        table.indexes.push({ name: index.name, table, entries: index.entries, unique: index.unique, type: index.type });
     }
     return table;
 }

package/dist/migrate/introspection/postgresIntrospector.js

@@ -199,6 +199,7 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
                 type: INDEX_TYPES.find((type) => type === rows[0].method),
                 where: rows[0].predicate ?? undefined,
                 include: include.length > 0 ? include : undefined,
+                ...fulltextIndex(rows),
             };
         });
     }
@@ -267,6 +268,24 @@ const FOREIGN_KEY_ACTION_CODES = {
 };
 const NUMBER_DEFAULT = /^\(?(-?\d+(?:\.\d+)?)\)?$/;
 const QUOTED_NUMBER_DEFAULT = /^'(-?\d+(?:\.\d+)?)'::(?:smallint|integer|bigint|numeric|real|double precision)$/;
+/**
+ * A `fulltext` index read back as declared, from the document its `GIN` index (`inverted` on CockroachDB)
+ * is over as UQL builds it, `to_tsvector('english'::regconfig, COALESCE(title, ''::text) || ...)`: its
+ * columns and config, so it compares with the entity. Any other expression stays the expression it is.
+ */
+function fulltextIndex(rows) {
+    const [row] = rows;
+    const document = rows.length === 1 && TEXT_INDEX_METHODS.has(row.method) && row.is_expression;
+    const config = document ? /^\(?to_tsvector\('((?:[^']|'')*)'::/i.exec(row.entry) : null;
+    const columns = config
+        ? [...row.entry.matchAll(/COALESCE\(("(?:[^"]|"")+"|[^,()\s]+),/gi)].map(([, column]) => column.startsWith('"') ? column.slice(1, -1).replaceAll('""', '"') : column)
+        : [];
+    if (!config || !columns.length) {
+        return undefined;
+    }
+    return { type: 'fulltext', entries: columns.map((column) => ({ column })), config: config[1].replaceAll("''", "'") };
+}
+const TEXT_INDEX_METHODS = new Set(['gin', 'inverted']);
 /**
  * Postgres states every entry in full: a plain column still reports `order: 'asc'`, and only a
  * non-default operator class is named. The diff defaults the entity side to match, so an option

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

@@ -1,9 +1,13 @@
+import type { IndexFacet } from '../../schema/indexDifferences.js';
 import type { ColumnSchema, ForeignKeySchema, IndexSchema } from '../../type/index.js';
 import { AbstractSqlSchemaIntrospector, type TableRowReader } from './abstractSqlSchemaIntrospector.js';
 /**
  * SQLite schema introspector
  */
 export declare class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
+    /** Whether an index is libSQL's vector index, where the engine has one; elsewhere a declared one is built plain. */
+    readonly indexFacets: ReadonlySet<IndexFacet>;
+    /** Not SQLite's own tables, nor the ones libSQL keeps a vector index in: its metadata and `<index>_shadow`. */
     protected getTableNamesQuery(): string;
     protected tableExistsQuery(): string;
     protected parseTableExistsResult([row]: SqliteCountRow[]): boolean;
@@ -29,6 +33,8 @@ export declare class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospec
     protected mapForeignKeysResult(_read: TableRowReader, tableName: string, results: SqliteForeignKeyRow[]): Promise<ForeignKeySchema[]>;
     protected mapPrimaryKeyResult(results: SqliteColumnRow[]): string[] | undefined;
     private getUniqueColumns;
+    /** libSQL's `libsql_vector_idx(col, 'metric=...')`, read back from the statement that created it. */
+    private getVectorIndex;
     private getIndexColumns;
     protected normalizeType(type: string): string;
     protected extractLength(type: string): number | undefined;