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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Martin Adámek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/MikroORM.d.ts

@@ -0,0 +1,102 @@
+import type { EntityManagerType, IDatabaseDriver } from './drivers';
+import { MetadataStorage } from './metadata';
+import { Configuration, type Options } from './utils';
+import type { EntityManager } from './EntityManager';
+import type { Constructor, EntityMetadata, EntityName, IEntityGenerator, IMigrator, ISeedManager } from './typings';
+/**
+ * Helper class for bootstrapping the MikroORM.
+ */
+export declare class MikroORM<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager> {
+    /** The global EntityManager instance. If you are using `RequestContext` helper, it will automatically pick the request specific context under the hood */
+    em: EM;
+    readonly config: Configuration<D>;
+    private metadata;
+    private readonly driver;
+    private readonly logger;
+    private readonly discovery;
+    /**
+     * Initialize the ORM, load entity metadata, create EntityManager and connect to the database.
+     * If you omit the `options` parameter, your CLI config will be used.
+     */
+    static init<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options?: Options<D, EM>): Promise<MikroORM<D, EM>>;
+    /**
+     * Synchronous variant of the `init` method with some limitations:
+     * - database connection will be established when you first interact with the database (or you can use `orm.connect()` explicitly)
+     * - no loading of the `config` file, `options` parameter is mandatory
+     * - no support for folder based discovery
+     * - no check for mismatched package versions
+     */
+    static initSync<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options: Options<D, EM>): MikroORM<D, EM>;
+    constructor(options: Options<D, EM> | Configuration<D, EM>);
+    /**
+     * Connects to the database.
+     */
+    connect(): Promise<D>;
+    /**
+     * Reconnects, possibly to a different database.
+     */
+    reconnect(options?: Options): Promise<void>;
+    /**
+     * Checks whether the database connection is active.
+     */
+    isConnected(): Promise<boolean>;
+    /**
+     * Checks whether the database connection is active, returns .
+     */
+    checkConnection(): Promise<{
+        ok: boolean;
+        reason?: string;
+        error?: Error;
+    }>;
+    /**
+     * Closes the database connection.
+     */
+    close(force?: boolean): Promise<void>;
+    /**
+     * Gets the `MetadataStorage`.
+     */
+    getMetadata(): MetadataStorage;
+    /**
+     * Gets the `EntityMetadata` instance when provided with the `entityName` parameter.
+     */
+    getMetadata<Entity extends object>(entityName: EntityName<Entity>): EntityMetadata<Entity>;
+    discoverEntities(): Promise<void>;
+    discoverEntitiesSync(): void;
+    private createEntityManager;
+    /**
+     * Allows dynamically discovering new entity by reference, handy for testing schema diffing.
+     */
+    discoverEntity(entities: Constructor | Constructor[]): void;
+    /**
+     * Gets the SchemaGenerator.
+     */
+    getSchemaGenerator(): ReturnType<ReturnType<D['getPlatform']>['getSchemaGenerator']>;
+    /**
+     * Gets the EntityGenerator.
+     */
+    getEntityGenerator<T extends IEntityGenerator = IEntityGenerator>(): T;
+    /**
+     * Gets the Migrator.
+     */
+    getMigrator<T extends IMigrator = IMigrator>(): T;
+    /**
+     * Gets the SeedManager
+     */
+    getSeeder<T extends ISeedManager = ISeedManager>(): T;
+    /**
+     * Shortcut for `orm.getSchemaGenerator()`
+     */
+    get schema(): ReturnType<ReturnType<D["getPlatform"]>["getSchemaGenerator"]>;
+    /**
+     * Shortcut for `orm.getSeeder()`
+     */
+    get seeder(): ISeedManager;
+    /**
+     * Shortcut for `orm.getMigrator()`
+     */
+    get migrator(): IMigrator;
+    /**
+     * Shortcut for `orm.getEntityGenerator()`
+     */
+    get entityGenerator(): IEntityGenerator;
+}

