@lakutata/orm 0.0.0-stage → 3.0.0-beta.0

package/dist/cjs/providers/migration/GenerateMigration.js

@@ -0,0 +1,303 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var GenerateMigration_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateMigration = void 0;
+/*
+ * The generation of the migrations, rewritten from the command migration:generate of TypeORM (Copyright (c) 2015-2025
+ * TypeORM, MIT License, see THIRD_PARTY_NOTICES.md)
+ */
+const core_1 = require("@lakutata/core");
+const di_1 = require("@lakutata/core/decorator/di");
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const DataSource_js_1 = require("typeorm/data-source/DataSource.js");
+const sqlFormatter_js_1 = require("@sqltools/formatter/lib/sqlFormatter.js");
+const StringUtils_js_1 = require("typeorm/util/StringUtils.js");
+const PlatformTools_js_1 = require("typeorm/platform/PlatformTools.js");
+const CommandUtils_js_1 = require("typeorm/commands/CommandUtils.js");
+const ansis_1 = __importDefault(require("ansis"));
+let GenerateMigration = class GenerateMigration extends core_1.Provider {
+    static { GenerateMigration_1 = this; }
+    get extension() {
+        return this.outputJs ? '.js' : '.ts';
+    }
+    get filename() {
+        return this.timestamp + '-' + (this.dataSourceName ? this.dataSourceName : path_1.default.basename(this.path)) + this.extension;
+    }
+    #app;
+    #dataSource;
+    /**
+     * Initializer
+     * @protected
+     */
+    /**
+     * The migrations generated by the run (its databases share the process)
+     */
+    static { this.generated = 0; }
+    async init() {
+        this.#app = await this.getObject(core_1.Application);
+        this.#dataSource = new DataSource_js_1.DataSource(this.dataSource);
+        this.#dataSource.setOptions({
+            synchronize: false,
+            migrationsRun: false,
+            dropSchema: false,
+            logging: false
+        });
+        this.#dataSource = await this.#dataSource.initialize();
+        await this.handle();
+    }
+    /**
+     * Destroyer
+     * @protected
+     */
+    async destroy() {
+        //The data source is destroyed once the schema is read
+        if (this.#dataSource?.isInitialized)
+            await this.#dataSource.destroy();
+    }
+    async handle() {
+        try {
+            const upSqls = [], downSqls = [];
+            try {
+                const sqlInMemory = await this.#dataSource.driver
+                    .createSchemaBuilder()
+                    .log();
+                if (this.pretty) {
+                    sqlInMemory.upQueries.forEach((upQuery) => {
+                        upQuery.query = GenerateMigration_1.prettifyQuery(upQuery.query);
+                    });
+                    sqlInMemory.downQueries.forEach((downQuery) => {
+                        downQuery.query =
+                            GenerateMigration_1.prettifyQuery(downQuery.query);
+                    });
+                }
+                sqlInMemory.upQueries.forEach((upQuery) => {
+                    upSqls.push('        await queryRunner.query(`' +
+                        GenerateMigration_1.escapeTemplateLiteral(upQuery.query) +
+                        '`' +
+                        GenerateMigration_1.queryParams(upQuery.parameters) +
+                        ');');
+                });
+                sqlInMemory.downQueries.forEach((downQuery) => {
+                    downSqls.push('        await queryRunner.query(`' +
+                        GenerateMigration_1.escapeTemplateLiteral(downQuery.query) +
+                        '`' +
+                        GenerateMigration_1.queryParams(downQuery.parameters) +
+                        ');');
+                });
+            }
+            finally {
+                await this.#dataSource.destroy();
+            }
+            if (!upSqls.length) {
+                if (this.check) {
+                    console.log(ansis_1.default.green `No changes in database schema were found`);
+                    if (this.exitProcess) {
+                        return this.#app.exit(0);
+                    }
+                    else {
+                        return;
+                    }
+                }
+                else {
+                    console.log(ansis_1.default.yellow `No changes in database schema were found`);
+                    if (this.exitProcess) {
+                        //The code 1 when no database of the run had a change
+                        return this.#app.exit(GenerateMigration_1.generated ? 0 : 1);
+                    }
+                    else {
+                        return;
+                    }
+                }
+            }
+            else if (!this.path) {
+                console.log(ansis_1.default.yellow `Please specify a migration path`);
+                return this.#app.exit(1);
+            }
+            const fileContent = this.outputJs
+                ? GenerateMigration_1.getJavascriptTemplate(path_1.default.basename(this.path), this.timestamp, upSqls, downSqls.reverse(), this.esm)
+                : GenerateMigration_1.getTemplate(path_1.default.basename(this.path), this.timestamp, upSqls, downSqls.reverse());
+            if (this.check) {
+                console.log(ansis_1.default.yellow `Unexpected changes in database schema were found in check mode:\n\n${ansis_1.default.white(fileContent)}`);
+                //Changes found in check mode: the code 1, as the check of TypeORM
+                return this.#app.exit(1);
+            }
+            GenerateMigration_1.generated++;
+            if (this.dryRun) {
+                console.log(ansis_1.default.green(`Migration ${ansis_1.default.blue(this.path + this.extension)} has content:\n\n${ansis_1.default.white(fileContent)}`));
+                if (this.exitProcess)
+                    return this.#app.exit(0);
+            }
+            else {
+                const migrationFileName = path_1.default.isAbsolute(this.path) ? path_1.default.join(this.path, this.filename) : path_1.default.join(process.cwd(), this.path, this.filename);
+                await CommandUtils_js_1.CommandUtils.createFile(migrationFileName, fileContent);
+                console.log(ansis_1.default.green `Migration ${ansis_1.default.blue(migrationFileName)} has been generated successfully.`);
+                if (this.exitProcess) {
+                    return this.#app.exit(0);
+                }
+                else {
+                    return;
+                }
+            }
+        }
+        catch (err) {
+            PlatformTools_js_1.PlatformTools.logCmdErr('Error during migration generation:', err);
+            return this.#app.exit(1);
+        }
+    }
+    /**
+     * The module the migrations import their types from: @lakutata/orm when the project depends on it, otherwise
+     * lakutata/orm (the migrations of the projects depending on lakutata)
+     */
+    static migrationModule() {
+        try {
+            const pkg = JSON.parse((0, fs_1.readFileSync)(path_1.default.join(process.cwd(), 'package.json'), 'utf8'));
+            if (pkg.dependencies?.['@lakutata/orm'] || pkg.devDependencies?.['@lakutata/orm'])
+                return '@lakutata/orm';
+        }
+        catch {
+            //No package.json
+        }
+        return 'lakutata/orm';
+    }
+    /**
+     * Escape a query for a template literal of the migration: its backslashes, its backticks and its interpolations
+     * (the defaults and the comments of the columns are in the queries)
+     * @param query
+     */
+    static escapeTemplateLiteral(query) {
+        return query.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+    }
+    /**
+     * Formats query parameters for migration queries if parameters actually exist
+     */
+    static queryParams(parameters) {
+        if (!parameters || !parameters.length) {
+            return '';
+        }
+        return `, ${JSON.stringify(parameters)}`;
+    }
+    /**
+     * Gets contents of the migration file.
+     */
+    static getTemplate(name, timestamp, upSqls, downSqls) {
+        const migrationName = `${(0, StringUtils_js_1.camelCase)(name, true)}${timestamp}`;
+        return `import { MigrationInterface, QueryRunner } from "${GenerateMigration_1.migrationModule()}";
+
+export class ${migrationName} implements MigrationInterface {
+    name = '${migrationName}'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+${upSqls.join(`
+`)}
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+${downSqls.join(`
+`)}
+    }
+
+}
+`;
+    }
+    /**
+     * Gets contents of the migration file in Javascript.
+     */
+    static getJavascriptTemplate(name, timestamp, upSqls, downSqls, esm) {
+        const migrationName = `${(0, StringUtils_js_1.camelCase)(name, true)}${timestamp}`;
+        const exportMethod = esm ? 'export' : 'module.exports =';
+        const migrationModule = GenerateMigration_1.migrationModule();
+        return `/**
+ * @typedef {import('${migrationModule}').MigrationInterface} MigrationInterface
+ * @typedef {import('${migrationModule}').QueryRunner} QueryRunner
+ */
+
+/**
+ * @class
+ * @implements {MigrationInterface}
+ */
+${exportMethod} class ${migrationName} {
+    name = '${migrationName}'
+
+    /**
+     * @param {QueryRunner} queryRunner
+     */
+    async up(queryRunner) {
+${upSqls.join(`
+`)}
+    }
+
+    /**
+     * @param {QueryRunner} queryRunner
+     */
+    async down(queryRunner) {
+${downSqls.join(`
+`)}
+    }
+}
+`;
+    }
+    /**
+     *
+     */
+    static prettifyQuery(query) {
+        const formattedQuery = (0, sqlFormatter_js_1.format)(query, { indent: '    ' });
+        return ('\n' + formattedQuery.replace(/^/gm, '            ') + '\n        ');
+    }
+};
+exports.GenerateMigration = GenerateMigration;
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], GenerateMigration.prototype, "path", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.String().allow('').optional().default('')),
+    __metadata("design:type", String)
+], GenerateMigration.prototype, "dataSourceName", void 0);
+__decorate([
+    (0, di_1.Configurable)(),
+    __metadata("design:type", Object)
+], GenerateMigration.prototype, "dataSource", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], GenerateMigration.prototype, "pretty", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], GenerateMigration.prototype, "outputJs", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], GenerateMigration.prototype, "esm", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], GenerateMigration.prototype, "dryRun", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], GenerateMigration.prototype, "check", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Number().optional().default(() => Date.now())),
+    __metadata("design:type", Number)
+], GenerateMigration.prototype, "timestamp", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], GenerateMigration.prototype, "exitProcess", void 0);
+exports.GenerateMigration = GenerateMigration = GenerateMigration_1 = __decorate([
+    (0, di_1.Transient)()
+], GenerateMigration);

