@mikro-orm/sql 7.0.0-dev.97 → 7.0.0-dev.98

package/schema/SqlSchemaGenerator.js

@@ -0,0 +1,375 @@
+import { AbstractSchemaGenerator, Utils, } from '@mikro-orm/core';
+import { DatabaseSchema } from './DatabaseSchema.js';
+import { SchemaComparator } from './SchemaComparator.js';
+export class SqlSchemaGenerator extends AbstractSchemaGenerator {
+    helper = this.platform.getSchemaHelper();
+    options = this.config.get('schemaGenerator');
+    lastEnsuredDatabase;
+    static register(orm) {
+        orm.config.registerExtension('@mikro-orm/schema-generator', () => new SqlSchemaGenerator(orm.em));
+    }
+    async create(options) {
+        await this.ensureDatabase();
+        const sql = await this.getCreateSchemaSQL(options);
+        await this.execute(sql);
+    }
+    /**
+     * Returns true if the database was created.
+     */
+    async ensureDatabase(options) {
+        await this.connection.ensureConnection();
+        const dbName = this.config.get('dbName');
+        if (this.lastEnsuredDatabase === dbName && !options?.forceCheck) {
+            return true;
+        }
+        const exists = await this.helper.databaseExists(this.connection, dbName);
+        this.lastEnsuredDatabase = dbName;
+        if (!exists) {
+            const managementDbName = this.helper.getManagementDbName();
+            if (managementDbName) {
+                this.config.set('dbName', managementDbName);
+                await this.driver.reconnect({ skipOnConnect: true });
+                await this.createDatabase(dbName, { skipOnConnect: true });
+            }
+            if (options?.create) {
+                await this.create(options);
+            }
+            return true;
+        }
+        /* v8 ignore next */
+        if (options?.clear) {
+            await this.clear({ ...options, clearIdentityMap: false });
+        }
+        return false;
+    }
+    getTargetSchema(schema) {
+        const metadata = this.getOrderedMetadata(schema);
+        const schemaName = schema ?? this.config.get('schema') ?? this.platform.getDefaultSchemaName();
+        return DatabaseSchema.fromMetadata(metadata, this.platform, this.config, schemaName);
+    }
+    getOrderedMetadata(schema) {
+        const metadata = super.getOrderedMetadata(schema);
+        // Filter out skipped tables
+        return metadata.filter(meta => {
+            const tableName = meta.tableName;
+            const tableSchema = meta.schema ?? schema ?? this.config.get('schema');
+            return !this.isTableSkipped(tableName, tableSchema);
+        });
+    }
+    async getCreateSchemaSQL(options = {}) {
+        const toSchema = this.getTargetSchema(options.schema);
+        const ret = [];
+        for (const namespace of toSchema.getNamespaces()) {
+            if (namespace === this.platform.getDefaultSchemaName()) {
+                continue;
+            }
+            const sql = this.helper.getCreateNamespaceSQL(namespace);
+            this.append(ret, sql);
+        }
+        if (this.platform.supportsNativeEnums()) {
+            const created = [];
+            for (const [enumName, enumOptions] of Object.entries(toSchema.getNativeEnums())) {
+                /* v8 ignore next */
+                if (created.includes(enumName)) {
+                    continue;
+                }
+                created.push(enumName);
+                const sql = this.helper.getCreateNativeEnumSQL(enumOptions.name, enumOptions.items, this.getSchemaName(enumOptions, options));
+                this.append(ret, sql);
+            }
+        }
+        for (const table of toSchema.getTables()) {
+            this.append(ret, this.helper.createTable(table), true);
+        }
+        if (this.helper.supportsSchemaConstraints()) {
+            for (const table of toSchema.getTables()) {
+                const fks = Object.values(table.getForeignKeys()).map(fk => this.helper.createForeignKey(table, fk));
+                this.append(ret, fks, true);
+            }
+        }
+        return this.wrapSchema(ret, options);
+    }
+    async drop(options = {}) {
+        if (options.dropDb) {
+            const name = this.config.get('dbName');
+            return this.dropDatabase(name);
+        }
+        const sql = await this.getDropSchemaSQL(options);
+        await this.execute(sql);
+    }
+    async createNamespace(name) {
+        const sql = this.helper.getCreateNamespaceSQL(name);
+        await this.execute(sql);
+    }
+    async dropNamespace(name) {
+        const sql = this.helper.getDropNamespaceSQL(name);
+        await this.execute(sql);
+    }
+    async clear(options) {
+        // truncate by default, so no value is considered as true
+        /* v8 ignore next */
+        if (options?.truncate === false) {
+            return super.clear(options);
+        }
+        await this.execute(this.helper.disableForeignKeysSQL());
+        const schema = options?.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());
+        for (const meta of this.getOrderedMetadata(schema).reverse()) {
+            await this.driver.createQueryBuilder(meta.className, this.em?.getTransactionContext(), 'write', false)
+                .withSchema(schema)
+                .truncate()
+                .execute();
+        }
+        await this.execute(this.helper.enableForeignKeysSQL());
+        if (options?.clearIdentityMap ?? true) {
+            this.clearIdentityMap();
+        }
+    }
+    async getDropSchemaSQL(options = {}) {
+        await this.ensureDatabase();
+        const metadata = this.getOrderedMetadata(options.schema).reverse();
+        const schemas = this.getTargetSchema(options.schema).getNamespaces();
+        const schema = await DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas);
+        const ret = [];
+        // remove FKs explicitly if we can't use a cascading statement and we don't disable FK checks (we need this for circular relations)
+        for (const meta of metadata) {
+            if (!this.platform.usesCascadeStatement() && (!this.options.disableForeignKeys || options.dropForeignKeys)) {
+                const table = schema.getTable(meta.tableName);
+                if (!table) {
+                    continue;
+                }
+                const foreignKeys = Object.values(table.getForeignKeys());
+                for (const fk of foreignKeys) {
+                    this.append(ret, this.helper.dropForeignKey(table.getShortestName(), fk.constraintName));
+                }
+            }
+        }
+        for (const meta of metadata) {
+            this.append(ret, this.helper.dropTableIfExists(meta.tableName, this.getSchemaName(meta, options)));
+        }
+        if (this.platform.supportsNativeEnums()) {
+            for (const columnName of Object.keys(schema.getNativeEnums())) {
+                const sql = this.helper.getDropNativeEnumSQL(columnName, options.schema ?? this.config.get('schema'));
+                this.append(ret, sql);
+            }
+        }
+        if (options.dropMigrationsTable) {
+            this.append(ret, this.helper.dropTableIfExists(this.config.get('migrations').tableName, this.config.get('schema')));
+        }
+        return this.wrapSchema(ret, options);
+    }
+    getSchemaName(meta, options) {
+        const schemaName = options.schema ?? this.config.get('schema');
+        /* v8 ignore next */
+        const resolvedName = meta.schema && meta.schema === '*' ? schemaName : (meta.schema ?? schemaName);
+        // skip default schema name
+        if (resolvedName === this.platform.getDefaultSchemaName()) {
+            return undefined;
+        }
+        return resolvedName;
+    }
+    async update(options = {}) {
+        const sql = await this.getUpdateSchemaSQL(options);
+        await this.execute(sql);
+    }
+    async getUpdateSchemaSQL(options = {}) {
+        await this.ensureDatabase();
+        const { fromSchema, toSchema } = await this.prepareSchemaForComparison(options);
+        const comparator = new SchemaComparator(this.platform);
+        const diffUp = comparator.compare(fromSchema, toSchema);
+        return this.diffToSQL(diffUp, options);
+    }
+    async getUpdateSchemaMigrationSQL(options = {}) {
+        if (!options.fromSchema) {
+            await this.ensureDatabase();
+        }
+        const { fromSchema, toSchema } = await this.prepareSchemaForComparison(options);
+        const comparator = new SchemaComparator(this.platform);
+        const diffUp = comparator.compare(fromSchema, toSchema);
+        const diffDown = comparator.compare(toSchema, fromSchema, diffUp);
+        return {
+            up: this.diffToSQL(diffUp, options),
+            down: this.platform.supportsDownMigrations() ? this.diffToSQL(diffDown, options) : '',
+        };
+    }
+    async prepareSchemaForComparison(options) {
+        options.safe ??= false;
+        options.dropTables ??= true;
+        const toSchema = this.getTargetSchema(options.schema);
+        const schemas = toSchema.getNamespaces();
+        const fromSchema = options.fromSchema ?? (await DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas, undefined, this.options.skipTables));
+        const wildcardSchemaTables = Object.values(this.metadata.getAll()).filter(meta => meta.schema === '*').map(meta => meta.tableName);
+        fromSchema.prune(options.schema, wildcardSchemaTables);
+        toSchema.prune(options.schema, wildcardSchemaTables);
+        return { fromSchema, toSchema };
+    }
+    diffToSQL(schemaDiff, options) {
+        const ret = [];
+        globalThis.idx = 0;
+        if (this.platform.supportsSchemas()) {
+            for (const newNamespace of schemaDiff.newNamespaces) {
+                const sql = this.helper.getCreateNamespaceSQL(newNamespace);
+                this.append(ret, sql);
+            }
+        }
+        if (this.platform.supportsNativeEnums()) {
+            for (const newNativeEnum of schemaDiff.newNativeEnums) {
+                const sql = this.helper.getCreateNativeEnumSQL(newNativeEnum.name, newNativeEnum.items, this.getSchemaName(newNativeEnum, options));
+                this.append(ret, sql);
+            }
+        }
+        if (!options.safe && this.options.createForeignKeyConstraints) {
+            for (const orphanedForeignKey of schemaDiff.orphanedForeignKeys) {
+                const [schemaName, tableName] = this.helper.splitTableName(orphanedForeignKey.localTableName, true);
+                /* v8 ignore next */
+                const name = (schemaName ? schemaName + '.' : '') + tableName;
+                this.append(ret, this.helper.dropForeignKey(name, orphanedForeignKey.constraintName));
+            }
+            if (schemaDiff.orphanedForeignKeys.length > 0) {
+                ret.push('');
+            }
+        }
+        for (const newTable of Object.values(schemaDiff.newTables)) {
+            this.append(ret, this.helper.createTable(newTable, true), true);
+        }
+        if (this.helper.supportsSchemaConstraints()) {
+            for (const newTable of Object.values(schemaDiff.newTables)) {
+                const sql = [];
+                if (this.options.createForeignKeyConstraints) {
+                    const fks = Object.values(newTable.getForeignKeys()).map(fk => this.helper.createForeignKey(newTable, fk));
+                    this.append(sql, fks);
+                }
+                for (const check of newTable.getChecks()) {
+                    this.append(sql, this.helper.createCheck(newTable, check));
+                }
+                this.append(ret, sql, true);
+            }
+        }
+        if (options.dropTables && !options.safe) {
+            for (const table of Object.values(schemaDiff.removedTables)) {
+                this.append(ret, this.helper.dropTableIfExists(table.name, table.schema));
+            }
+            if (Utils.hasObjectKeys(schemaDiff.removedTables)) {
+                ret.push('');
+            }
+        }
+        for (const changedTable of Object.values(schemaDiff.changedTables)) {
+            this.append(ret, this.preAlterTable(changedTable, options.safe), true);
+        }
+        for (const changedTable of Object.values(schemaDiff.changedTables)) {
+            this.append(ret, this.helper.alterTable(changedTable, options.safe), true);
+        }
+        for (const changedTable of Object.values(schemaDiff.changedTables)) {
+            this.append(ret, this.helper.getPostAlterTable(changedTable, options.safe), true);
+        }
+        if (!options.safe && this.platform.supportsNativeEnums()) {
+            for (const removedNativeEnum of schemaDiff.removedNativeEnums) {
+                this.append(ret, this.helper.getDropNativeEnumSQL(removedNativeEnum.name, removedNativeEnum.schema));
+            }
+        }
+        if (options.dropTables && !options.safe) {
+            for (const removedNamespace of schemaDiff.removedNamespaces) {
+                const sql = this.helper.getDropNamespaceSQL(removedNamespace);
+                this.append(ret, sql);
+            }
+        }
+        return this.wrapSchema(ret, options);
+    }
+    /**
+     * We need to drop foreign keys first for all tables to allow dropping PK constraints.
+     */
+    preAlterTable(diff, safe) {
+        const ret = [];
+        this.append(ret, this.helper.getPreAlterTable(diff, safe));
+        for (const foreignKey of Object.values(diff.removedForeignKeys)) {
+            ret.push(this.helper.dropForeignKey(diff.toTable.getShortestName(), foreignKey.constraintName));
+        }
+        for (const foreignKey of Object.values(diff.changedForeignKeys)) {
+            ret.push(this.helper.dropForeignKey(diff.toTable.getShortestName(), foreignKey.constraintName));
+        }
+        return ret;
+    }
+    /**
+     * creates new database and connects to it
+     */
+    async createDatabase(name, options) {
+        name ??= this.config.get('dbName');
+        const sql = this.helper.getCreateDatabaseSQL('' + this.platform.quoteIdentifier(name));
+        if (sql) {
+            await this.execute(sql);
+        }
+        this.config.set('dbName', name);
+        await this.driver.reconnect(options);
+    }
+    async dropDatabase(name) {
+        name ??= this.config.get('dbName');
+        this.config.set('dbName', this.helper.getManagementDbName());
+        await this.driver.reconnect();
+        await this.execute(this.helper.getDropDatabaseSQL(name));
+        this.config.set('dbName', name);
+    }
+    async execute(sql, options = {}) {
+        options.wrap ??= false;
+        const lines = this.wrapSchema(sql, options).split('\n');
+        const groups = [];
+        let i = 0;
+        for (const line of lines) {
+            if (line.trim() === '') {
+                if (groups[i]?.length > 0) {
+                    i++;
+                }
+                continue;
+            }
+            groups[i] ??= [];
+            groups[i].push(line.trim());
+        }
+        if (groups.length === 0) {
+            return;
+        }
+        if (this.platform.supportsMultipleStatements()) {
+            for (const group of groups) {
+                const query = group.join('\n');
+                await this.driver.execute(query);
+            }
+            return;
+        }
+        await Utils.runSerial(groups.flat(), line => this.driver.execute(line));
+    }
+    async dropTableIfExists(name, schema) {
+        const sql = this.helper.dropTableIfExists(name, schema);
+        return this.execute(sql);
+    }
+    wrapSchema(sql, options) {
+        const array = Utils.asArray(sql);
+        if (array.length === 0) {
+            return '';
+        }
+        if (array[array.length - 1] === '') {
+            array.pop();
+        }
+        if (options.wrap === false) {
+            return array.join('\n') + '\n';
+        }
+        let ret = this.helper.getSchemaBeginning(this.config.get('charset'), this.options.disableForeignKeys);
+        ret += array.join('\n') + '\n';
+        ret += this.helper.getSchemaEnd(this.options.disableForeignKeys);
+        return ret;
+    }
+    append(array, sql, pad) {
+        return this.helper.append(array, sql, pad);
+    }
+    matchName(name, nameToMatch) {
+        return typeof nameToMatch === 'string'
+            ? name.toLocaleLowerCase() === nameToMatch.toLocaleLowerCase()
+            : nameToMatch.test(name);
+    }
+    isTableSkipped(tableName, schemaName) {
+        const skipTables = this.options.skipTables;
+        if (!skipTables || skipTables.length === 0) {
+            return false;
+        }
+        const fullTableName = schemaName ? `${schemaName}.${tableName}` : tableName;
+        return skipTables.some(pattern => this.matchName(tableName, pattern) || this.matchName(fullTableName, pattern));
+    }
+}
+// for back compatibility
+export { SqlSchemaGenerator as SchemaGenerator };