package/MikroORM.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MikroORM = void 0;
+const metadata_1 = require("./metadata");
+const utils_1 = require("./utils");
+const logging_1 = require("./logging");
+const cache_1 = require("./cache");
+/**
+ * Helper class for bootstrapping the MikroORM.
+ */
+class MikroORM {
+    /** The global EntityManager instance. If you are using `RequestContext` helper, it will automatically pick the request specific context under the hood */
+    em;
+    config;
+    metadata;
+    driver;
+    logger;
+    discovery;
+    /**
+     * Initialize the ORM, load entity metadata, create EntityManager and connect to the database.
+     * If you omit the `options` parameter, your CLI config will be used.
+     */
+    static async init(options) {
+        utils_1.ConfigurationLoader.registerDotenv(options);
+        const coreVersion = await utils_1.ConfigurationLoader.checkPackageVersion();
+        const env = utils_1.ConfigurationLoader.loadEnvironmentVars();
+        if (!options) {
+            options = (await utils_1.ConfigurationLoader.getConfiguration()).getAll();
+        }
+        options = utils_1.Utils.mergeConfig(options, env);
+        await utils_1.ConfigurationLoader.commonJSCompat(options);
+        if ('DRIVER' in this && !options.driver) {
+            options.driver = this.DRIVER;
+        }
+        const orm = new MikroORM(options);
+        orm.logger.log('info', `MikroORM version: ${logging_1.colors.green(coreVersion)}`);
+        // we need to allow global context here as we are not in a scope of requests yet
+        const allowGlobalContext = orm.config.get('allowGlobalContext');
+        orm.config.set('allowGlobalContext', true);
+        await orm.discoverEntities();
+        orm.config.set('allowGlobalContext', allowGlobalContext);
+        orm.driver.getPlatform().lookupExtensions(orm);
+        if (orm.config.get('connect')) {
+            await orm.connect();
+        }
+        for (const extension of orm.config.get('extensions')) {
+            extension.register(orm);
+        }
+        if (orm.config.get('connect') && orm.config.get('ensureIndexes')) {
+            await orm.getSchemaGenerator().ensureIndexes();
+        }
+        return orm;
+    }
+    /**
+     * Synchronous variant of the `init` method with some limitations:
+     * - database connection will be established when you first interact with the database (or you can use `orm.connect()` explicitly)
+     * - no loading of the `config` file, `options` parameter is mandatory
+     * - no support for folder based discovery
+     * - no check for mismatched package versions
+     */
+    static initSync(options) {
+        utils_1.ConfigurationLoader.registerDotenv(options);
+        const env = utils_1.ConfigurationLoader.loadEnvironmentVars();
+        options = utils_1.Utils.merge(options, env);
+        if ('DRIVER' in this && !options.driver) {
+            options.driver = this.DRIVER;
+        }
+        const orm = new MikroORM(options);
+        // we need to allow global context here as we are not in a scope of requests yet
+        const allowGlobalContext = orm.config.get('allowGlobalContext');
+        orm.config.set('allowGlobalContext', true);
+        orm.discoverEntitiesSync();
+        orm.config.set('allowGlobalContext', allowGlobalContext);
+        orm.driver.getPlatform().lookupExtensions(orm);
+        for (const extension of orm.config.get('extensions')) {
+            extension.register(orm);
+        }
+        return orm;
+    }
+    constructor(options) {
+        if (options instanceof utils_1.Configuration) {
+            this.config = options;
+        }
+        else {
+            this.config = new utils_1.Configuration(options);
+        }
+        const discovery = this.config.get('discovery');
+        if (discovery.disableDynamicFileAccess) {
+            this.config.set('metadataProvider', metadata_1.ReflectMetadataProvider);
+            this.config.set('metadataCache', { adapter: cache_1.NullCacheAdapter });
+            discovery.requireEntitiesArray = true;
+        }
+        this.driver = this.config.getDriver();
+        this.logger = this.config.getLogger();
+        this.discovery = new metadata_1.MetadataDiscovery(new metadata_1.MetadataStorage(), this.driver.getPlatform(), this.config);
+    }
+    /**
+     * Connects to the database.
+     */
+    async connect() {
+        const connection = await this.driver.connect();
+        const clientUrl = connection.getClientUrl();
+        const dbName = this.config.get('dbName');
+        const db = dbName + (clientUrl ? ' on ' + clientUrl : '');
+        if (this.config.get('ensureDatabase')) {
+            const options = this.config.get('ensureDatabase');
+            await this.schema.ensureDatabase(typeof options === 'boolean' ? {} : { ...options, forceCheck: true });
+        }
+        if (await this.isConnected()) {
+            this.logger.log('info', `MikroORM successfully connected to database ${logging_1.colors.green(db)}`);
+        }
+        else {
+            this.logger.error('info', `MikroORM failed to connect to database ${db}`);
+        }
+        return this.driver;
+    }
+    /**
+     * Reconnects, possibly to a different database.
+     */
+    async reconnect(options = {}) {
+        /* istanbul ignore next */
+        for (const key of utils_1.Utils.keys(options)) {
+            this.config.set(key, options[key]);
+        }
+        await this.driver.reconnect();
+    }
+    /**
+     * Checks whether the database connection is active.
+     */
+    async isConnected() {
+        return this.driver.getConnection().isConnected();
+    }
+    /**
+     * Checks whether the database connection is active, returns .
+     */
+    async checkConnection() {
+        return this.driver.getConnection().checkConnection();
+    }
+    /**
+     * Closes the database connection.
+     */
+    async close(force = false) {
+        if (await this.isConnected()) {
+            await this.driver.close(force);
+        }
+        if (this.config.getMetadataCacheAdapter()?.close) {
+            await this.config.getMetadataCacheAdapter().close();
+        }
+        if (this.config.getResultCacheAdapter()?.close) {
+            await this.config.getResultCacheAdapter().close();
+        }
+    }
+    /**
+     * Gets the `MetadataStorage` (without parameters) or `EntityMetadata` instance when provided with the `entityName` parameter.
+     */
+    getMetadata(entityName) {
+        if (entityName) {
+            entityName = utils_1.Utils.className(entityName);
+            return this.metadata.get(entityName);
+        }
+        return this.metadata;
+    }
+    async discoverEntities() {
+        this.metadata = await this.discovery.discover(this.config.get('tsNode'));
+        this.createEntityManager();
+    }
+    discoverEntitiesSync() {
+        this.metadata = this.discovery.discoverSync(this.config.get('tsNode'));
+        this.createEntityManager();
+    }
+    createEntityManager() {
+        this.driver.setMetadata(this.metadata);
+        this.em = this.driver.createEntityManager();
+        this.em.global = true;
+        this.metadata.decorate(this.em);
+        this.driver.setMetadata(this.metadata);
+    }
+    /**
+     * Allows dynamically discovering new entity by reference, handy for testing schema diffing.
+     */
+    discoverEntity(entities) {
+        entities = utils_1.Utils.asArray(entities);
+        const tmp = this.discovery.discoverReferences(entities);
+        const options = this.config.get('discovery');
+        new metadata_1.MetadataValidator().validateDiscovered([...Object.values(this.metadata.getAll()), ...tmp], options);
+        const metadata = this.discovery.processDiscoveredEntities(tmp);
+        metadata.forEach(meta => this.metadata.set(meta.className, meta));
+        this.metadata.decorate(this.em);
+    }
+    /**
+     * Gets the SchemaGenerator.
+     */
+    getSchemaGenerator() {
+        const extension = this.config.getExtension('@mikro-orm/schema-generator');
+        if (extension) {
+            return extension;
+        }
+        /* istanbul ignore next */
+        throw new Error(`SchemaGenerator extension not registered.`);
+    }
+    /**
+     * Gets the EntityGenerator.
+     */
+    getEntityGenerator() {
+        const extension = this.config.getExtension('@mikro-orm/entity-generator');
+        if (extension) {
+            return extension;
+        }
+        throw new Error(`EntityGenerator extension not registered.`);
+    }
+    /**
+     * Gets the Migrator.
+     */
+    getMigrator() {
+        const extension = this.config.getExtension('@mikro-orm/migrator');
+        if (extension) {
+            return extension;
+        }
+        /* istanbul ignore next */
+        throw new Error(`Migrator extension not registered.`);
+    }
+    /**
+     * Gets the SeedManager
+     */
+    getSeeder() {
+        const extension = this.config.getExtension('@mikro-orm/seeder');
+        if (extension) {
+            return extension;
+        }
+        /* istanbul ignore next */
+        throw new Error(`SeedManager extension not registered.`);
+    }
+    /**
+     * Shortcut for `orm.getSchemaGenerator()`
+     */
+    get schema() {
+        return this.getSchemaGenerator();
+    }
+    /**
+     * Shortcut for `orm.getSeeder()`
+     */
+    get seeder() {
+        return this.getSeeder();
+    }
+    /**
+     * Shortcut for `orm.getMigrator()`
+     */
+    get migrator() {
+        return this.getMigrator();
+    }
+    /**
+     * Shortcut for `orm.getEntityGenerator()`
+     */
+    get entityGenerator() {
+        return this.getEntityGenerator();
+    }
+}
+exports.MikroORM = MikroORM;