uql-orm 0.56.0 → 0.58.0

package/dist/migrate/cli.d.ts

@@ -1,11 +1,10 @@
 #!/usr/bin/env node
-import type { AbstractDialect } from '../dialect/index.js';
 import type { ForeignKeyAction } from '../schema/types.js';
-import type { Config } from '../type/index.js';
+import type { Config, MigratorDialect } from '../type/index.js';
 import { Migrator } from './migrator.js';
 import { createSchemaGeneratorAsync } from './schemaGeneratorAsync.js';
 /** Sync helper for SQL dialects only; returns `undefined` for MongoDB - use {@link createSchemaGeneratorAsync}. */
-export declare function getSchemaGenerator(dialect: AbstractDialect, defaultForeignKeyAction?: ForeignKeyAction): import("./schemaGenerator.js").SqlSchemaGenerator | undefined;
+export declare function getSchemaGenerator(dialect: MigratorDialect, defaultForeignKeyAction?: ForeignKeyAction): import("./schemaGenerator.js").SqlSchemaGenerator | undefined;
 export { createSchemaGeneratorAsync };
 export declare function main(args?: string[]): Promise<void>;
 export declare function runUp(migrator: Migrator, args: string[]): Promise<void>;

package/dist/migrate/cli.js

@@ -308,7 +308,7 @@ function printDriftGroup(title, drifts, icon, showSuggestion) {
                 console.log(`    Expected: ${drift.expected}, Actual: ${drift.actual}`);
             }
             if (showSuggestion) {
-                console.log(`    → ${drift.suggestion}`);
+                console.log(`    -> ${drift.suggestion}`);
             }
         }
         console.log('');
@@ -358,7 +358,7 @@ Configuration:
   Create a uql.config.ts or uql.config.js file in your project root.
   You can also specify a custom config path using --config or -c.
   The CLI requires pool.dialect (dialect id = pool.dialect.dialectName).
-  See the repo README section "Driver → pool → dialect class".
+  See the repo README section "Driver -> pool -> dialect class".
 
   export default {
     pool: new PgQuerierPool({ ... }),

package/dist/migrate/codegen/entityCodeGenerator.js

@@ -11,7 +11,7 @@
  */
 import { canonicalToTypeScript } from '../../schema/canonicalType.js';
 import { DEFAULT_FOREIGN_KEY_ACTION, } from '../../schema/types.js';
-import { camelCase, pascalCase, singularize } from '../../util/string.util.js';
+import { camelCase, lowerFirst, pascalCase, singularize } from '../../util/string.util.js';
 import { buildFieldOptionsSource, fieldNeedsRaw } from './fieldOptionsSource.js';
 import { buildIndexDecoratorSource, indexNeedsRaw, isPlainFieldIndex } from './indexDecoratorSource.js';
 /**
@@ -116,8 +116,9 @@ export class EntityCodeGenerator {
     buildEntityDecorators(table) {
         const lines = [];
         if (this.options.includeIndexes) {
+            const param = lowerFirst(this.options.classNameTransformer(table.name));
             for (const index of this.declaredIndexes(table)) {
-                lines.push(buildIndexDecoratorSource(index, this.options.propertyNameTransformer));
+                lines.push(buildIndexDecoratorSource(index, this.options.propertyNameTransformer, param));
             }
         }
         // Entity decorator
@@ -260,9 +261,10 @@ export class EntityCodeGenerator {
             lines.push(`   * Inverse relation from ${rel.from.table.name}`);
             lines.push('   */');
         }
-        // Decorator - includes references to property name
+        // The inverse side, mapped by the related class's property that points back at this one.
         const inverseProp = this.options.propertyNameTransformer(this.options.singularize(table.name));
