@yandjin-mikro-orm/core 6.1.4-rc-sti-changes-1

package/unit-of-work/index.d.ts

@@ -0,0 +1,6 @@
+export * from './ChangeSet';
+export * from './ChangeSetComputer';
+export * from './ChangeSetPersister';
+export * from './CommitOrderCalculator';
+export * from './UnitOfWork';
+export * from './IdentityMap';

package/unit-of-work/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ChangeSet"), exports);
+__exportStar(require("./ChangeSetComputer"), exports);
+__exportStar(require("./ChangeSetPersister"), exports);
+__exportStar(require("./CommitOrderCalculator"), exports);
+__exportStar(require("./UnitOfWork"), exports);
+__exportStar(require("./IdentityMap"), exports);

package/utils/AbstractSchemaGenerator.d.ts

@@ -0,0 +1,38 @@
+import type { ClearDatabaseOptions, DropSchemaOptions, EntityMetadata, ISchemaGenerator, UpdateSchemaOptions, CreateSchemaOptions, RefreshDatabaseOptions, EnsureDatabaseOptions } from '../typings';
+import type { IDatabaseDriver } from '../drivers/IDatabaseDriver';
+import type { MetadataStorage } from '../metadata/MetadataStorage';
+import type { Configuration } from './Configuration';
+export declare abstract class AbstractSchemaGenerator<D extends IDatabaseDriver> implements ISchemaGenerator {
+    protected readonly em?: ReturnType<D['createEntityManager']>;
+    protected readonly driver: D;
+    protected readonly config: Configuration;
+    protected readonly metadata: MetadataStorage;
+    protected readonly platform: ReturnType<D['getPlatform']>;
+    protected readonly connection: ReturnType<D['getConnection']>;
+    constructor(em: D | ReturnType<D['createEntityManager']>);
+    createSchema(options?: CreateSchemaOptions): Promise<void>;
+    /**
+     * Returns true if the database was created.
+     */
+    ensureDatabase(options?: EnsureDatabaseOptions): Promise<boolean>;
+    refreshDatabase(options?: RefreshDatabaseOptions): Promise<void>;
+    clearDatabase(options?: ClearDatabaseOptions): Promise<void>;
+    getCreateSchemaSQL(options?: CreateSchemaOptions): Promise<string>;
+    dropSchema(options?: DropSchemaOptions): Promise<void>;
+    getDropSchemaSQL(options?: Omit<DropSchemaOptions, 'dropDb'>): Promise<string>;
+    updateSchema(options?: UpdateSchemaOptions): Promise<void>;
+    getUpdateSchemaSQL(options?: UpdateSchemaOptions): Promise<string>;
+    getUpdateSchemaMigrationSQL(options?: UpdateSchemaOptions): Promise<{
+        up: string;
+        down: string;
+    }>;
+    /**
+     * creates new database and connects to it
+     */
+    createDatabase(name: string): Promise<void>;
+    dropDatabase(name?: string): Promise<void>;
+    execute(query: string): Promise<void>;
+    ensureIndexes(): Promise<void>;
+    protected getOrderedMetadata(schema?: string): EntityMetadata[];
+    protected notImplemented(): never;
+}

