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

package/dist/cjs/providers/Database.js

@@ -0,0 +1,376 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Database = exports.buildDatabaseOptions = void 0;
+const di_1 = require("@lakutata/core/decorator/di");
+const DataSource_js_1 = require("typeorm/data-source/DataSource.js");
+const core_1 = require("@lakutata/core");
+const utils_1 = require("@lakutata/utils");
+/**
+ * Build the registration of a {@link Database} provider, for the `providers` of the application options: the provider
+ * class with its TypeORM connection options. Its `entities` option, added to the entities of the connection options,
+ * is set by spreading the registration: `{...buildDatabaseOptions(options), entities: [User]}`.
+ * @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/provider/database'
+ * import {Column, Entity, PrimaryGeneratedColumn} from 'lakutata/decorator/orm'
+ *
+ * @Entity()
+ * class Report {
+ *     @PrimaryGeneratedColumn()
+ *     public id: number
+ *
+ *     @Column('text')
+ *     public content: string
+ * }
+ *
+ * Application.run(() => ({
+ *     id: 'com.example.reports',
+ *     name: 'Reports',
+ *     providers: {
+ *         //A new PostgreSQL connection each time reports is resolved, closed with its owner
+ *         reports: {
+ *             ...buildDatabaseOptions({type: 'postgres', url: 'postgres://postgres:secret@localhost:5432/reports'}),
+ *             entities: [Report]
+ *         }
+ *     }
+ * }))
+ * ```
+ */
+const buildDatabaseOptions = (options) => ({
+    class: Database,
+    options: options
+});
+exports.buildDatabaseOptions = buildDatabaseOptions;
+/**
+ * A database connection of its own: a transient provider wrapping a TypeORM `DataSource`, with the API of the
+ * `Database` component of `lakutata/com/database`.
+ *
+ * Register it in the `providers` of the application options with {@link buildDatabaseOptions}. Each resolution
+ * (`@Inject('reports')`, `getObject('reports')`) creates a new instance, even within one scope: it opens its own
+ * connection (its own pool) while it is created, and closes it when it is destroyed with the object or the container
+ * which created it. It suits a short use (a job, a script, a tenant database); the requests of a busy application
+ * share the `Database` component instead. A connection failure rejects its creation with the driver error.
+ *
+ * The entities of its `entities` option are added to the entities of its connection options.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildDatabaseOptions, Database} from 'lakutata/provider/database'
+ * import {Column, Entity, PrimaryGeneratedColumn} from 'lakutata/decorator/orm'
+ *
+ * @Entity()
+ * class Report {
+ *     @PrimaryGeneratedColumn()
+ *     public id: number
+ *
+ *     @Column('text')
+ *     public content: string
+ * }
+ *
+ * Application
+ *     .run(() => ({
+ *         id: 'com.example.reports',
+ *         name: 'Reports',
+ *         providers: {
+ *             reports: {
+ *                 ...buildDatabaseOptions({type: 'postgres', url: 'postgres://postgres:secret@localhost:5432/reports', synchronize: true}),
+ *                 entities: [Report]
+ *             }
+ *         }
+ *     }))
+ *     .onLaunched(async (app: Application): Promise<void> => {
+ *         //A connection opened for this use, closed with the application
+ *         const database: Database = await app.getObject('reports')
+ *         await database.transaction(async (manager): Promise<void> => {
+ *             await manager.save(Report, {content: 'Daily report'})
+ *         })
+ *         console.log(await database.getRepository(Report).count())
+ *     })
+ * ```
+ */
+let Database = class Database extends core_1.Provider {
+    /**
+     * 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 Promise.resolve().then(() => __importStar(require('./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 Promise.resolve().then(() => __importStar(require('./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, their entities and the ones of the `entities` option.
+     * @protected
+     */
+    async init() {
+        const entities = this.entities ? this.entities : [];
+        const options = {
+            ...this.options,
+            entities: [...(0, utils_1.As)(this.options.entities ? this.options.entities : []), ...(0, utils_1.As)(entities)]
+        };
+        this.#datasource = await (new DataSource_js_1.DataSource(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);
+    }
+};
+exports.Database = Database;
+__decorate([
+    (0, di_1.Configurable)(),
+    __metadata("design:type", Object)
+], Database.prototype, "options", void 0);
+__decorate([
+    (0, di_1.Configurable)(),
+    __metadata("design:type", Object)
+], Database.prototype, "entities", void 0);
+exports.Database = Database = __decorate([
+    (0, di_1.Transient)()
+], Database);