package/dist/cjs/types/MigrationRunOptions.d.ts

@@ -0,0 +1,19 @@
+/**
+ * How {@link Database.runMigrations} and {@link Database.undoLastMigration} run the migrations: in transactions or not,
+ * for real or only recorded.
+ */
+export type MigrationRunOptions = {
+    /**
+     * The transactions wrapping the migrations: `'all'` runs them all in one transaction (one failure rolls them all
+     * back), `'each'` runs each one in its own transaction (the ones before a failure stay applied), `'none'` runs them
+     * without a transaction. A migration may override it with its own `transaction` property.
+     * @default The `migrationsTransactionMode` of the connection options for `runMigrations()`, else `'all'`
+     */
+    transaction?: 'all' | 'none' | 'each';
+    /**
+     * Record the migrations as run (or remove them as reverted) in the migrations table without running their `up()`
+     * (or `down()`): for a database whose schema is already up to date.
+     * @default false
+     */
+    fake?: boolean;
+};

package/dist/cjs/types/MigrationRunOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/components/Database.js

@@ -0,0 +1,344 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Configurable, Singleton } from '@lakutata/core/decorator/di';
+import { Component } from '@lakutata/core';
+import { DataSource } from 'typeorm/data-source/DataSource.js';
+/**
+ * Build the registration of a {@link Database} component, for the `components` of the application options: the
+ * component class with its TypeORM connection options.
+ * @param options The TypeORM connection options (`DataSourceOptions`): the driver `type`, the connection settings, the
+ * `entities`, the `migrations`, `synchronize`, `migrationsRun`, `logging`… Passed to TypeORM as they are.
+ * @returns The registration `{class: Database, options}`.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildDatabaseOptions} from 'lakutata/com/database'
+ * import {Column, Entity, PrimaryGeneratedColumn} from 'lakutata/decorator/orm'
+ *
+ * @Entity()
+ * class User {
+ *     @PrimaryGeneratedColumn()
+ *     public id: number
+ *
+ *     @Column()
+ *     public name: string
+ * }
+ *
+ * Application.run(() => ({
+ *     id: 'com.example.app',
+ *     name: 'Example',
+ *     components: {
+ *         //A PostgreSQL connection (the pg package installed), the component named db
+ *         db: buildDatabaseOptions({
+ *             type: 'postgres',
+ *             host: 'localhost',
+ *             port: 5432,
+ *             username: 'postgres',
+ *             password: 'secret',
+ *             database: 'example',
+ *             entities: [User]
+ *         })
+ *     },
+ *     //Connected while the application launches: a connection failure stops it
+ *     bootstrap: ['db']
+ * }))
+ * ```
+ */
+export const buildDatabaseOptions = (options) => ({
+    class: Database,
+    options: options
+});
+/**
+ * A database connection shared by the whole application: a singleton component wrapping a TypeORM `DataSource`.
+ *
+ * Register it in the `components` of the application options with {@link buildDatabaseOptions}, then inject it by its
+ * name (`@Inject('db')`) or get it with `getObject('db')`. It connects when it is created (while the application
+ * launches when it is listed in `bootstrap`, otherwise on its first use): a connection failure rejects its creation
+ * with the driver error. TypeORM applies `synchronize` and `migrationsRun` of the options while connecting. It
+ * disconnects when the application stops.
+ *
+ * An application may register several of them (one per database), each under its own name. Their names are the ones
+ * the migration commands of the application (`MIGRATION_GENERATE`, `MIGRATION_RUN`…) select with `MIGRATION_DATABASE`.
+ * @example
+ * ```typescript
+ * import {Application, Component} from 'lakutata'
+ * import {Inject} from 'lakutata/decorator/di'
+ * import {buildDatabaseOptions, Database} from 'lakutata/com/database'
+ * import {Column, Entity, PrimaryGeneratedColumn} from 'lakutata/decorator/orm'
+ *
+ * @Entity()
+ * class Account {
+ *     @PrimaryGeneratedColumn()
+ *     public id: number
+ *
+ *     @Column('integer', {default: 0})
+ *     public balance: number
+ * }
+ *
+ * class Bank extends Component {
+ *     @Inject('db')
+ *     protected readonly db: Database
+ *
+ *     public async balance(id: number): Promise<number> {
+ *         const account: Account | null = await this.db.getRepository(Account).findOneBy({id: id})
+ *         return account ? account.balance : 0
+ *     }
+ *
+ *     //Both updates are committed, or none when one fails
+ *     public async transfer(from: number, to: number, amount: number): Promise<void> {
+ *         await this.db.transaction(async (manager): Promise<void> => {
+ *             await manager.decrement(Account, {id: from}, 'balance', amount)
+ *             await manager.increment(Account, {id: to}, 'balance', amount)
+ *         })
+ *     }
+ * }
+ *
+ * Application.run(() => ({
+ *     id: 'com.example.bank',
+ *     name: 'Bank',
+ *     components: {
+ *         db: buildDatabaseOptions({type: 'postgres', url: 'postgres://postgres:secret@localhost:5432/bank', entities: [Account]}),
+ *         bank: {class: Bank}
+ *     },
+ *     bootstrap: ['db']
+ * }))
+ * ```
+ */
+let Database = class Database extends Component {
+    /**
+     * Load the provider generating the migrations of the database. The application calls it when it is started with
+     * `MIGRATION_GENERATE`: the applications do not call it.
+     * @returns The migration generator provider class.
+     */
+    static { this.migrationGenerator = async () => (await import('../providers/migration/GenerateMigration.js')).GenerateMigration; }
+    /**
+     * Load the provider running, reverting or showing the migrations of the database. The application calls it when it
+     * is started with `MIGRATION_RUN`, `MIGRATION_REVERT` or `MIGRATION_SHOW`: the applications do not call it.
+     * @returns The migration executor provider class.
+     */
+    static { this.migrationExecutor = async () => (await import('../providers/migration/ExecuteMigration.js')).ExecuteMigration; }
+    #datasource;
+    /**
+     * The TypeORM `DataSource` of the connection, for the subclasses needing what this class does not expose.
+     */
+    get datasource() {
+        return this.#datasource;
+    }
+    /**
+     * The TypeORM driver of the connection (PostgreSQL, MySQL, SQLite…).
+     */
+    get driver() {
+        return this.datasource.driver;
+    }
+    /**
+     * The entity manager of the connection: the TypeORM operations on any entity (`find`, `save`, `delete`…) outside a
+     * transaction.
+     */
+    get manager() {
+        return this.datasource.manager;
+    }
+    /**
+     * Replace the naming strategy of the connection, which names the tables, the columns and the constraints of the
+     * entities. Set it before the metadata is used: the names already built are not renamed.
+     * @param instance The naming strategy.
+     */
+    set namingStrategy(instance) {
+        this.datasource.namingStrategy = instance;
+    }
+    /**
+     * The naming strategy of the connection, which names the tables, the columns and the constraints of the entities.
+     * @default TypeORM's `DefaultNamingStrategy`, unless the options set `namingStrategy`
+     */
+    get namingStrategy() {
+        return this.datasource.namingStrategy;
+    }
+    /**
+     * The entity subscribers registered on the connection (the `subscribers` of the options).
+     */
+    get subscribers() {
+        return this.datasource.subscribers;
+    }
+    /**
+     * The metadata of every entity registered on the connection.
+     */
+    get entityMetadatas() {
+        return this.datasource.entityMetadatas;
+    }
+    /**
+     * The metadata of every entity registered on the connection, by entity target (class, name or schema): the same as
+     * {@link Database.entityMetadatas}, for fast lookups.
+     */
+    get entityMetadatasMap() {
+        return this.datasource.entityMetadatasMap;
+    }
+    /**
+     * The query result cache of the connection, `undefined` unless the options enable `cache`.
+     */
+    get queryResultCache() {
+        return this.datasource.queryResultCache;
+    }
+    /**
+     * Connect to the database with the options.
+     * @protected
+     */
+    async init() {
+        this.#datasource = await (new DataSource(this.options)).initialize();
+    }
+    /**
+     * Disconnect from the database.
+     * @protected
+     */
+    async destroy() {
+        await this.datasource.destroy();
+    }
+    /**
+     * Create or update the database schema from the registered entities (the tables, columns, indices and foreign
+     * keys). Meant for development: the migrations change the schema of a production database.
+     * @param dropBeforeSync Drop every table of the database schema, with its data (also the tables of no entity),
+     * before creating the schema. Defaults to `false`.
+     * @returns Resolves once the schema is built.
+     * @throws {CannotExecuteNotConnectedError} When the connection is closed.
+     */
+    async synchronize(dropBeforeSync) {
+        return await this.datasource.synchronize(dropBeforeSync);
+    }
+    /**
+     * Run the pending migrations (the `migrations` of the options not yet recorded in the migrations table), in their
+     * timestamp order.
+     * @param options The transactions of the migrations, and whether they are only recorded (`fake`).
+     * @returns The migrations run, an empty array when none is pending.
+     * @throws {CannotExecuteNotConnectedError} When the connection is closed.
+     * @throws {Error} The error of a failed migration, once its transaction (`'all'` or `'each'`) is rolled back.
+     */
+    async runMigrations(options) {
+        return await this.datasource.runMigrations(options);
+    }
+    /**
+     * Revert the last migration run (its `down()`), and remove it from the migrations table. Does nothing when no
+     * migration was run.
+     * @param options The transaction of the migration (`'all'` by default, `migrationsTransactionMode` not applying),
+     * and whether it is only removed from the migrations table (`fake`).
+     * @returns Resolves once the migration is reverted.
+     * @throws {CannotExecuteNotConnectedError} When the connection is closed.
+     */
+    async undoLastMigration(options) {
+        return await this.datasource.undoLastMigration(options);
+    }
+    /**
+     * Log each migration of the options with whether it was run (`[X]`) or not (`[ ]`), through the logger of the
+     * connection (shown when its `logging` includes `schema`).
+     * @returns Whether a migration is pending.
+     */
+    async showMigrations() {
+        return await this.datasource.showMigrations();
+    }
+    /**
+     * Whether an entity is registered on the connection.
+     * @param target The entity class, its name, or its table name.
+     * @returns `true` when the connection has its metadata.
+     */
+    hasMetadata(target) {
+        return this.datasource.hasMetadata(target);
+    }
+    /**
+     * The metadata of a registered entity: its table, columns, relations…
+     * @param target The entity class, its name, or its table name.
+     * @returns The metadata of the entity.
+     * @throws {EntityMetadataNotFoundError} When the entity is not registered on the connection.
+     */
+    getMetadata(target) {
+        return this.datasource.getMetadata(target);
+    }
+    /**
+     * The repository of an entity, created once per entity: its `find`, `save`, `delete`… operations outside a
+     * transaction (in a transaction, use the entity manager given to the callback).
+     * @param target The entity class, its name, or its `EntitySchema`.
+     * @returns The repository of the entity (a `MongoRepository` on a MongoDB connection).
+     * @throws {EntityMetadataNotFoundError} From the repository operations, when the entity is not registered.
+     */
+    getRepository(target) {
+        return this.datasource.getRepository(target);
+    }
+    /**
+     * The tree repository of an entity decorated with `@Tree()`: the operations on its ancestors and descendants
+     * (`findTrees`, `findDescendants`…).
+     * @param target The tree entity class, or its name.
+     * @returns The tree repository of the entity.
+     * @throws {TreeRepositoryNotSupportedError} On a driver without tree support (MongoDB).
+     */
+    getTreeRepository(target) {
+        return this.datasource.getTreeRepository(target);
+    }
+    /**
+     * The MongoDB repository of an entity: the repository operations plus the MongoDB ones (`aggregate`, `bulkWrite`…).
+     * @param target The entity class, or its name.
+     * @returns The MongoDB repository of the entity.
+     * @throws {TypeORMError} When the connection is not a MongoDB one.
+     */
+    getMongoRepository(target) {
+        return this.datasource.getMongoRepository(target);
+    }
+    async transaction(inp1, inp2) {
+        return inp2 ? await this.datasource.transaction(inp1, inp2) : await this.datasource.transaction(inp1);
+    }
+    /**
+     * Run a raw SQL query.
+     * @param query The SQL, its parameters as placeholders: `$1`, `$2`… for PostgreSQL, `?` for MySQL and SQLite.
+     * @param parameters The values of the placeholders, escaped by the driver.
+     * @param queryRunner The query runner to run it on (a transaction of {@link Database.createQueryRunner}), a
+     * connection of the pool otherwise.
+     * @returns The raw result of the driver: the rows of a `SELECT` (an array of objects).
+     * @throws {QueryFailedError} When the database rejects the query.
+     */
+    async query(query, parameters, queryRunner) {
+        return await this.datasource.query(query, parameters, queryRunner);
+    }
+    createQueryBuilder(inp1, inp2, inp3) {
+        return arguments.length > 1 ? this.datasource.createQueryBuilder(inp1, inp2, inp3) : this.datasource.createQueryBuilder(inp1);
+    }
+    /**
+     * Create a query runner: one connection taken from the pool, to run several queries on the same connection and
+     * control its transaction by hand (`connect()`, `startTransaction()`, `commitTransaction()`,
+     * `rollbackTransaction()`). The caller must `release()` it, or the connection stays taken.
+     * @param mode With replication, `'master'` (the default) for the writes, `'slave'` for the reads on a replica.
+     * @returns The query runner, not connected until its first query or `connect()`.
+     */
+    createQueryRunner(mode) {
+        return this.datasource.createQueryRunner(mode);
+    }
+    /**
+     * The metadata of the junction table of a many-to-many relation.
+     * @param entityTarget The entity owning the relation.
+     * @param relationPropertyPath The property of the relation (`'tags'`, or a path such as `'profile.tags'`).
+     * @returns The metadata of the junction table.
+     * @throws {EntityMetadataNotFoundError} When the entity is not registered.
+     * @throws {TypeORMError} When the entity has no such relation, or the relation is not a many-to-many one.
+     */
+    getManyToManyMetadata(entityTarget, relationPropertyPath) {
+        return this.datasource.getManyToManyMetadata(entityTarget, relationPropertyPath);
+    }
+    /**
+     * Create an entity manager on the connection, bound to a query runner when given (its operations then run on the
+     * runner's connection and transaction).
+     * @param queryRunner The query runner the manager uses, a connection of the pool per operation otherwise.
+     * @returns The entity manager.
+     */
+    createEntityManager(queryRunner) {
+        return this.datasource.createEntityManager(queryRunner);
+    }
+};
+__decorate([
+    Configurable(),
+    __metadata("design:type", Object)
+], Database.prototype, "options", void 0);
+Database = __decorate([
+    Singleton()
+], Database);
+export { Database };

package/dist/esm/decorators/orm/AfterInsert.js

@@ -0,0 +1 @@
+export { AfterInsert } from 'typeorm/decorator/listeners/AfterInsert.js';

package/dist/esm/decorators/orm/AfterLoad.js

@@ -0,0 +1 @@
+export { AfterLoad } from 'typeorm/decorator/listeners/AfterLoad.js';

package/dist/esm/decorators/orm/AfterRecover.js

@@ -0,0 +1 @@
+export { AfterRecover } from 'typeorm/decorator/listeners/AfterRecover.js';

package/dist/esm/decorators/orm/AfterRemove.js

@@ -0,0 +1 @@
+export { AfterRemove } from 'typeorm/decorator/listeners/AfterRemove.js';

package/dist/esm/decorators/orm/AfterSoftRemove.js

@@ -0,0 +1 @@
+export { AfterSoftRemove } from 'typeorm/decorator/listeners/AfterSoftRemove.js';