package/schema/index.d.ts

@@ -0,0 +1,5 @@
+export * from './DatabaseSchema.js';
+export * from './DatabaseTable.js';
+export * from './SqlSchemaGenerator.js';
+export * from './SchemaHelper.js';
+export * from './SchemaComparator.js';

package/schema/index.js

@@ -0,0 +1,5 @@
+export * from './DatabaseSchema.js';
+export * from './DatabaseTable.js';
+export * from './SqlSchemaGenerator.js';
+export * from './SchemaHelper.js';
+export * from './SchemaComparator.js';

package/typings.d.ts

@@ -0,0 +1,272 @@
+import type { Generated, Kysely } from 'kysely';
+import type { DeferMode, CheckCallback, Dictionary, EntityProperty, GroupOperator, RawQueryFragment, QBFilterQuery, QueryOrderMap, Type, QueryFlag, AnyEntity, EntityName, EntitySchemaWithMeta, Primary, PrimaryProperty, Opt } from '@mikro-orm/core';
+import type { JoinType, QueryType } from './query/enums.js';
+import type { DatabaseSchema } from './schema/DatabaseSchema.js';
+import type { DatabaseTable } from './schema/DatabaseTable.js';
+import type { QueryBuilder } from './query/QueryBuilder.js';
+import type { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
+import type { MikroKyselyPluginOptions } from './plugin/index.js';
+export interface Table {
+    table_name: string;
+    schema_name?: string;
+    table_comment?: string;
+}
+type AnyString = string & {};
+export type Field<T> = AnyString | keyof T | RawQueryFragment | QueryBuilder | NativeQueryBuilder;
+export interface JoinOptions {
+    table: string;
+    schema?: string;
+    type: JoinType;
+    alias: string;
+    ownerAlias: string;
+    inverseAlias?: string;
+    joinColumns?: string[];
+    inverseJoinColumns?: string[];
+    primaryKeys?: string[];
+    path?: string;
+    prop: EntityProperty;
+    cond: Dictionary;
+    cond_?: Dictionary;
+    subquery?: string;
+    nested?: Set<JoinOptions>;
+    parent?: JoinOptions;
+}
+export interface Column {
+    name: string;
+    type: string;
+    mappedType: Type<unknown>;
+    unsigned?: boolean;
+    autoincrement?: boolean;
+    nullable?: boolean;
+    length?: number;
+    precision?: number;
+    scale?: number;
+    default?: string | null;
+    defaultConstraint?: string;
+    comment?: string;
+    generated?: string;
+    nativeEnumName?: string;
+    enumItems?: string[];
+    primary?: boolean;
+    unique?: boolean;
+    /** mysql only */
+    extra?: string;
+    ignoreSchemaChanges?: ('type' | 'extra' | 'default')[];
+}
+export interface ForeignKey {
+    columnNames: string[];
+    constraintName: string;
+    localTableName: string;
+    referencedTableName: string;
+    referencedColumnNames: string[];
+    updateRule?: string;
+    deleteRule?: string;
+    deferMode?: DeferMode;
+}
+export interface IndexDef {
+    columnNames: string[];
+    keyName: string;
+    unique: boolean;
+    constraint: boolean;
+    primary: boolean;
+    composite?: boolean;
+    expression?: string;
+    options?: Dictionary;
+    type?: string | Readonly<{
+        indexType?: string;
+        storageEngineIndexType?: 'hash' | 'btree';
+        predicate?: string;
+    }>;
+    deferMode?: DeferMode | `${DeferMode}`;
+}
+export interface CheckDef<T = unknown> {
+    name: string;
+    expression: string | CheckCallback<T>;
+    definition?: string;
+    columnName?: string;
+}
+export interface ColumnDifference {
+    oldColumnName: string;
+    column: Column;
+    fromColumn: Column;
+    changedProperties: Set<string>;
+}
+export interface TableDifference {
+    name: string;
+    changedComment?: string;
+    fromTable: DatabaseTable;
+    toTable: DatabaseTable;
+    addedColumns: Dictionary<Column>;
+    changedColumns: Dictionary<ColumnDifference>;
+    removedColumns: Dictionary<Column>;
+    renamedColumns: Dictionary<Column>;
+    addedIndexes: Dictionary<IndexDef>;
+    changedIndexes: Dictionary<IndexDef>;
+    removedIndexes: Dictionary<IndexDef>;
+    renamedIndexes: Dictionary<IndexDef>;
+    addedChecks: Dictionary<CheckDef>;
+    changedChecks: Dictionary<CheckDef>;
+    removedChecks: Dictionary<CheckDef>;
+    addedForeignKeys: Dictionary<ForeignKey>;
+    changedForeignKeys: Dictionary<ForeignKey>;
+    removedForeignKeys: Dictionary<ForeignKey>;
+}
+export interface SchemaDifference {
+    newNamespaces: Set<string>;
+    newNativeEnums: {
+        name: string;
+        schema?: string;
+        items: string[];
+    }[];
+    newTables: Dictionary<DatabaseTable>;
+    changedTables: Dictionary<TableDifference>;
+    removedTables: Dictionary<DatabaseTable>;
+    removedNamespaces: Set<string>;
+    removedNativeEnums: {
+        name: string;
+        schema?: string;
+    }[];
+    orphanedForeignKeys: ForeignKey[];
+    fromSchema: DatabaseSchema;
+}
+export interface IQueryBuilder<T> {
+    readonly alias: string;
+    readonly type: QueryType;
+    _fields?: Field<T>[];
+    /** @internal */
+    helper: any;
+    select(fields: Field<T> | Field<T>[], distinct?: boolean): this;
+    addSelect(fields: string | string[]): this;
+    from<T extends AnyEntity<T> = AnyEntity>(target: EntityName<T> | IQueryBuilder<T>, aliasName?: string): IQueryBuilder<T>;
+    insert(data: any): this;
+    update(data: any): this;
+    delete(cond?: QBFilterQuery): this;
+    truncate(): this;
+    count(field?: string | string[], distinct?: boolean): this;
+    join(field: string, alias: string, cond?: QBFilterQuery, type?: JoinType, path?: string): this;
+    innerJoin(field: string, alias: string, cond?: QBFilterQuery): this;
+    leftJoin(field: string, alias: string, cond?: QBFilterQuery): this;
+    joinAndSelect(field: string, alias: string, cond?: QBFilterQuery): this;
+    leftJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery, fields?: string[]): this;
+    innerJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery, fields?: string[]): this;
+    withSubQuery(subQuery: RawQueryFragment | NativeQueryBuilder, alias: string): this;
+    where(cond: QBFilterQuery<T>, operator?: keyof typeof GroupOperator): this;
+    where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;
+    andWhere(cond: QBFilterQuery<T>): this;
+    andWhere(cond: string, params?: any[]): this;
+    orWhere(cond: QBFilterQuery<T>): this;
+    orWhere(cond: string, params?: any[]): this;
+    orderBy(orderBy: QueryOrderMap<T>): this;
+    groupBy(fields: (string | keyof T) | (string | keyof T)[]): this;
+    having(cond?: QBFilterQuery | string, params?: any[]): this;
+    getAliasForJoinPath(path: string, options?: ICriteriaNodeProcessOptions): string | undefined;
+    getJoinForPath(path?: string, options?: ICriteriaNodeProcessOptions): JoinOptions | undefined;
+    getNextAlias(entityName?: string): string;
+    clone(reset?: boolean): IQueryBuilder<T>;
+    setFlag(flag: QueryFlag): this;
+    unsetFlag(flag: QueryFlag): this;
+    hasFlag(flag: QueryFlag): boolean;
+    scheduleFilterCheck(path: string): void;
+}
+export interface ICriteriaNodeProcessOptions {
+    alias?: string;
+    matchPopulateJoins?: boolean;
+    ignoreBranching?: boolean;
+    preferNoBranch?: boolean;
+    type?: 'orderBy';
+    filter?: boolean;
+}
+export interface ICriteriaNode<T extends object> {
+    readonly entityName: string;
+    readonly parent?: ICriteriaNode<T> | undefined;
+    readonly key?: string | undefined;
+    readonly strict?: boolean;
+    payload: any;
+    prop?: EntityProperty;
+    index?: number;
+    process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
+    shouldInline(payload: any): boolean;
+    willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
+    shouldRename(payload: any): boolean;
+    renameFieldToPK<T>(qb: IQueryBuilder<T>, ownerAlias?: string): string;
+    getPath(addIndex?: boolean): string;
+    getPivotPath(path: string): string;
+}
+export type MaybeReturnType<T> = T extends (...args: any[]) => infer R ? R : T;
+export type InferEntityProperties<Schema> = Schema extends EntitySchemaWithMeta<any, any, any, any, infer Properties> ? Properties : never;
+export type InferKyselyDB<TEntities extends {
+    name: string;
+}, TOptions extends MikroKyselyPluginOptions = {}> = MapValueAsTable<MapByName<TEntities>, TOptions>;
+export type InferDBFromKysely<TKysely extends Kysely<any>> = TKysely extends Kysely<infer TDB> ? TDB : never;
+type PreferStringLiteral<TCandidate, TFallback> = [
+    TCandidate
+] extends [never] ? TFallback : string extends TCandidate ? TFallback : TCandidate extends string ? TCandidate : TFallback;
+export type MapByName<T extends {
+    name: string;
+    tableName?: string;
+}> = {
+    [P in T as PreferStringLiteral<NonNullable<P['tableName']>, P['name']>]: P;
+};
+export type MapValueAsTable<TMap extends Record<string, any>, TOptions extends MikroKyselyPluginOptions = {}> = {
+    [K in keyof TMap as TransformName<K, TOptions['tableNamingStrategy'] extends 'entity' ? 'entity' : 'underscore'>]: InferKyselyTable<TMap[K], TOptions>;
+};
+export type InferKyselyTable<TSchema extends EntitySchemaWithMeta, TOptions extends MikroKyselyPluginOptions = {}> = ExcludeNever<{
+    -readonly [K in keyof InferEntityProperties<TSchema> as TransformColumnName<K, TOptions['columnNamingStrategy'] extends 'property' ? 'property' : 'underscore', MaybeReturnType<InferEntityProperties<TSchema>[K]>>]: InferColumnValue<MaybeReturnType<InferEntityProperties<TSchema>[K]>, TOptions['processOnCreateHooks'] extends true ? true : false>;
+}>;
+type TransformName<TName, TNamingStrategy extends 'underscore' | 'entity'> = TNamingStrategy extends 'underscore' ? TName extends string ? SnakeCase<TName> : TName : TName;
+type TransformColumnName<TName, TNamingStrategy extends 'underscore' | 'property', TBuilder> = TNamingStrategy extends 'property' ? TName : TBuilder extends {
+    '~options': {
+        fieldName: string;
+    };
+} ? TBuilder['~options']['fieldName'] : TName extends string ? MaybeJoinColumnName<SnakeCase<TName>, TBuilder> : never;
+type MaybeJoinColumnName<TName extends string, TBuilder> = TBuilder extends {
+    '~type'?: {
+        value: infer Value;
+    };
+    '~options': {
+        kind: 'm:1';
+    };
+} ? PrimaryProperty<Value> extends string ? `${TName}_${SnakeCase<PrimaryProperty<Value>>}` : never : TBuilder extends {
+    '~type'?: {
+        value: infer Value;
+    };
+    '~options': {
+        kind: '1:1';
+        owner: true;
+    };
+} ? PrimaryProperty<Value> extends string ? `${TName}_${SnakeCase<PrimaryProperty<Value>>}` : never : TName;
+export type SnakeCase<TName extends string> = TName extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Uncapitalize<P1>}${SnakeCase<P2>}` : `${Uncapitalize<P1>}_${SnakeCase<Uncapitalize<P2>>}` : TName;
+type InferColumnValue<TBuilder, TProcessOnCreate extends boolean> = TBuilder extends {
+    '~type'?: {
+        value: infer Value;
+    };
+    '~options': infer TOptions;
+} ? MaybeNever<MaybeGenerated<MaybeJoinKey<Value, TOptions>, TOptions, TProcessOnCreate>, TOptions> : never;
+type MaybeGenerated<TValue, TOptions, TProcessOnCreate extends boolean> = TOptions extends {
+    nullable: true;
+} ? (TValue | null) : TOptions extends {
+    autoincrement: true;
+} ? Generated<TValue> : TOptions extends {
+    default: true;
+} ? Generated<TValue> : TOptions extends {
+    defaultRaw: true;
+} ? Generated<TValue> : TProcessOnCreate extends false ? TValue : TOptions extends {
+    onCreate: Function;
+} ? Generated<TValue> : TValue;
+type MaybeJoinKey<TValue, TOptions> = TOptions extends {
+    kind: 'm:1';
+} ? UnwrapOpt<Primary<TValue>> : TOptions extends {
+    kind: '1:1';
+} ? TOptions extends {
+    owner: true;
+} ? UnwrapOpt<Primary<TValue>> : never : TValue;
+type UnwrapOpt<TValue> = TValue extends Opt<infer OriginalValue> ? OriginalValue : TValue;
+type MaybeNever<TValue, TOptions> = TOptions extends {
+    persist: true;
+} ? never : TOptions extends {
+    kind: 'm:n';
+} ? never : TValue;
+type ExcludeNever<TMap extends Record<string, any>> = {
+    [K in keyof TMap as TMap[K] extends never ? never : K]: TMap[K];
+};
+export {};

package/typings.js

@@ -0,0 +1 @@
+export {};