package/dist/cjs/providers/migration/ExecuteMigration.d.ts

@@ -0,0 +1,40 @@
+import { Provider } from '@lakutata/core';
+import { type DataSourceOptions } from 'typeorm/data-source/DataSourceOptions.js';
+import { DataSource } from 'typeorm/data-source/DataSource.js';
+/**
+ * The actions on the migrations of a database
+ */
+export type MigrationAction = 'run' | 'revert' | 'show';
+/**
+ * Run, revert or show the migrations of a database of the application, with its options (MIGRATION_RUN, MIGRATION_REVERT,
+ * MIGRATION_SHOW): the database is connected without synchronizing its schema nor running its migrations, the action
+ * done, then the application exits (with the code 1 when the action fails)
+ */
+export declare class ExecuteMigration extends Provider {
+    protected readonly action: MigrationAction;
+    protected readonly dataSourceName: string;
+    protected readonly dataSource: DataSourceOptions;
+    protected readonly transaction?: 'all' | 'none' | 'each';
+    /**
+     * The transactions of the migrations: MIGRATION_TRANSACTION, else the migrationsTransactionMode of the database, else
+     * one for all
+     */
+    protected get transactionMode(): 'all' | 'none' | 'each';
+    protected readonly fake: boolean;
+    protected readonly exitProcess: boolean;
+    /**
+     * The prefix of the messages: the name of the database
+     */
+    protected get prefix(): string;
+    /**
+     * Initializer
+     * @protected
+     */
+    protected init(): Promise<void>;
+    /**
+     * Do the action on the database
+     * @param dataSource
+     * @protected
+     */
+    protected handle(dataSource: DataSource): Promise<void>;
+}

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

@@ -0,0 +1,143 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecuteMigration = void 0;
+const core_1 = require("@lakutata/core");
+const di_1 = require("@lakutata/core/decorator/di");
+const DataSource_js_1 = require("typeorm/data-source/DataSource.js");
+const MigrationExecutor_js_1 = require("typeorm/migration/MigrationExecutor.js");
+const ansis_1 = __importDefault(require("ansis"));
+/**
+ * The executor of the migrations, giving the migrations of the options of the database
+ */
+class Executor extends MigrationExecutor_js_1.MigrationExecutor {
+    /**
+     * The migrations of the options of the database, in their order
+     */
+    sourceMigrations() {
+        return this.getMigrations();
+    }
+}
+/**
+ * Run, revert or show the migrations of a database of the application, with its options (MIGRATION_RUN, MIGRATION_REVERT,
+ * MIGRATION_SHOW): the database is connected without synchronizing its schema nor running its migrations, the action
+ * done, then the application exits (with the code 1 when the action fails)
+ */
+let ExecuteMigration = class ExecuteMigration extends core_1.Provider {
+    /**
+     * The transactions of the migrations: MIGRATION_TRANSACTION, else the migrationsTransactionMode of the database, else
+     * one for all
+     */
+    get transactionMode() {
+        return this.transaction ?? this.dataSource.migrationsTransactionMode ?? 'all';
+    }
+    /**
+     * The prefix of the messages: the name of the database
+     */
+    get prefix() {
+        return this.dataSourceName ? `[${this.dataSourceName}] ` : '';
+    }
+    /**
+     * Initializer
+     * @protected
+     */
+    async init() {
+        const app = await this.getObject(core_1.Application);
+        const dataSource = new DataSource_js_1.DataSource({ ...this.dataSource, synchronize: false, migrationsRun: false, dropSchema: false });
+        let failed = false;
+        try {
+            await dataSource.initialize();
+            await this.handle(dataSource);
+        }
+        catch (error) {
+            console.error(ansis_1.default.red `${this.prefix}The migrations could not be ${this.action === 'show' ? 'shown' : this.action === 'run' ? 'run' : 'reverted'}:`, error);
+            failed = true;
+        }
+        finally {
+            if (dataSource.isInitialized)
+                await dataSource.destroy();
+        }
+        //A failure stops the actions on the other databases
+        if (failed)
+            return app.exit(1);
+        if (this.exitProcess)
+            return app.exit(0);
+    }
+    /**
+     * Do the action on the database
+     * @param dataSource
+     * @protected
+     */
+    async handle(dataSource) {
+        const executor = new Executor(dataSource);
+        switch (this.action) {
+            case 'run': {
+                const pending = await executor.getPendingMigrations();
+                const ran = await dataSource.runMigrations({ transaction: this.transactionMode, fake: this.fake });
+                //The migrations marked as run are not given back by TypeORM
+                const executed = this.fake ? pending : ran;
+                if (!executed.length)
+                    return console.log(ansis_1.default.green `${this.prefix}No pending migration`);
+                for (const migration of executed)
+                    console.log(ansis_1.default.green `${this.prefix}Migration ${ansis_1.default.blue(migration.name)} has been ${this.fake ? 'marked as run' : 'run'}`);
+                return;
+            }
+            case 'revert': {
+                const [last] = (await executor.getExecutedMigrations()).sort((a, b) => (b.id ?? 0) - (a.id ?? 0));
+                if (!last)
+                    return console.log(ansis_1.default.yellow `${this.prefix}No migration to revert`);
+                await dataSource.undoLastMigration({ transaction: this.transactionMode, fake: this.fake });
+                return console.log(ansis_1.default.green `${this.prefix}Migration ${ansis_1.default.blue(last.name)} has been ${this.fake ? 'marked as reverted' : 'reverted'}`);
+            }
+            case 'show': {
+                const executed = new Set((await executor.getExecutedMigrations()).map((migration) => migration.name));
+                const migrations = executor.sourceMigrations();
+                if (!migrations.length)
+                    return console.log(ansis_1.default.yellow `${this.prefix}No migration in the options of the database`);
+                for (const migration of migrations)
+                    console.log(`${this.prefix}${executed.has(migration.name) ? ansis_1.default.green `[X]` : ansis_1.default.yellow `[ ]`} ${migration.name}`);
+                const pending = migrations.filter((migration) => !executed.has(migration.name)).length;
+                return console.log(pending ? ansis_1.default.yellow `${this.prefix}${pending} pending migration${pending > 1 ? 's' : ''}` : ansis_1.default.green `${this.prefix}No pending migration`);
+            }
+        }
+    }
+};
+exports.ExecuteMigration = ExecuteMigration;
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.String().valid('run', 'revert', 'show').required()),
+    __metadata("design:type", String)
+], ExecuteMigration.prototype, "action", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.String().allow('').optional().default('')),
+    __metadata("design:type", String)
+], ExecuteMigration.prototype, "dataSourceName", void 0);
+__decorate([
+    (0, di_1.Configurable)(),
+    __metadata("design:type", Object)
+], ExecuteMigration.prototype, "dataSource", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.String().valid('all', 'none', 'each').optional()),
+    __metadata("design:type", String)
+], ExecuteMigration.prototype, "transaction", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ExecuteMigration.prototype, "fake", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], ExecuteMigration.prototype, "exitProcess", void 0);
+exports.ExecuteMigration = ExecuteMigration = __decorate([
+    (0, di_1.Transient)()
+], ExecuteMigration);