package/utils/AbstractSchemaGenerator.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSchemaGenerator = void 0;
+const CommitOrderCalculator_1 = require("../unit-of-work/CommitOrderCalculator");
+const EntityManager_1 = require("../EntityManager");
+class AbstractSchemaGenerator {
+    em;
+    driver;
+    config;
+    metadata;
+    platform;
+    connection;
+    constructor(em) {
+        this.em = em instanceof EntityManager_1.EntityManager ? em : undefined;
+        this.driver = em instanceof EntityManager_1.EntityManager ? em.getDriver() : em;
+        this.config = this.driver.config;
+        this.metadata = this.driver.getMetadata();
+        this.platform = this.driver.getPlatform();
+        this.connection = this.driver.getConnection();
+    }
+    async createSchema(options) {
+        this.notImplemented();
+    }
+    /**
+     * Returns true if the database was created.
+     */
+    async ensureDatabase(options) {
+        this.notImplemented();
+    }
+    async refreshDatabase(options) {
+        await this.ensureDatabase();
+        await this.dropSchema();
+        await this.createSchema(options);
+    }
+    async clearDatabase(options) {
+        for (const meta of this.getOrderedMetadata(options?.schema).reverse()) {
+            await this.driver.nativeDelete(meta.className, {}, options);
+        }
+        if (this.em) {
+            const allowGlobalContext = this.config.get('allowGlobalContext');
+            this.config.set('allowGlobalContext', true);
+            this.em.clear();
+            this.config.set('allowGlobalContext', allowGlobalContext);
+        }
+    }
+    async getCreateSchemaSQL(options) {
+        this.notImplemented();
+    }
+    async dropSchema(options) {
+        this.notImplemented();
+    }
+    async getDropSchemaSQL(options) {
+        this.notImplemented();
+    }
+    async updateSchema(options) {
+        this.notImplemented();
+    }
+    async getUpdateSchemaSQL(options) {
+        this.notImplemented();
+    }
+    async getUpdateSchemaMigrationSQL(options) {
+        this.notImplemented();
+    }
+    /**
+     * creates new database and connects to it
+     */
+    async createDatabase(name) {
+        this.notImplemented();
+    }
+    async dropDatabase(name) {
+        this.notImplemented();
+    }
+    async execute(query) {
+        this.notImplemented();
+    }
+    async ensureIndexes() {
+        this.notImplemented();
+    }
+    getOrderedMetadata(schema) {
+        const metadata = Object.values(this.metadata.getAll()).filter(meta => {
+            const isRootEntity = meta.root.className === meta.className;
+            return isRootEntity && !meta.embeddable && !meta.virtual;
+        }).map(meta => meta.getStiRoot());
+        const calc = new CommitOrderCalculator_1.CommitOrderCalculator();
+        metadata.forEach(meta => calc.addNode(meta.root.className));
+        let meta = metadata.pop();
+        while (meta) {
+            for (const prop of meta.props) {
+                calc.discoverProperty(prop, meta.root.className);
+            }
+            meta = metadata.pop();
+        }
+        return calc.sort()
+            .map(cls => this.metadata.find(cls))
+            .filter(meta => schema ? [schema, '*'].includes(meta.schema) : meta.schema !== '*');
+    }
+    notImplemented() {
+        throw new Error(`This method is not supported by ${this.driver.constructor.name} driver`);
+    }
+}
+exports.AbstractSchemaGenerator = AbstractSchemaGenerator;

package/utils/Configuration.d.ts