-        lines.push(`  @${decoratorName}({ entity: () => ${relatedClassName}, references: '${inverseProp}' })`);
+        const param = lowerFirst(relatedClassName);
+        lines.push(`  @${decoratorName}({ entity: () => ${relatedClassName}, mappedBy: (${param}) => ${param}.${inverseProp} })`);
         // Property
         if (inverseType === 'OneToMany' || inverseType === 'ManyToMany') {
             lines.push(`  ${propertyName}?: ${relatedClassName}[];`);

package/dist/migrate/codegen/entityTypes.d.ts

@@ -4,4 +4,4 @@ import type { Type } from '../../type/index.js';
  * compiler too. Interfaces, not the entity classes `generate:from-db` writes: those are the source of
  * a schema, these describe one already defined elsewhere.
  */
-export declare function entityTypesSource(entities: readonly Type<unknown>[]): string;
+export declare function entityTypesSource(entities: readonly Type<object>[]): string;

package/dist/migrate/codegen/entityTypes.js

@@ -2,6 +2,7 @@ import { getMeta } from '../../entity/index.js';
 import { canonicalToTypeScript } from '../../schema/canonicalType.js';
 import { resolveColumnCanonicalType } from '../../schema/schemaASTBuilder.js';
 import { isToManyRelation, upperFirst } from '../../util/index.js';
+import { isIdentifierName } from './sourceLiteral.js';
 /**
  * A `.d.ts` for the entities as registered, so a shape that only exists at runtime reaches the
  * compiler too. Interfaces, not the entity classes `generate:from-db` writes: those are the source of
@@ -41,12 +42,12 @@ function interfaceNames(metas) {
 }
 /** `text` as an identifier: what cannot be in one is dropped, and what cannot start one is prefixed. */
 function identifier(text) {
-    const stripped = text.replace(/[^A-Za-z0-9_$]/g, '');
-    return /^[A-Za-z_$]/.test(stripped) ? stripped : `Entity${stripped}`;
+    const stripped = text.replace(/[^\p{ID_Continue}$\u200C\u200D]/gu, '');
+    return isIdentifierName(stripped) ? stripped : `Entity${stripped}`;
 }
 /** A column name a property cannot hold - `hero-image` - is quoted rather than dropped. */
 function member(key, type) {
-    const name = key === identifier(key) ? key : JSON.stringify(key);
+    const name = isIdentifierName(key) ? key : JSON.stringify(key);
     return `  ${name}?: ${type};`;
 }
 /**

package/dist/migrate/codegen/indexDecoratorSource.d.ts

@@ -2,13 +2,14 @@ import type { IndexNode } from '../../schema/types.js';
 /**
  * Whether `@Field({ index })` can carry the whole index. It says only "this column is indexed under
  * this name", so anything else the index declares - an expression, a predicate, uniqueness, an access
- * method, stored columns, a stored order - has to be written out as `@Index([...])` instead.
+ * method, stored columns, a stored order - has to be written out as an `@Index` instead.
  */
 export declare function isPlainFieldIndex(index: IndexNode): boolean;
 /**
- * One `@Index([...])` as source, for an index no `@Field` can express. Emits `raw(...)` for an
- * expression entry, so callers import `raw` when {@link indexNeedsRaw} holds.
+ * One `@Index((user) => [...])` as source, for an index no `@Field` can express, its columns read off the
+ * key map `param` names. Emits `raw(...)` for an expression entry, so callers import `raw` when
+ * {@link indexNeedsRaw} holds.
  */
-export declare function buildIndexDecoratorSource(index: IndexNode, propertyName: (column: string) => string): string;
+export declare function buildIndexDecoratorSource(index: IndexNode, propertyName: (column: string) => string, param: string): string;
 /** Whether emitting this index needs `raw` imported alongside `Index`. */
 export declare function indexNeedsRaw(index: IndexNode): boolean;

package/dist/migrate/codegen/indexDecoratorSource.js

@@ -1,4 +1,4 @@
-import { rawTag } from './sourceLiteral.js';
+import { isIdentifierName, quoted, rawTag } from './sourceLiteral.js';
 /**
  * A vector index carries its metric in the operator class pgvector names after it
  * (`vector_cosine_ops`), which is the only place introspection can recover it from. `@Index` requires
@@ -37,7 +37,7 @@ function significantModifiers(entry) {
 /**
  * Whether `@Field({ index })` can carry the whole index. It says only "this column is indexed under
  * this name", so anything else the index declares - an expression, a predicate, uniqueness, an access
- * method, stored columns, a stored order - has to be written out as `@Index([...])` instead.
+ * method, stored columns, a stored order - has to be written out as an `@Index` instead.
  */
 export function isPlainFieldIndex(index) {
     const entries = index.entries;
@@ -53,11 +53,12 @@ export function isPlainFieldIndex(index) {
         significantModifiers(entry).length === 0);
 }
 /**
- * One `@Index([...])` as source, for an index no `@Field` can express. Emits `raw(...)` for an
- * expression entry, so callers import `raw` when {@link indexNeedsRaw} holds.
+ * One `@Index((user) => [...])` as source, for an index no `@Field` can express, its columns read off the
+ * key map `param` names. Emits `raw(...)` for an expression entry, so callers import `raw` when
+ * {@link indexNeedsRaw} holds.
  */
-export function buildIndexDecoratorSource(index, propertyName) {
-    const entries = index.entries.map((entry) => indexEntrySource(entry, propertyName)).join(', ');
+export function buildIndexDecoratorSource(index, propertyName, param) {
+    const entries = index.entries.map((entry) => indexEntrySource(entry, propertyName, param)).join(', ');
     const isVector = index.type === 'hnsw' || index.type === 'ivfflat';
     const distance = isVector ? vectorDistance(index) : undefined;
     const options = [];
@@ -77,21 +78,24 @@ export function buildIndexDecoratorSource(index, propertyName) {
     if (index.where)
         options.push(`where: ${rawTag(index.where)}`);
     if (index.include?.length) {
-        options.push(`include: [${index.include.map((column) => `'${propertyName(column)}'`).join(', ')}]`);
+        const included = index.include.map((column) => memberSource(param, propertyName(column)));
+        options.push(`include: (${param}) => [${included.join(', ')}]`);
     }
-    return `@Index([${entries}]${options.length > 0 ? `, { ${options.join(', ')} }` : ''})`;
+    return `@Index((${param}) => [${entries}]${options.length > 0 ? `, { ${options.join(', ')} }` : ''})`;
 }
 /** Whether emitting this index needs `raw` imported alongside `Index`. */
 export function indexNeedsRaw(index) {
     return Boolean(index.where) || index.entries.some((entry) => entry.expression);
 }
-function indexEntrySource(entry, propertyName) {
+function indexEntrySource(entry, propertyName, param) {
     if (entry.expression) {
         return rawTag(entry.column);
     }
+    const column = memberSource(param, propertyName(entry.column));
     const modifiers = significantModifiers(entry);
-    if (modifiers.length === 0) {
-        return `'${propertyName(entry.column)}'`;
-    }
-    return `{ column: '${propertyName(entry.column)}', ${modifiers.join(', ')} }`;
+    return modifiers.length === 0 ? column : `{ column: ${column}, ${modifiers.join(', ')} }`;
+}
+/** `user.email`, or `user['first-name']` for a property name that is no identifier. */
+function memberSource(param, property) {
+    return isIdentifierName(property) ? `${param}.${property}` : `${param}[${quoted(property)}]`;
 }

package/dist/migrate/codegen/sourceLiteral.d.ts

@@ -1,3 +1,5 @@
+/** Whether `text` can name a property unquoted, in any script: `dueño` can, `first-name` cannot. */
+export declare function isIdentifierName(text: string): boolean;
 /**
  * A string as single-quoted source. Introspected text is arbitrary - a comment or a default
  * expression can hold a quote or a backslash - and only escaping both keeps the generated file

package/dist/migrate/codegen/sourceLiteral.js

@@ -1,3 +1,7 @@
+/** Whether `text` can name a property unquoted, in any script: `dueño` can, `first-name` cannot. */
+export function isIdentifierName(text) {
+    return /^[\p{ID_Start}$_][\p{ID_Continue}$\u200C\u200D]*$/u.test(text);
+}
 /**
  * A string as single-quoted source. Introspected text is arbitrary - a comment or a default
  * expression can hold a quote or a backslash - and only escaping both keeps the generated file

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

@@ -2,15 +2,11 @@ import type { AbstractSqlDialect } from '../../dialect/abstractSqlDialect.js';
 import { IndexDdl } from './indexDdl.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 { TableDdl } from './tableDdl.js';
-/**
- * The index DDL a dialect gets, most specific first. `instanceof` rather than the `dialectName`
- * {@link tableDdlFor} reads, because each family's index DDL is typed to its dialect and the narrowing
- * is what hands it one. Anything else gets the portable form, which is SQLite's.
- */
 export declare function indexDdlFor(dialect: AbstractSqlDialect): IndexDdl;
 /**
  * The table DDL a dialect gets: SQL Server's, or the portable form every other engine takes. By

package/dist/migrate/ddl/index.js

@@ -1,40 +1,29 @@
-import { CockroachDialect } from '../../cockroachdb/cockroachDialect.js';
-import { MysqlLikeSqlDialect } from '../../dialect/mysqlLikeSqlDialect.js';
-import { PgLikeSqlDialect } from '../../dialect/pgLikeSqlDialect.js';
-import { MariaDialect } from '../../maria/mariaDialect.js';
-import { MySqlDialect } from '../../mysql/mysqlDialect.js';
 import { IndexDdl } from './indexDdl.js';
+import { MsSqlIndexDdl } from './mssqlIndexDdl.js';
 import { MsSqlTableDdl } from './mssqlTableDdl.js';
-import { MariaIndexDdl, MySqlIndexDdl, MysqlLikeIndexDdl } from './mysqlIndexDdl.js';
+import { MariaIndexDdl, MySqlIndexDdl } from './mysqlIndexDdl.js';
 import { CockroachIndexDdl, PgIndexDdl } from './pgIndexDdl.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 { TableDdl } from './tableDdl.js';
 /**
- * The index DDL a dialect gets, most specific first. `instanceof` rather than the `dialectName`
- * {@link tableDdlFor} reads, because each family's index DDL is typed to its dialect and the narrowing
- * is what hands it one. Anything else gets the portable form, which is SQLite's.
+ * 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.
  */
+const INDEX_DDL = {
+    postgres: PgIndexDdl,
+    cockroachdb: CockroachIndexDdl,
+    mysql: MySqlIndexDdl,
+    mariadb: MariaIndexDdl,
+    mssql: MsSqlIndexDdl,
+    sqlite: IndexDdl,
+};
 export function indexDdlFor(dialect) {
-    if (dialect instanceof CockroachDialect) {
-        return new CockroachIndexDdl(dialect);
-    }
-    if (dialect instanceof PgLikeSqlDialect) {
-        return new PgIndexDdl(dialect);
-    }
-    if (dialect instanceof MySqlDialect) {
-        return new MySqlIndexDdl(dialect);
-    }
-    if (dialect instanceof MariaDialect) {
-        return new MariaIndexDdl(dialect);
-    }
-    if (dialect instanceof MysqlLikeSqlDialect) {
-        return new MysqlLikeIndexDdl(dialect);
-    }
-    return new IndexDdl(dialect);
+    return new INDEX_DDL[dialect.dialectName](dialect);
 }
 /**
  * The table DDL a dialect gets: SQL Server's, or the portable form every other engine takes. By

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

@@ -1,5 +1,5 @@
 import type { AbstractSqlDialect } from '../../dialect/abstractSqlDialect.js';
-import type { IndexType } from '../../schema/types.js';
+import { type IndexType } from '../../schema/types.js';
 import { type IndexColumnSchema, type IndexFeature, type IndexJsonArray, type IndexSchema } from '../../type/index.js';
 /**
  * `CREATE INDEX` for SQL dialects: the statement and the fragments each engine spells differently.
@@ -20,6 +20,15 @@ export declare class IndexDdl<D extends AbstractSqlDialect = AbstractSqlDialect>
      * emitted: each of them is a hard error at the server, not a slower plan.
      */
     protected readonly indexFeatures: ReadonlySet<IndexFeature>;
+    /**
+     * Index types this dialect's `CREATE INDEX` takes. SQLite's grammar has no `USING` clause, so every
+     * type builds the plain index it has there, which is what lets an entity written for Postgres
+     * migrate unchanged. An engine that would reject a type narrows this, and the type is refused.
+     */
+    protected readonly indexTypes: ReadonlySet<IndexType>;
+    /** What to declare instead of a type this dialect lacks, appended to its refusal. */
+    protected readonly indexTypeHints: ReadonlyMap<IndexType, string>;
+    private assertIndexType;
     private assertIndexFeatures;
     /**
      * Index types this dialect spells as a keyword of their own (`FULLTEXT INDEX`, `VECTOR INDEX`)
@@ -51,7 +60,7 @@ export declare class IndexDdl<D extends AbstractSqlDialect = AbstractSqlDialect>
     protected indexInclude(_index: IndexSchema): string;
     /** ` USING <method>`, which SQLite's grammar has no place for at all. */
     protected indexAccessMethod(_index: IndexSchema): string;
-    /** pgvector's ` WITH (m = ..., ef_construction = ..., lists = ...)`. */
+    /** What trails the columns: pgvector's ` WITH (m = ...)`, MySQL's ` USING btree`, MariaDB's ` M=8`. */
     protected indexTuning(_index: IndexSchema): string;
     /**
      * The partial-index predicate. Engines without one reject the index in {@link assertIndexFeatures}

package/dist/migrate/ddl/indexDdl.js

@@ -1,4 +1,5 @@
 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';
 /**
@@ -29,6 +30,7 @@ export class IndexDdl {
         this.dialect = dialect;
     }
     getCreateIndexStatement(tableName, index, opts = {}) {
+        this.assertIndexType(index);
         this.assertIndexFeatures(index);
         const unique = index.unique ? 'UNIQUE ' : '';
         const ifNotExists = (opts.ifNotExists ?? this.dialect.features.indexIfNotExists) ? 'IF NOT EXISTS ' : '';
@@ -47,6 +49,20 @@ export class IndexDdl {
         'partial',
         'jsonPath',
     ]);
+    /**
+     * Index types this dialect's `CREATE INDEX` takes. SQLite's grammar has no `USING` clause, so every
+     * type builds the plain index it has there, which is what lets an entity written for Postgres
+     * migrate unchanged. An engine that would reject a type narrows this, and the type is refused.
+     */
+    indexTypes = new Set(INDEX_TYPES);
+    /** What to declare instead of a type this dialect lacks, appended to its refusal. */
+    indexTypeHints = new Map();
+    assertIndexType(index) {
+        if (index.type && !this.indexTypes.has(index.type)) {
+            throw new TypeError(`${this.dialect.dialectName} has no ${index.type} index (index "${index.name}")` +
+                (this.indexTypeHints.get(index.type) ?? ''));
+        }
+    }
     assertIndexFeatures(index) {
         for (const feature of getKeys(INDEX_FEATURE_PROBES)) {
             if (INDEX_FEATURE_PROBES[feature](index) && !this.indexFeatures.has(feature)) {
@@ -111,7 +127,7 @@ export class IndexDdl {
     indexAccessMethod(_index) {
         return '';
     }
-    /** pgvector's ` WITH (m = ..., ef_construction = ..., lists = ...)`. */
+    /** What trails the columns: pgvector's ` WITH (m = ...)`, MySQL's ` USING btree`, MariaDB's ` M=8`. */
     indexTuning(_index) {
         return '';
     }

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

@@ -0,0 +1,10 @@
+import { IndexDdl } from './indexDdl.js';
+/**
+ * SQL Server's `CREATE INDEX` is the portable form minus what 2025 rejects: an expression (Msg 16216),
+ * the subquery a JSON path compiles to (Msg 1046), and any type but the plain rowstore B-tree, since
+ * the index built in its place fails on a `VECTOR` or `nvarchar(max)` column (Msg 1978).
+ */
+export declare class MsSqlIndexDdl extends IndexDdl {
+    protected readonly indexFeatures: Set<"expression" | "include" | "jsonArray" | "jsonPath" | "nullsOrder" | "opsClass" | "partial" | "prefixLength">;
+    protected readonly indexTypes: Set<"brin" | "btree" | "fulltext" | "gin" | "gist" | "hash" | "hnsw" | "ivfflat" | "vector" | "vectorSearch">;
+}

package/dist/migrate/ddl/mssqlIndexDdl.js

@@ -0,0 +1,10 @@
+import { IndexDdl } from './indexDdl.js';
+/**
+ * SQL Server's `CREATE INDEX` is the portable form minus what 2025 rejects: an expression (Msg 16216),
+ * the subquery a JSON path compiles to (Msg 1046), and any type but the plain rowstore B-tree, since
+ * the index built in its place fails on a `VECTOR` or `nvarchar(max)` column (Msg 1978).
+ */
+export class MsSqlIndexDdl extends IndexDdl {
+    indexFeatures = new Set(['partial']);
+    indexTypes = new Set(['btree']);
+}

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

@@ -1,19 +1,13 @@
 import type { IndexType } from '../../schema/types.js';
 import type { IndexJsonArray, IndexSchema } from '../../type/index.js';
 import { IndexDdl } from './indexDdl.js';
-/** `CREATE INDEX ... USING btree`, plus the types this family spells as a keyword instead. */
+/** `CREATE INDEX ... (cols) USING btree`, plus the types this family spells as a keyword instead. */
 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>;
-    /**
-     * ` USING btree|hash`, for the types this family does *not* spell as a keyword of its own. A vector
-     * type that is neither is one this engine has no index for at all, refused here rather than
-     * compiled into a ` USING hnsw` the server can only answer with a syntax error: which of them a
-     * dialect *does* have is `indexTypeKeywords`, so declaring one there is all it takes to serve it.
-     */
-    protected indexAccessMethod(index: IndexSchema): string;
-    /** What to do instead, appended to the refusal above. */
-    protected readonly vectorIndexHint: string;
+    /** ` USING btree|hash` trails the columns: between the table and them, it is a syntax error here. */
+    protected indexTuning(index: IndexSchema): string;
 }
 export declare class MySqlIndexDdl extends MysqlLikeIndexDdl {
     /** The multi-valued index is the only JSON index MySQL has - see `IndexFeature` for why. */
@@ -25,12 +19,10 @@ export declare class MySqlIndexDdl extends MysqlLikeIndexDdl {
      */
     protected jsonArrayIndexExpr(escapedColumn: string, json: IndexJsonArray): string;
     /**
-     * MySQL has no vector index of any kind, so one is refused rather than compiled to DDL the server
-     * rejects: `USING hnsw` is a syntax error, and MariaDB's `VECTOR INDEX` is not MySQL syntax either.
-     * Verified against 26.7, which does have `VECTOR` columns and `STRING_TO_VECTOR`, but no distance
-     * function outside HeatWave - hence nothing to index for.
+     * MySQL 26.7 has `VECTOR` columns and `STRING_TO_VECTOR`, but no distance function outside
+     * HeatWave, hence no vector index to build: `USING hnsw` is a syntax error, `VECTOR INDEX` MariaDB's.
      */
-    protected readonly vectorIndexHint = ". Vector search on MySQL needs HeatWave";
+    protected readonly indexTypeHints: Map<"brin" | "btree" | "fulltext" | "gin" | "gist" | "hash" | "hnsw" | "ivfflat" | "vector" | "vectorSearch", string>;
 }
 export declare class MariaIndexDdl extends MysqlLikeIndexDdl {
     /**
@@ -41,12 +33,13 @@ export declare class MariaIndexDdl extends MysqlLikeIndexDdl {
     protected readonly indexFeatures: Set<"expression" | "include" | "jsonArray" | "jsonPath" | "nullsOrder" | "opsClass" | "partial" | "prefixLength">;
     /** The family's, plus a vector index of its own: `CREATE VECTOR INDEX ... ON t (col)`, 11.7+. */
     protected readonly indexTypeKeywords: ReadonlyMap<IndexType, string>;
+    protected readonly indexTypes: Set<"brin" | "btree" | "fulltext" | "gin" | "gist" | "hash" | "hnsw" | "ivfflat" | "vector" | "vectorSearch">;
+    /** pgvector's names are not access methods it has; `vector` is its own keyword above. */
+    protected readonly indexTypeHints: Map<"brin" | "btree" | "fulltext" | "gin" | "gist" | "hash" | "hnsw" | "ivfflat" | "vector" | "vectorSearch", string>;
     /**
      * `M=n DISTANCE=metric`, trailing its `CREATE VECTOR INDEX`. The metric names are MariaDB's own
      * (`euclidean`, not `l2`), and an unsupported one throws rather than being dropped, which would
      * silently build the index on euclidean - its default - instead of what the entity asked for.
      */
     protected indexTuning(index: IndexSchema): string;
-    /** `vector` is its own keyword above; pgvector's names are not access methods it has. */
-    protected readonly vectorIndexHint = "; declare type: 'vector' instead";
 }

package/dist/migrate/ddl/mysqlIndexDdl.js

@@ -1,34 +1,21 @@
 import { jsonPath } from '../../dialect/jsonSql.js';
 import { MARIA_VECTOR_METRICS } from '../../maria/mariaVectorMetrics.js';
-import { isVectorIndexType, unsupportedVectorMetric } from '../../type/vector.js';
+import { unsupportedVectorMetric, VECTOR_INDEX_TYPES } from '../../type/vector.js';
 import { IndexDdl } from './indexDdl.js';
 /**
  * A full-text index is its own keyword here (`CREATE FULLTEXT INDEX ... (cols)`); `USING fulltext` is
  * a syntax error, so it is the keyword that changes rather than the access method.
  */
 const MYSQL_LIKE_INDEX_KEYWORDS = new Map([['fulltext', 'FULLTEXT INDEX']]);
-/** `CREATE INDEX ... USING btree`, plus the types this family spells as a keyword instead. */
+/** `CREATE INDEX ... (cols) USING btree`, plus the types this family spells as a keyword instead. */
 export class MysqlLikeIndexDdl extends IndexDdl {
     indexFeatures = new Set(['expression', 'prefixLength']);
+    indexTypes = new Set(['btree', 'hash', 'fulltext']);
     indexTypeKeywords = MYSQL_LIKE_INDEX_KEYWORDS;
-    /**
-     * ` USING btree|hash`, for the types this family does *not* spell as a keyword of its own. A vector
-     * type that is neither is one this engine has no index for at all, refused here rather than
-     * compiled into a ` USING hnsw` the server can only answer with a syntax error: which of them a
-     * dialect *does* have is `indexTypeKeywords`, so declaring one there is all it takes to serve it.
-     */
-    indexAccessMethod(index) {
-        const type = index.type;
-        if (!type || this.indexTypeKeywords.has(type)) {
-            return '';
-        }
-        if (isVectorIndexType(type)) {
-            throw new TypeError(`${this.dialect.dialectName} has no ${type} index (index "${index.name}")${this.vectorIndexHint}`);
-        }
-        return ` USING ${type}`;
+    /** ` 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}` : '';
     }
-    /** What to do instead, appended to the refusal above. */
-    vectorIndexHint = '';
 }
 export class MySqlIndexDdl extends MysqlLikeIndexDdl {
     /** The multi-valued index is the only JSON index MySQL has - see `IndexFeature` for why. */
@@ -43,12 +30,10 @@ export class MySqlIndexDdl extends MysqlLikeIndexDdl {
         return `CAST(${source} AS ${arrayCastType(json)} ARRAY)`;
     }
     /**
-     * MySQL has no vector index of any kind, so one is refused rather than compiled to DDL the server
-     * rejects: `USING hnsw` is a syntax error, and MariaDB's `VECTOR INDEX` is not MySQL syntax either.
-     * Verified against 26.7, which does have `VECTOR` columns and `STRING_TO_VECTOR`, but no distance
-     * function outside HeatWave - hence nothing to index for.
+     * MySQL 26.7 has `VECTOR` columns and `STRING_TO_VECTOR`, but no distance function outside
+     * HeatWave, hence no vector index to build: `USING hnsw` is a syntax error, `VECTOR INDEX` MariaDB's.
      */
-    vectorIndexHint = '. Vector search on MySQL needs HeatWave';
+    indexTypeHints = new Map(VECTOR_INDEX_TYPES.map((type) => [type, '. Vector search on MySQL needs HeatWave']));
 }
 export class MariaIndexDdl extends MysqlLikeIndexDdl {
     /**
@@ -62,13 +47,19 @@ export class MariaIndexDdl extends MysqlLikeIndexDdl {
         ...MYSQL_LIKE_INDEX_KEYWORDS,
         ['vector', 'VECTOR INDEX'],
     ]);
+    indexTypes = new Set(['btree', 'hash', 'fulltext', 'vector']);
+    /** pgvector's names are not access methods it has; `vector` is its own keyword above. */
+    indexTypeHints = new Map([
+        ['hnsw', "; declare type: 'vector' instead"],
+        ['ivfflat', "; declare type: 'vector' instead"],
+    ]);
     /**
      * `M=n DISTANCE=metric`, trailing its `CREATE VECTOR INDEX`. The metric names are MariaDB's own
      * (`euclidean`, not `l2`), and an unsupported one throws rather than being dropped, which would
      * silently build the index on euclidean - its default - instead of what the entity asked for.
      */
     indexTuning(index) {
-        let tuning = index.m === undefined ? '' : ` M=${index.m}`;
+        let tuning = super.indexTuning(index) + (index.m === undefined ? '' : ` M=${index.m}`);
         if (index.distance) {
             const metric = MARIA_VECTOR_METRICS.get(index.distance);
             if (!metric) {
@@ -78,8 +69,6 @@ export class MariaIndexDdl extends MysqlLikeIndexDdl {
         }
         return tuning;
     }
-    /** `vector` is its own keyword above; pgvector's names are not access methods it has. */
-    vectorIndexHint = "; declare type: 'vector' instead";
 }
 /**
  * MySQL's `CAST(... AS <type> ARRAY)` targets, the closed list its multi-valued index takes: no

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

@@ -1,16 +1,18 @@
-import type { PgLikeSqlDialect } from '../../dialect/pgLikeSqlDialect.js';
 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<PgLikeSqlDialect> {
+export declare class PgIndexDdl extends IndexDdl {
+    /** Postgres 18's `pg_am`, with pgvector's two. */
+    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">;
+    /** The metrics its vector index takes, each naming the operator class it is built with. */
+    protected readonly vectorMetrics: ReadonlyMap<import("../../type/vector.js").VectorDistance, {
+        readonly op: string;
+        readonly opsSuffix: string;
+    }>;
     /** pgvector's own index types; CockroachDB's native one widens this. */
     protected isVectorIndex(index: IndexSchema): boolean;
-    /**
-     * ` USING <method>`. `fulltext` is refused rather than compiled into a ` USING fulltext` the server
-     * can only answer with a syntax error: `$text` computes its `TO_TSVECTOR` per row, which no index
-     * over the raw columns serves.
-     */
     protected indexAccessMethod(index: IndexSchema): string;
     /**
      * A vector index's operator class is named `{type}_{metric}_ops`: an index on a `halfvec` column
@@ -33,9 +35,17 @@ export declare class PgIndexDdl extends IndexDdl<PgLikeSqlDialect> {
  */
 export declare class CockroachIndexDdl extends PgIndexDdl {
     protected readonly indexFeatures: Set<"expression" | "include" | "jsonArray" | "jsonPath" | "nullsOrder" | "opsClass" | "partial" | "prefixLength">;
+    /** v26.3 answers `hash` and `brin` "unimplemented", `ivfflat` "unrecognized"; `hnsw` builds its vector index. */
+    protected readonly indexTypes: Set<"brin" | "btree" | "fulltext" | "gin" | "gist" | "hash" | "hnsw" | "ivfflat" | "vector" | "vectorSearch">;
+    protected readonly indexTypeHints: Map<"brin" | "btree" | "fulltext" | "gin" | "gist" | "hash" | "hnsw" | "ivfflat" | "vector" | "vectorSearch", string>;
+    protected readonly vectorMetrics: ReadonlyMap<import("../../type/vector.js").VectorDistance, {
+        readonly op: string;
+        readonly opsSuffix: string;
+    }>;
     private isNativeVectorIndex;
     protected isVectorIndex(index: IndexSchema): boolean;
     protected indexKeyword(index: IndexSchema): string;
     protected indexAccessMethod(index: IndexSchema): string;
-    protected indexTuning(index: IndexSchema): string;
+    /** None of pgvector's knobs: `WITH (m = 16)` answers "invalid storage parameter", `hnsw` included. */
+    protected indexTuning(): string;
 }