package/dist/cjs/providers/migration/GenerateMigration.d.ts

@@ -0,0 +1,59 @@
+import { Provider } from '@lakutata/core';
+import { type DataSourceOptions } from 'typeorm/data-source/DataSourceOptions.js';
+export declare class GenerateMigration extends Provider {
+    #private;
+    protected readonly path: string;
+    protected readonly dataSourceName: string;
+    protected readonly dataSource: DataSourceOptions;
+    protected readonly pretty: boolean;
+    protected readonly outputJs: boolean;
+    protected readonly esm: boolean;
+    protected readonly dryRun: boolean;
+    protected readonly check: boolean;
+    protected readonly timestamp: number;
+    protected readonly exitProcess: boolean;
+    protected get extension(): string;
+    protected get filename(): string;
+    /**
+     * Initializer
+     * @protected
+     */
+    /**
+     * The migrations generated by the run (its databases share the process)
+     */
+    protected static generated: number;
+    protected init(): Promise<void>;
+    /**
+     * Destroyer
+     * @protected
+     */
+    protected destroy(): Promise<void>;
+    protected handle(): Promise<void>;
+    /**
+     * 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)
+     */
+    protected static migrationModule(): string;
+    /**
+     * 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
+     */
+    protected static escapeTemplateLiteral(query: string): string;
+    /**
+     * Formats query parameters for migration queries if parameters actually exist
+     */
+    protected static queryParams(parameters: any[] | undefined): string;
+    /**
+     * Gets contents of the migration file.
+     */
+    protected static getTemplate(name: string, timestamp: number, upSqls: string[], downSqls: string[]): string;
+    /**
+     * Gets contents of the migration file in Javascript.
+     */
+    protected static getJavascriptTemplate(name: string, timestamp: number, upSqls: string[], downSqls: string[], esm: boolean): string;
+    /**
+     *
+     */
+    protected static prettifyQuery(query: string): string;
+}