uql-orm 0.63.0 → 0.65.0

package/dist/migrate/cli.js

@@ -7,14 +7,8 @@ import { createEntityCodeGenerator } from './codegen/entityCodeGenerator.js';
 import { entityTypesSource } from './codegen/entityTypes.js';
 import { detectDrift } from './drift/driftDetector.js';
 import { Migrator } from './migrator.js';
-import { buildEntityAST, createSchemaGenerator } from './schemaGenerator.js';
-import { createSchemaGeneratorAsync } from './schemaGeneratorAsync.js';
+import { buildEntityAST } from './schemaGenerator.js';
 import { DEFAULT_MIGRATIONS_TABLE } from './storage/databaseStorage.js';
-/** Sync helper for SQL dialects only; returns `undefined` for MongoDB - use {@link createSchemaGeneratorAsync}. */
-export function getSchemaGenerator(dialect, defaultForeignKeyAction) {
-    return createSchemaGenerator(dialect, defaultForeignKeyAction);
-}
-export { createSchemaGeneratorAsync };
 export async function main(args = process.argv.slice(2)) {
     let customPath;
     const filteredArgs = [];
@@ -42,7 +36,6 @@ export async function main(args = process.argv.slice(2)) {
             defaultForeignKeyAction: config.defaultForeignKeyAction,
         };
         const migrator = new Migrator(config.pool, options);
-        await migrator.ensureSchemaGenerator();
         switch (command) {
             case 'up':
                 await runUp(migrator, filteredArgs.slice(1));
@@ -63,7 +56,7 @@ export async function main(args = process.argv.slice(2)) {
                 break;
             case 'generate:from-db':
             case 'generate-from-db':
-                await runGenerateFromDb(migrator, filteredArgs.slice(1), config);
+                await runGenerateFromDb(migrator, filteredArgs.slice(1));
                 break;
             case 'sync':
                 await runSync(migrator, filteredArgs.slice(1), config);
@@ -204,7 +197,7 @@ function readOutput(args) {
 export async function runSync(migrator, args, config) {
     // Pulling the database into entity files is what `generate:from-db` does; one implementation.
     if (args.includes('--pull')) {
-        return runGenerateFromDb(migrator, args, config);
+        return runGenerateFromDb(migrator, args);
     }
     const force = args.includes('--force');
     const safe = !args.includes('--unsafe');
@@ -223,49 +216,35 @@ export async function runSync(migrator, args, config) {
     await migrator.sync({ ...options, logging: true });
     console.log('\nSchema sync completed.');
 }
-export async function runGenerateFromDb(migrator, args, config) {
+export async function runGenerateFromDb(migrator, args) {
     const outputDir = readOutput(args) ?? './src/entities';
-    if (!migrator.schemaIntrospector) {
-        console.error('No introspector available. Check your pool configuration.');
-        process.exit(1);
-    }
-    else {
-        console.log('\nAnalyzing database schema...');
-        const ast = await migrator.schemaIntrospector.introspect();
-        const tableCount = ast.tables.size;
-        console.log(`Found ${tableCount} table(s): ${Array.from(ast.tables.keys()).join(', ')}`);
-        console.log('\nGenerating entities...');
-        const generator = createEntityCodeGenerator(ast, {
-            addSyncComments: true,
-            includeRelations: true,
-            includeIndexes: true,
-        });
-        const entities = generator.generateAll();
-        // Ensure output directory exists
-        if (!fs.existsSync(outputDir)) {
-            fs.mkdirSync(outputDir, { recursive: true });
-        }
-        // Write entity files
-        for (const entity of entities) {
-            const filePath = path.join(outputDir, entity.fileName);
-            fs.writeFileSync(filePath, entity.code, 'utf-8');
-            console.log(`  ✓ ${entity.className} -> ${filePath}`);
-        }
-        console.log(`\nGenerated ${entities.length} entities to ${outputDir}`);
+    console.log('\nAnalyzing database schema...');
+    const ast = await migrator.schemaIntrospector.introspect();
+    const tableCount = ast.tables.size;
+    console.log(`Found ${tableCount} table(s): ${Array.from(ast.tables.keys()).join(', ')}`);
+    console.log('\nGenerating entities...');
+    const generator = createEntityCodeGenerator(ast, {
+        addSyncComments: true,
+        includeRelations: true,
+        includeIndexes: true,
+    });
+    const entities = generator.generateAll();
+    fs.mkdirSync(outputDir, { recursive: true });
+    for (const entity of entities) {
+        const filePath = path.join(outputDir, entity.fileName);
+        fs.writeFileSync(filePath, entity.code, 'utf-8');
+        console.log(`  ✓ ${entity.className} -> ${filePath}`);
     }
+    console.log(`\nGenerated ${entities.length} entities to ${outputDir}`);
 }
 export async function runDriftCheck(migrator, config) {
     if (!config.entities || config.entities.length === 0) {
         console.error('No entities configured. Add entities to your uql config.');
         process.exit(1);
     }
-    else if (!migrator.schemaIntrospector || !migrator.schemaGenerator) {
-        console.error('No introspector available. Check your pool configuration.');
-        process.exit(1);
-    }
     else {
         console.log('\nChecking for schema drift...');
-        const expectedAST = buildEntityAST(migrator.schemaGenerator, config.entities);
+        const expectedAST = buildEntityAST(await migrator.getSchemaGenerator(), config.entities);
         // Build actual schema from database
         const actualAST = await migrator.schemaIntrospector.introspect();
         // Detect drift. The dialect renders canonical types as SQL - without it every type formats as

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

@@ -98,6 +98,11 @@ export declare class EntityCodeGenerator {
      * Build outgoing relation (ManyToOne or OneToOne where this table has FK).
      */
     private buildOutgoingRelation;
+    /**
+     * The `references` callback of a to-one: its foreign key column where that is the target's whole primary
+     * key, column pairs otherwise, and nothing when the columns do not pair up.
+     */
+    private referencesSource;
     /**
      * Build incoming relation (OneToMany where other tables have FK to this).
      */

package/dist/migrate/codegen/entityCodeGenerator.js

@@ -14,6 +14,7 @@ import { DEFAULT_FOREIGN_KEY_ACTION, } from '../../schema/types.js';
 import { camelCase, lowerFirst, pascalCase, singularize } from '../../util/string.util.js';
 import { buildFieldOptionsSource, fieldNeedsRaw } from './fieldOptionsSource.js';
 import { buildIndexDecoratorSource, indexNeedsRaw, isPlainFieldIndex } from './indexDecoratorSource.js';
+import { memberSource } from './sourceLiteral.js';
 /**
  * Generates TypeScript entity code from SchemaAST.
  */
@@ -234,17 +235,38 @@ export class EntityCodeGenerator {
         }
         // Decorator. `onDelete`/`onUpdate` only when introspection found a real referential action, so a
         // round-trip through an unconstrained column stays as terse as before.
-        const fkActions = [];
+        const options = [`entity: () => ${relatedClassName}`];
+        const references = this.referencesSource(rel, relatedClassName);
+        if (references)
+            options.push(`references: ${references}`);
         if (rel.onDelete && rel.onDelete !== DEFAULT_FOREIGN_KEY_ACTION)
-            fkActions.push(`onDelete: '${rel.onDelete}'`);
+            options.push(`onDelete: '${rel.onDelete}'`);
         if (rel.onUpdate && rel.onUpdate !== DEFAULT_FOREIGN_KEY_ACTION)
-            fkActions.push(`onUpdate: '${rel.onUpdate}'`);
-        const fkActionsSource = fkActions.length ? `, ${fkActions.join(', ')}` : '';
-        lines.push(`  @${decoratorName}({ entity: () => ${relatedClassName}${fkActionsSource} })`);
+            options.push(`onUpdate: '${rel.onUpdate}'`);
+        lines.push(`  @${decoratorName}({ ${options.join(', ')} })`);
         // Property
         lines.push(`  ${propertyName}?: ${relatedClassName};`);
         return lines.join('\n');
     }
+    /**
+     * The `references` callback of a to-one: its foreign key column where that is the target's whole primary
+     * key, column pairs otherwise, and nothing when the columns do not pair up.
+     */
+    referencesSource(rel, relatedClassName) {
+        if (!rel.from.columns.length || rel.from.columns.length !== rel.to.columns.length) {
+            return undefined;
+        }
+        const member = (param, column) => memberSource(param, this.options.propertyNameTransformer(column.name));
+        const own = lowerFirst(this.options.classNameTransformer(rel.from.table.name));
+        const key = rel.to.table.primaryKey;
+        if (rel.from.columns.length === 1 && key.length === 1 && rel.to.columns[0].name === key[0].name) {
+            return `(${own}) => ${member(own, rel.from.columns[0])}`;
+        }
+        const target = lowerFirst(relatedClassName);
+        const [local, foreign] = own === target ? ['local', 'foreign'] : [own, target];
+        const pairs = rel.from.columns.map((column, i) => `{ local: ${member(local, column)}, foreign: ${member(foreign, rel.to.columns[i])} }`);
+        return `(${local}, ${foreign}) => [${pairs.join(', ')}]`;
+    }
     /**
      * Build incoming relation (OneToMany where other tables have FK to this).
      */
@@ -262,9 +284,9 @@ export class EntityCodeGenerator {
             lines.push('   */');
         }
         // 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));
         const param = lowerFirst(relatedClassName);
-        lines.push(`  @${decoratorName}({ entity: () => ${relatedClassName}, mappedBy: (${param}) => ${param}.${inverseProp} })`);
+        const inverse = memberSource(param, this.options.propertyNameTransformer(this.options.singularize(table.name)));
+        lines.push(`  @${decoratorName}({ entity: () => ${relatedClassName}, mappedBy: (${param}) => ${inverse} })`);
         // Property
         if (inverseType === 'OneToMany' || inverseType === 'ManyToMany') {
             lines.push(`  ${propertyName}?: ${relatedClassName}[];`);

package/dist/migrate/codegen/indexDecoratorSource.js

@@ -1,5 +1,5 @@
 import { isVectorIndexType } from '../../type/index.js';
-import { isIdentifierName, quoted, rawTag } from './sourceLiteral.js';
+import { memberSource, 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
@@ -93,7 +93,3 @@ function indexEntrySource(entry, propertyName, param) {
     const modifiers = significantModifiers(entry);
     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/migrationFile.d.ts

@@ -28,14 +28,22 @@ export declare function emitMongoCommandCalls(statements: string[]): string;
 export declare const EMPTY_MANUAL_MIGRATION_UP_INNER = "    // Add your migration logic here.\n    // Use one await querier.run(\"...\") per SQL statement when possible (same style as generate:entities).\n    // Example (Postgres):\n    // await querier.run(\"CREATE TABLE \\\"users\\\" (\\\"id\\\" SERIAL PRIMARY KEY);\");\n";
 /** Body for `down` in a manual (empty) migration scaffold. */
 export declare const EMPTY_MANUAL_MIGRATION_DOWN_INNER = "    // Add your rollback logic here.\n    // await querier.run(\"DROP TABLE IF EXISTS \\\"users\\\";\");\n";
-/** How a migration on each querier is scaffolded empty, and how a generated statement is spelled in it. */
+/** How a migration on one querier is scaffolded empty, and how a generated statement is spelled in it. */
+export type MigrationSource = {
+    readonly querier: MigrationQuerierType;
+    readonly emptyUp: string;
+    readonly emptyDown: string;
+    emit(statements: string[]): string;
+};
 export declare const migrationSource: {
     SqlQuerier: {
+        querier: "SqlQuerier";
         emptyUp: string;
         emptyDown: string;
         emit: typeof emitSqlRunCalls;
     };
     MongoQuerier: {
+        querier: "MongoQuerier";
         emptyUp: string;
         emptyDown: string;
         emit: typeof emitMongoCommandCalls;

package/dist/migrate/codegen/migrationFile.js

@@ -24,14 +24,15 @@ export const EMPTY_MANUAL_MIGRATION_UP_INNER = `    // Add your migration logic
 export const EMPTY_MANUAL_MIGRATION_DOWN_INNER = `    // Add your rollback logic here.
     // await querier.run("DROP TABLE IF EXISTS \\"users\\";");
 `;
-/** How a migration on each querier is scaffolded empty, and how a generated statement is spelled in it. */
 export const migrationSource = {
     SqlQuerier: {
+        querier: 'SqlQuerier',
         emptyUp: EMPTY_MANUAL_MIGRATION_UP_INNER,
         emptyDown: EMPTY_MANUAL_MIGRATION_DOWN_INNER,
         emit: emitSqlRunCalls,
     },
     MongoQuerier: {
+        querier: 'MongoQuerier',
         emptyUp: `    // Add your migration logic here, through the database handle.
     // await querier.db.collection('users').updateMany({}, { $set: { active: true } });
 `,

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

@@ -6,6 +6,8 @@ export declare function isIdentifierName(text: string): boolean;
  * parsing.
  */
 export declare function quoted(text: string): string;
+/** `user.email`, or `user['first-name']` for a property name that is no identifier. */
+export declare function memberSource(param: string, property: string): string;
 /**
  * SQL as a `raw` tagged template. A database reprints an expression as arbitrary text, and exactly
  * three sequences can end or interpolate a template literal, so escaping those is the whole job.

package/dist/migrate/codegen/sourceLiteral.js

@@ -10,6 +10,10 @@ export function isIdentifierName(text) {
 export function quoted(text) {
     return `'${text.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
 }
+/** `user.email`, or `user['first-name']` for a property name that is no identifier. */
+export function memberSource(param, property) {
+    return isIdentifierName(property) ? `${param}.${property}` : `${param}[${quoted(property)}]`;
+}
 /**
  * SQL as a `raw` tagged template. A database reprints an expression as arbitrary text, and exactly
  * three sequences can end or interpolate a template literal, so escaping those is the whole job.

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

@@ -1,6 +1,10 @@
 import type { AbstractSqlDialect } from '../../dialect/abstractSqlDialect.js';
 import { type IndexType } from '../../schema/types.js';
 import { type IndexColumnSchema, type IndexFeature, type IndexJsonArray, type IndexSchema } from '../../type/index.js';
+/** Refuses an index of a type `types` lacks, `hints` naming what to declare instead. */
+export declare function assertIndexType(index: IndexSchema, types: ReadonlySet<IndexType>, dialectName: string, hints?: ReadonlyMap<IndexType, string>): void;
+/** Refuses an index asking for a feature `features` lacks. */
+export declare function assertIndexFeatures(index: IndexSchema, features: ReadonlySet<IndexFeature>, dialectName: string): void;
 /**
  * `CREATE INDEX` for SQL dialects: the statement and the fragments each engine spells differently.
  * The migrator's rather than the dialect's, since {@link SqlSchemaGenerator} is the only thing that
@@ -28,8 +32,6 @@ export declare class IndexDdl<D extends AbstractSqlDialect = AbstractSqlDialect>
     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`)
      * rather than as an access method after the table. One table drives both, so a type that is a

package/dist/migrate/ddl/indexDdl.js

@@ -17,6 +17,20 @@ const INDEX_FEATURE_PROBES = {
     opsClass: (index) => index.entries.some((entry) => entry.opsClass !== undefined),
     include: (index) => Boolean(index.include?.length),
 };
+/** Refuses an index of a type `types` lacks, `hints` naming what to declare instead. */
+export function assertIndexType(index, types, dialectName, hints = new Map()) {
+    if (index.type && !types.has(index.type)) {
+        throw new TypeError(`${dialectName} has no ${index.type} index (index "${index.name}")` + (hints.get(index.type) ?? ''));
+    }
+}
+/** Refuses an index asking for a feature `features` lacks. */
+export function assertIndexFeatures(index, features, dialectName) {
+    for (const feature of getKeys(INDEX_FEATURE_PROBES)) {
+        if (INDEX_FEATURE_PROBES[feature](index) && !features.has(feature)) {
+            throw new TypeError(`${dialectName} does not support ${INDEX_FEATURE_LABELS[feature]} (index "${index.name}")`);
+        }
+    }
+}
 /**
  * `CREATE INDEX` for SQL dialects: the statement and the fragments each engine spells differently.
  * The migrator's rather than the dialect's, since {@link SqlSchemaGenerator} is the only thing that
@@ -30,8 +44,8 @@ export class IndexDdl {
         this.dialect = dialect;
     }
     getCreateIndexStatement(tableName, index, opts = {}) {
-        this.assertIndexType(index);
-        this.assertIndexFeatures(index);
+        assertIndexType(index, this.indexTypes, this.dialect.dialectName, this.indexTypeHints);
+        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(', ');
@@ -57,19 +71,6 @@ export class IndexDdl {
     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)) {
-                throw new TypeError(`${this.dialect.dialectName} does not support ${INDEX_FEATURE_LABELS[feature]} (index "${index.name}")`);
-            }
-        }
-    }
     /**
      * Index types this dialect spells as a keyword of their own (`FULLTEXT INDEX`, `VECTOR INDEX`)
      * rather than as an access method after the table. One table drives both, so a type that is a

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

@@ -1,12 +1,18 @@
 /** The direction, or `'text'`, of one field in a MongoDB index key spec. */
 export type MongoIndexKey = Record<string, 1 | -1 | 'text'>;
+/** What a `createIndex` command hands the driver beside its key spec. */
+export type MongoIndexOptions = {
+    readonly unique: boolean;
+    readonly name: string;
+    readonly partialFilterExpression?: Readonly<Record<string, unknown>>;
+};
 /**
  * `SchemaGenerator` yields one string per statement, so {@link MongoSchemaGenerator} emits its
  * commands as JSON and this is their schema.
  *
  * Declared next to the generator that writes them because the migrator used to restate the shape
  * inline from `JSON.parse`, with `cmd.name!` assertions and a bare `action: string` - where a command
- * it had no branch for (`renameCollection`) was silently a no-op.
+ * it had no branch for was silently a no-op.
  */
 export type MongoCommand = {
     readonly action: 'createCollection';
@@ -23,10 +29,7 @@ export type MongoCommand = {
     readonly collection: string;
     readonly name: string;
     readonly key: MongoIndexKey;
-    readonly options: {
-        readonly unique: boolean;
-        readonly name: string;
-    };
+    readonly options: MongoIndexOptions;
 } | {
     readonly action: 'dropIndex';
     readonly collection: string;
@@ -43,10 +46,7 @@ export type MongoCommandTarget = {
     renameCollection(from: string, to: string): Promise<unknown>;
     collection(name: string): {
         drop(): Promise<unknown>;
-        createIndex(key: MongoIndexKey, options: {
-            unique: boolean;
-            name: string;
-        }): Promise<unknown>;
+        createIndex(key: MongoIndexKey, options: MongoIndexOptions): Promise<unknown>;
         dropIndex(name: string): Promise<unknown>;
     };
 };

package/dist/migrate/generator/mongoCommand.js

@@ -27,7 +27,7 @@ export function runMongoCommand(db, statement) {
             return db.collection(command.collection).dropIndex(command.name);
         default:
             // Unreachable for a command this module produced; a hand-written statement lands here rather
-            // than being silently skipped, which is how `renameCollection` went unnoticed.
+            // than being silently skipped.
             throw unsupportedMongoCommand(statement);
     }
 }

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

@@ -1,12 +1,9 @@
-import { AbstractDialect } from '../../dialect/abstractDialect.js';
-import type { ForeignKeyAction, IndexNode, TableNode } from '../../schema/types.js';
-import type { CreateSchemaOptions, FieldOptions, IndexSchema, InsertIdSource, NamingStrategy, SchemaDiff, SchemaGenerator, Type } from '../../type/index.js';
-import type { TableDefinition } from '../builder/types.js';
-export declare class MongoSchemaGenerator extends AbstractDialect implements SchemaGenerator {
+import { MongoDialect } from '../../mongo/mongoDialect.js';
+import type { ForeignKeyAction, TableNode } from '../../schema/types.js';
+import { type CreateSchemaOptions, type EntityWhereMeta, type IndexSchema, type NamingStrategy, type SchemaDiff, type SchemaGenerator, type Type } from '../../type/index.js';
+import type { AnyMigrationOperation } from '../builder/types.js';
+export declare class MongoSchemaGenerator extends MongoDialect implements SchemaGenerator {
     protected readonly defaultForeignKeyAction?: ForeignKeyAction | undefined;
-    readonly dialectName = "mongodb";
-    protected readonly featureDefaults: import("../../type/dialect.js").DialectFeatures;
-    readonly insertIdSource: InsertIdSource;
     constructor(namingStrategy?: NamingStrategy, defaultForeignKeyAction?: ForeignKeyAction | undefined);
     /** A collection has no SQL to render a check, a computed column or an index expression into. */
     compileDdl(): string;
@@ -19,13 +16,18 @@ export declare class MongoSchemaGenerator extends AbstractDialect implements Sch
     generateDropSchema(entities: readonly Type<object>[]): string[];
     private selected;
     /**
-     * The indexes `@Field({ index })` declares, as the collection would hold them.
-     *
-     * One owner because two paths need it: creating a collection, and working out which of its indexes
-     * are missing. Derived twice, they drifted the moment either changed how a name is settled.
+     * The indexes an entity declares, as the collection would hold them. One owner because two paths need
+     * it: creating a collection, and working out which of its indexes are missing.
+     */
+    private indexesOf;
+    /** One declared index, its members resolved to document paths and its `where` to a filter document. */
+    private indexSchema;
+    /**
+     * The JSON of the document `partialFilterExpression` takes, refused where the predicate reaches past
+     * what that holds or what a migration carries as JSON.
      */
-    private fieldIndexes;
-    generateCreateTable<E>(entity: Type<E>, _options?: {
+    compileIndexPredicate(where: EntityWhereMeta<object>, entity: Type<object>, indexName: string): string;
+    generateCreateTable<E extends object>(entity: Type<E>, _options?: {
         ifNotExists?: boolean;
     }): string[];
     generateDropTable(tableName: string): string;
@@ -35,20 +37,13 @@ export declare class MongoSchemaGenerator extends AbstractDialect implements Sch
      * MongoDB's key spec is where its index options live: `-1` for a descending entry and `'text'` for a
      * full-text index, which is what `$text` needs since a text index declares its own fields.
      *
-     * @remarks The SQL-only modifiers are refused rather than dropped, for the same reason the SQL
-     * dialects refuse each other's - a silently weaker index is worse than a clear failure. `where`
-     * included: MongoDB's partial indexes take a filter document, not a SQL predicate.
+     * @remarks The SQL-only options are refused by the checks the SQL dialects refuse each other's with - a
+     * silently weaker index is worse than a clear failure. `where` is the filter's JSON, as
+     * {@link compileIndexPredicate} writes it.
      */
     generateCreateIndex(tableName: string, index: IndexSchema): string;
     generateDropIndex(tableName: string, indexName: string): string;
-    getSqlType(fieldOptions: FieldOptions): string;
-    generateCreateTableFromNode(table: TableNode, _options?: {
-        ifNotExists?: boolean;
-    }): string[];
-    generateCreateIndexFromNode(index: IndexNode): string;
-    generateCreateTableFromDefinition(table: TableDefinition, _options?: {
-        ifNotExists?: boolean;
-    }): string[];
-    generateRenameTableSql(oldName: string, newName: 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[];
     diffSchema(entity: Type<object>, currentTable: TableNode | undefined): SchemaDiff | undefined;
 }