@mikro-orm/knex 7.0.0-dev.8 → 7.0.0-dev.80

package/schema/SqlSchemaGenerator.d.ts

@@ -1,4 +1,4 @@
-import { AbstractSchemaGenerator, type ClearDatabaseOptions, type CreateSchemaOptions, type DropSchemaOptions, type EnsureDatabaseOptions, type ISchemaGenerator, type MikroORM, type Transaction, type UpdateSchemaOptions } from '@mikro-orm/core';
+import { AbstractSchemaGenerator, type ClearDatabaseOptions, type CreateSchemaOptions, type Dictionary, type DropSchemaOptions, type EnsureDatabaseOptions, type EntityMetadata, type ISchemaGenerator, type MikroORM, type Transaction, type UpdateSchemaOptions } from '@mikro-orm/core';
 import type { SchemaDifference } from '../typings.js';
 import { DatabaseSchema } from './DatabaseSchema.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
@@ -8,24 +8,27 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
         disableForeignKeys?: boolean;
         createForeignKeyConstraints?: boolean;
         ignoreSchema?: string[];
+        skipTables?: (string | RegExp)[];
+        skipColumns?: Dictionary<(string | RegExp)[]>;
         managementDbName?: string;
     };
     protected lastEnsuredDatabase?: string;
     static register(orm: MikroORM): void;
-    createSchema(options?: CreateSchemaOptions): Promise<void>;
+    create(options?: CreateSchemaOptions): Promise<void>;
     /**
      * Returns true if the database was created.
      */
     ensureDatabase(options?: EnsureDatabaseOptions): Promise<boolean>;
     getTargetSchema(schema?: string): DatabaseSchema;
+    protected getOrderedMetadata(schema?: string): EntityMetadata[];
     getCreateSchemaSQL(options?: CreateSchemaOptions): Promise<string>;
-    dropSchema(options?: DropSchemaOptions): Promise<void>;
+    drop(options?: DropSchemaOptions): Promise<void>;
     createNamespace(name: string): Promise<void>;
     dropNamespace(name: string): Promise<void>;
-    clearDatabase(options?: ClearDatabaseOptions): Promise<void>;
+    clear(options?: ClearDatabaseOptions): Promise<void>;
     getDropSchemaSQL(options?: Omit<DropSchemaOptions, 'dropDb'>): Promise<string>;
     private getSchemaName;