@@ -0,0 +1,390 @@
+import type { NamingStrategy } from '../naming-strategy';
+import { FileCacheAdapter, type SyncCacheAdapter, type CacheAdapter } from '../cache';
+import type { EntityRepository } from '../entity/EntityRepository';
+import type { AnyEntity, Constructor, Dictionary, EntityClass, EntityClassGroup, FilterDef, Highlighter, HydratorConstructor, IHydrator, IMigrationGenerator, IPrimaryKey, MaybePromise, MigrationObject, EntityMetadata, EnsureDatabaseOptions, GenerateOptions } from '../typings';
+import { ObjectHydrator } from '../hydration';
+import { NullHighlighter } from '../utils/NullHighlighter';
+import { type Logger, type LoggerNamespace, type LoggerOptions } from '../logging';
+import type { EntityManager } from '../EntityManager';
+import type { Platform } from '../platforms';
+import type { EntitySchema } from '../metadata/EntitySchema';
+import type { MetadataProvider } from '../metadata/MetadataProvider';
+import type { MetadataStorage } from '../metadata/MetadataStorage';
+import { ReflectMetadataProvider } from '../metadata/ReflectMetadataProvider';
+import type { EventSubscriber } from '../events';
+import type { EntityManagerType, IDatabaseDriver } from '../drivers/IDatabaseDriver';
+import { NotFoundError } from '../errors';
+import { DataloaderType, FlushMode, LoadStrategy, PopulateHint } from '../enums';
+import { MemoryCacheAdapter } from '../cache/MemoryCacheAdapter';
+import { EntityComparator } from './EntityComparator';
+import type { Type } from '../types/Type';
+import type { MikroORM } from '../MikroORM';
+export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager> {
+    static readonly DEFAULTS: {
+        pool: {};
+        entities: never[];
+        entitiesTs: never[];
+        extensions: never[];
+        subscribers: never[];
+        filters: {};
+        discovery: {
+            warnWhenNoEntities: true;
+            requireEntitiesArray: false;
+            checkDuplicateTableNames: true;
+            checkDuplicateFieldNames: true;
+            alwaysAnalyseProperties: true;
+            disableDynamicFileAccess: false;
+            checkDuplicateEntities: true;
+            inferDefaultValues: true;
+        };
+        strict: false;
+        validate: false;
+        validateRequired: true;
+        context: (name: string) => EntityManager<IDatabaseDriver<import("..").Connection>> | undefined;
+        contextName: string;
+        allowGlobalContext: false;
+        logger: (message?: any, ...optionalParams: any[]) => void;
+        colors: true;
+        findOneOrFailHandler: (entityName: string, where: Dictionary | IPrimaryKey) => NotFoundError<Partial<any>>;
+        findExactlyOneOrFailHandler: (entityName: string, where: Dictionary | IPrimaryKey) => NotFoundError<Partial<any>>;
+        baseDir: string;
+        hydrator: typeof ObjectHydrator;
+        flushMode: FlushMode.AUTO;
+        loadStrategy: LoadStrategy.JOINED;
+        dataloader: DataloaderType.NONE;
+        populateWhere: PopulateHint.ALL;
+        connect: true;
+        ignoreUndefinedInQuery: false;
+        autoJoinOneToOneOwner: true;
+        autoJoinRefsForFilters: true;
+        propagationOnPrototype: true;
+        populateAfterFlush: true;
+        serialization: {
+            includePrimaryKeys: true;
+        };
+        persistOnCreate: true;
+        forceEntityConstructor: false;
+        forceUndefined: false;
+        forceUtcTimezone: false;
+        ensureDatabase: true;
+        ensureIndexes: false;
+        batchSize: number;
+        debug: false;
+        verbose: false;
+        driverOptions: {};
+        migrations: {
+            tableName: string;
+            path: string;
+            glob: string;
+            silent: false;
+            transactional: true;
+            disableForeignKeys: true;
+            allOrNothing: true;
+            dropTables: true;
+            safe: false;
+            snapshot: true;
+            emit: "ts";
+            fileName: (timestamp: string, name?: string) => string;
+        };
+        schemaGenerator: {
+            disableForeignKeys: true;
+            createForeignKeyConstraints: true;
+            ignoreSchema: never[];
+        };
+        entityGenerator: {
+            bidirectionalRelations: false;
+            identifiedReferences: false;
+            scalarTypeInDecorator: false;
+            scalarPropertiesForRelations: "never";
+            fileName: (className: string) => string;
+            onlyPurePivotTables: false;
+            readOnlyPivotTables: false;
+            useCoreBaseEntity: false;
+        };
+        metadataCache: {
+            pretty: false;
+            adapter: typeof FileCacheAdapter;
+            options: {
+                cacheDir: string;
+            };
+        };
+        resultCache: {
+            adapter: typeof MemoryCacheAdapter;
+            expiration: number;
+            options: {};
+        };
+        metadataProvider: typeof ReflectMetadataProvider;
+        highlighter: NullHighlighter;
+        seeder: {
+            path: string;
+            defaultSeeder: string;
+            glob: string;
+            emit: "ts";
+            fileName: (className: string) => string;
+        };
+        preferReadReplicas: true;
+        dynamicImportProvider: (id: string) => Promise<any>;
+    };
+    private readonly options;
+    private readonly logger;
+    private readonly driver;
+    private readonly platform;
+    private readonly cache;
+    private readonly extensions;
+    constructor(options: Options, validate?: boolean);
+    /**
+     * Gets specific configuration option. Falls back to specified `defaultValue` if provided.
+     */
+    get<T extends keyof MikroORMOptions<D, EM>, U extends MikroORMOptions<D, EM>[T]>(key: T, defaultValue?: U): U;
+    getAll(): MikroORMOptions<D, EM>;
+    /**
+     * Overrides specified configuration value.
+     */
+    set<T extends keyof MikroORMOptions<D, EM>, U extends MikroORMOptions<D, EM>[T]>(key: T, value: U): void;
+    /**
+     * Resets the configuration to its default value
+     */
+    reset<T extends keyof MikroORMOptions<D, EM>>(key: T): void;
+    /**
+     * Gets Logger instance.
+     */
+    getLogger(): Logger;
+    /**
+     * Gets current client URL (connection string).
+     */
+    getClientUrl(hidePassword?: boolean): string;
+    /**
+     * Gets current database driver instance.
+     */
+    getDriver(): D;
+    registerExtension(name: string, cb: () => unknown): void;
+    getExtension<T>(name: string): T | undefined;
+    /**
+     * Gets instance of NamingStrategy. (cached)
+     */
+    getNamingStrategy(): NamingStrategy;
+    /**
+     * Gets instance of Hydrator. (cached)
+     */
+    getHydrator(metadata: MetadataStorage): IHydrator;
+    /**
+     * Gets instance of Comparator. (cached)
+     */
+    getComparator(metadata: MetadataStorage): EntityComparator;
+    /**
+     * Gets instance of MetadataProvider. (cached)
+     */
+    getMetadataProvider(): MetadataProvider;
+    /**
+     * Gets instance of metadata CacheAdapter. (cached)
+     */
+    getMetadataCacheAdapter(): SyncCacheAdapter;
+    /**
+     * Gets instance of CacheAdapter for result cache. (cached)
+     */
+    getResultCacheAdapter(): CacheAdapter;
+    /**
+     * Gets EntityRepository class to be instantiated.
+     */
+    getRepositoryClass(repository: () => EntityClass<EntityRepository<AnyEntity>>): MikroORMOptions<D, EM>['entityRepository'];
+    /**
+     * Creates instance of given service and caches it.
+     */
+    getCachedService<T extends {
+        new (...args: any[]): InstanceType<T>;
+    }>(cls: T, ...args: ConstructorParameters<T>): InstanceType<T>;
+    resetServiceCache(): void;
+    private init;
+    private sync;
+    /**
+     * Checks if `src` folder exists, it so, tries to adjust the migrations and seeders paths automatically to use it.
+     * If there is a `dist` or `build` folder, it will be used for the JS variant (`path` option), while the `src` folder will be
+     * used for the TS variant (`pathTs` option).
+     *
+     * If the default folder exists (e.g. `/migrations`), the config will respect that, so this auto-detection should not
+     * break existing projects, only help with the new ones.
+     */
+    private detectSourceFolder;
+    private validateOptions;
+}
+/**
+ * Type helper to make it easier to use `mikro-orm.config.js`.
+ */
+export declare function defineConfig<D extends IDatabaseDriver>(options: Options<D>): Options<D, D[typeof EntityManagerType] & EntityManager<IDatabaseDriver<import("..").Connection>>>;
+export interface DynamicPassword {
+    password: string;
+    expirationChecker?: () => boolean;
+}
+export interface ConnectionOptions {
+    dbName?: string;
+    schema?: string;
+    name?: string;
+    clientUrl?: string;
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string | (() => MaybePromise<string> | MaybePromise<DynamicPassword>);
+    charset?: string;
+    collate?: string;
+    multipleStatements?: boolean;
+    pool?: PoolConfig;
+}
+export type MigrationsOptions = {
+    tableName?: string;
+    path?: string;
+    pathTs?: string;
+    glob?: string;
+    silent?: boolean;
+    transactional?: boolean;
+    disableForeignKeys?: boolean;
+    allOrNothing?: boolean;
+    dropTables?: boolean;
+    safe?: boolean;
+    snapshot?: boolean;
+    snapshotName?: string;
+    emit?: 'js' | 'ts' | 'cjs';
+    generator?: Constructor<IMigrationGenerator>;
+    fileName?: (timestamp: string, name?: string) => string;
+    migrationsList?: MigrationObject[];
+};
+export interface SeederOptions {
+    path?: string;
+    pathTs?: string;
+    glob?: string;
+    defaultSeeder?: string;
+    emit?: 'js' | 'ts';
+    fileName?: (className: string) => string;
+}
+export interface PoolConfig {
+    name?: string;
+    afterCreate?: (...a: unknown[]) => unknown;
+    min?: number;
+    max?: number;
+    refreshIdle?: boolean;
+    idleTimeoutMillis?: number;
+    reapIntervalMillis?: number;
+    returnToHead?: boolean;
+    priorityRange?: number;
+    log?: (message: string, logLevel: string) => void;
+    maxWaitingClients?: number;
+    testOnBorrow?: boolean;
+    acquireTimeoutMillis?: number;
+    fifo?: boolean;
+    autostart?: boolean;
+    evictionRunIntervalMillis?: number;
+    numTestsPerRun?: number;
+    softIdleTimeoutMillis?: number;
+    Promise?: any;
+}
+export interface MetadataDiscoveryOptions {
+    warnWhenNoEntities?: boolean;
+    requireEntitiesArray?: boolean;
+    checkDuplicateTableNames?: boolean;
+    checkDuplicateFieldNames?: boolean;
+    alwaysAnalyseProperties?: boolean;
+    disableDynamicFileAccess?: boolean;
+    inferDefaultValues?: boolean;
+    getMappedType?: (type: string, platform: Platform) => Type<unknown> | undefined;
+    checkDuplicateEntities?: boolean;
+    onMetadata?: (meta: EntityMetadata, platform: Platform) => MaybePromise<void>;
+    afterDiscovered?: (storage: MetadataStorage, platform: Platform) => MaybePromise<void>;
+}
+export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = EntityManager> extends ConnectionOptions {
+    entities: (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[];
+    entitiesTs: (string | EntityClass<AnyEntity> | EntityClassGroup<AnyEntity> | EntitySchema)[];
+    extensions: {
+        register: (orm: MikroORM) => void;
+    }[];
+    subscribers: (EventSubscriber | Constructor<EventSubscriber>)[];
+    filters: Dictionary<{
+        name?: string;
+    } & Omit<FilterDef, 'name'>>;
+    discovery: MetadataDiscoveryOptions;
+    driver?: {
+        new (config: Configuration): D;
+    };
+    driverOptions: Dictionary;
+    namingStrategy?: {
+        new (): NamingStrategy;
+    };
+    implicitTransactions?: boolean;
+    disableTransactions?: boolean;
+    connect: boolean;
+    verbose: boolean;
+    ignoreUndefinedInQuery?: boolean;
+    autoJoinOneToOneOwner: boolean;
+    autoJoinRefsForFilters: boolean;
+    propagationOnPrototype: boolean;
+    populateAfterFlush: boolean;
+    serialization: {
+        includePrimaryKeys?: boolean;
+        /** Enforce unpopulated references to be returned as objects, e.g. `{ author: { id: 1 } }` instead of `{ author: 1 }`. */
+        forceObject?: boolean;
+    };
+    persistOnCreate: boolean;
+    forceEntityConstructor: boolean | (Constructor<AnyEntity> | string)[];
+    forceUndefined: boolean;
+    forceUtcTimezone: boolean;
+    timezone?: string;
+    ensureDatabase: boolean | EnsureDatabaseOptions;
+    ensureIndexes: boolean;
+    useBatchInserts?: boolean;
+    useBatchUpdates?: boolean;
+    batchSize: number;
+    hydrator: HydratorConstructor;
+    loadStrategy: LoadStrategy | 'select-in' | 'joined';
+    dataloader: DataloaderType | boolean;
+    populateWhere: PopulateHint;
+    flushMode: FlushMode | 'commit' | 'auto' | 'always';
+    entityRepository?: EntityClass<EntityRepository<any>>;
+    entityManager?: Constructor<EM>;
+    replicas?: Partial<ConnectionOptions>[];
+    strict: boolean;
+    validate: boolean;
+    validateRequired: boolean;
+    context: (name: string) => EntityManager | undefined;
+    contextName: string;
+    allowGlobalContext: boolean;
+    disableIdentityMap?: boolean;
+    logger: (message: string) => void;
+    colors?: boolean;
+    loggerFactory?: (options: LoggerOptions) => Logger;
+    findOneOrFailHandler: (entityName: string, where: Dictionary | IPrimaryKey) => Error;
+    findExactlyOneOrFailHandler: (entityName: string, where: Dictionary | IPrimaryKey) => Error;
+    debug: boolean | LoggerNamespace[];
+    highlighter: Highlighter;
+    tsNode?: boolean;
+    baseDir: string;
+    migrations: MigrationsOptions;
+    schemaGenerator: {
+        disableForeignKeys?: boolean;
+        createForeignKeyConstraints?: boolean;
+        ignoreSchema?: string[];
+        managementDbName?: string;
+    };
+    entityGenerator: GenerateOptions;
+    metadataCache: {
+        enabled?: boolean;
+        combined?: boolean | string;
+        pretty?: boolean;
+        adapter?: {
+            new (...params: any[]): SyncCacheAdapter;
+        };
+        options?: Dictionary;
+    };
+    resultCache: {
+        expiration?: number;
+        adapter?: {
+            new (...params: any[]): CacheAdapter;
+        };
+        options?: Dictionary;
+        global?: boolean | number | [string, number];
+    };
+    metadataProvider: {
+        new (config: Configuration): MetadataProvider;
+    };
+    seeder: SeederOptions;
+    preferReadReplicas: boolean;
+    dynamicImportProvider: (id: string) => Promise<unknown>;
+}
+export type Options<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager = D[typeof EntityManagerType] & EntityManager> = Pick<MikroORMOptions<D, EM>, Exclude<keyof MikroORMOptions<D, EM>, keyof typeof Configuration.DEFAULTS>> & Partial<MikroORMOptions<D, EM>>;