-    updateSchema(options?: UpdateSchemaOptions<DatabaseSchema>): Promise<void>;
+    update(options?: UpdateSchemaOptions<DatabaseSchema>): Promise<void>;
     getUpdateSchemaSQL(options?: UpdateSchemaOptions<DatabaseSchema>): Promise<string>;
     getUpdateSchemaMigrationSQL(options?: UpdateSchemaOptions<DatabaseSchema>): Promise<{
         up: string;
@@ -45,7 +48,9 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
     /**
      * creates new database and connects to it
      */
-    createDatabase(name?: string): Promise<void>;
+    createDatabase(name?: string, options?: {
+        skipOnConnect?: boolean;
+    }): Promise<void>;
     dropDatabase(name?: string): Promise<void>;
     execute(sql: string, options?: {
         wrap?: boolean;
@@ -54,5 +59,7 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
     dropTableIfExists(name: string, schema?: string): Promise<void>;
     private wrapSchema;
     private append;
+    private matchName;
+    private isTableSkipped;
 }
 export { SqlSchemaGenerator as SchemaGenerator };

package/schema/SqlSchemaGenerator.js

@@ -8,7 +8,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
     static register(orm) {
         orm.config.registerExtension('@mikro-orm/schema-generator', () => new SqlSchemaGenerator(orm.em));
     }
-    async createSchema(options) {
+    async create(options) {
         await this.ensureDatabase();
         const sql = await this.getCreateSchemaSQL(options);
         await this.execute(sql);
@@ -17,6 +17,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
      * 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;
@@ -27,18 +28,17 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
             const managementDbName = this.helper.getManagementDbName();
             if (managementDbName) {
                 this.config.set('dbName', managementDbName);
-                await this.driver.reconnect();
-                await this.createDatabase(dbName);
-                this.config.set('dbName', dbName);
-                await this.driver.reconnect();
+                await this.driver.reconnect({ skipOnConnect: true });
+                await this.createDatabase(dbName, { skipOnConnect: true });
             }
             if (options?.create) {
-                await this.createSchema(options);
+                await this.create(options);
             }
             return true;
         }
+        /* v8 ignore next */
         if (options?.clear) {
-            await this.clearDatabase(options);
+            await this.clear({ ...options, clearIdentityMap: false });
         }
         return false;
     }
@@ -47,6 +47,15 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         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 = [];
@@ -60,7 +69,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         if (this.platform.supportsNativeEnums()) {
             const created = [];
             for (const [enumName, enumOptions] of Object.entries(toSchema.getNativeEnums())) {
-                /* v8 ignore next 3 */
+                /* v8 ignore next */
                 if (created.includes(enumName)) {
                     continue;
                 }
@@ -80,7 +89,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         }
         return this.wrapSchema(ret, options);
     }
-    async dropSchema(options = {}) {
+    async drop(options = {}) {
         if (options.dropDb) {
             const name = this.config.get('dbName');
             return this.dropDatabase(name);
@@ -96,11 +105,11 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         const sql = this.helper.getDropNamespaceSQL(name);
         await this.execute(sql);
     }
-    async clearDatabase(options) {
+    async clear(options) {
         // truncate by default, so no value is considered as true
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (options?.truncate === false) {
-            return super.clearDatabase(options);
+            return super.clear(options);
         }
         await this.execute(this.helper.disableForeignKeysSQL());
         const schema = options?.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());
@@ -111,7 +120,9 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 .execute();
         }
         await this.execute(this.helper.enableForeignKeysSQL());
-        this.clearIdentityMap();
+        if (options?.clearIdentityMap ?? true) {
+            this.clearIdentityMap();
+        }
     }
     async getDropSchemaSQL(options = {}) {
         await this.ensureDatabase();
@@ -156,7 +167,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         }
         return resolvedName;
     }
-    async updateSchema(options = {}) {
+    async update(options = {}) {
         const sql = await this.getUpdateSchemaSQL(options);
         await this.execute(sql);
     }
@@ -280,15 +291,14 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
     /**
      * creates new database and connects to it
      */
-    async createDatabase(name) {
+    async createDatabase(name, options) {
         name ??= this.config.get('dbName');
         const sql = this.helper.getCreateDatabaseSQL('' + this.platform.quoteIdentifier(name));
         if (sql) {
-            // console.log(sql);
             await this.execute(sql);
         }
         this.config.set('dbName', name);
-        await this.driver.reconnect();
+        await this.driver.reconnect(options);
     }
     async dropDatabase(name) {
         name ??= this.config.get('dbName');
@@ -318,12 +328,10 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         if (this.platform.supportsMultipleStatements()) {
             for (const group of groups) {
                 const query = group.join('\n');
-                // console.log(query);
                 await this.driver.execute(query);
             }
             return;
         }
-        // console.log(groups);
         await Utils.runSerial(groups.flat(), line => this.driver.execute(line));
     }
     async dropTableIfExists(name, schema) {
@@ -349,6 +357,19 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
     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/typings.d.ts

@@ -1,4 +1,5 @@
-import type { DeferMode, CheckCallback, Dictionary, EntityProperty, GroupOperator, RawQueryFragment, QBFilterQuery, QueryOrderMap, Type, QueryFlag, AnyEntity, EntityName } from '@mikro-orm/core';
+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';
@@ -27,6 +28,7 @@ export interface JoinOptions {
     cond_?: Dictionary;
     subquery?: string;
     nested?: Set<JoinOptions>;
+    parent?: JoinOptions;
 }
 export interface Column {
     name: string;
@@ -74,7 +76,7 @@ export interface IndexDef {
         storageEngineIndexType?: 'hash' | 'btree';
         predicate?: string;
     }>;
-    deferMode?: DeferMode;
+    deferMode?: DeferMode | `${DeferMode}`;
 }
 export interface CheckDef<T = unknown> {
     name: string;
@@ -170,11 +172,14 @@ export interface ICriteriaNodeProcessOptions {
     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;
@@ -182,8 +187,85 @@ export interface ICriteriaNode<T extends object> {
     shouldInline(payload: any): boolean;
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
     shouldRename(payload: any): boolean;
-    renameFieldToPK<T>(qb: IQueryBuilder<T>): string;
+    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 = {}> = 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 = {}> = {
+    [K in keyof TMap as TransformName<K, 'underscore'>]: InferKyselyTable<TMap[K], 'underscore'>;
+};
+export type InferKyselyTable<TSchema extends EntitySchemaWithMeta, TNamingStrategy extends 'underscore' | 'entity' = 'underscore', TProcessOnCreate extends boolean = false> = ExcludeNever<{
+    -readonly [K in keyof InferEntityProperties<TSchema> as TransformColumnName<K, TNamingStrategy, MaybeReturnType<InferEntityProperties<TSchema>[K]>>]: InferColumnValue<MaybeReturnType<InferEntityProperties<TSchema>[K]>, TProcessOnCreate>;
+}>;
+type TransformName<TName, TNamingStrategy extends 'underscore' | 'entity'> = TNamingStrategy extends 'underscore' ? TName extends string ? SnakeCase<TName> : TName : TName;
+type TransformColumnName<TName, TNamingStrategy extends 'underscore' | 'entity', TBuilder> = TNamingStrategy extends 'entity' ? 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 {};