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

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

@@ -0,0 +1,137 @@
+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 { Provider, DTO, Application } from '@lakutata/core';
+import { Configurable, Transient } from '@lakutata/core/decorator/di';
+import { DataSource } from 'typeorm/data-source/DataSource.js';
+import { MigrationExecutor } from 'typeorm/migration/MigrationExecutor.js';
+import ansi from 'ansis';
+/**
+ * The executor of the migrations, giving the migrations of the options of the database
+ */
+class Executor extends 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 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(Application);
+        const dataSource = new DataSource({ ...this.dataSource, synchronize: false, migrationsRun: false, dropSchema: false });
+        let failed = false;
+        try {
+            await dataSource.initialize();
+            await this.handle(dataSource);
+        }
+        catch (error) {
+            console.error(ansi.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(ansi.green `${this.prefix}No pending migration`);
+                for (const migration of executed)
+                    console.log(ansi.green `${this.prefix}Migration ${ansi.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(ansi.yellow `${this.prefix}No migration to revert`);
+                await dataSource.undoLastMigration({ transaction: this.transactionMode, fake: this.fake });
+                return console.log(ansi.green `${this.prefix}Migration ${ansi.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(ansi.yellow `${this.prefix}No migration in the options of the database`);
+                for (const migration of migrations)
+                    console.log(`${this.prefix}${executed.has(migration.name) ? ansi.green `[X]` : ansi.yellow `[ ]`} ${migration.name}`);
+                const pending = migrations.filter((migration) => !executed.has(migration.name)).length;
+                return console.log(pending ? ansi.yellow `${this.prefix}${pending} pending migration${pending > 1 ? 's' : ''}` : ansi.green `${this.prefix}No pending migration`);
+            }
+        }
+    }
+};
+__decorate([
+    Configurable(DTO.String().valid('run', 'revert', 'show').required()),
+    __metadata("design:type", String)
+], ExecuteMigration.prototype, "action", void 0);
+__decorate([
+    Configurable(DTO.String().allow('').optional().default('')),
+    __metadata("design:type", String)
+], ExecuteMigration.prototype, "dataSourceName", void 0);
+__decorate([
+    Configurable(),
+    __metadata("design:type", Object)
+], ExecuteMigration.prototype, "dataSource", void 0);
+__decorate([
+    Configurable(DTO.String().valid('all', 'none', 'each').optional()),
+    __metadata("design:type", String)
+], ExecuteMigration.prototype, "transaction", void 0);
+__decorate([
+    Configurable(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], ExecuteMigration.prototype, "fake", void 0);
+__decorate([
+    Configurable(DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], ExecuteMigration.prototype, "exitProcess", void 0);
+ExecuteMigration = __decorate([
+    Transient()
+], ExecuteMigration);
+export { ExecuteMigration };

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

@@ -0,0 +1,297 @@
+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 GenerateMigration_1;
+/*
+ * 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)
+ */
+import { Provider, DTO, Application } from '@lakutata/core';
+import { Configurable, Transient } from '@lakutata/core/decorator/di';
+import path from 'path';
+import { readFileSync } from 'fs';
+import { DataSource } from 'typeorm/data-source/DataSource.js';
+import { format } from '@sqltools/formatter/lib/sqlFormatter.js';
+import { camelCase } from 'typeorm/util/StringUtils.js';
+import { PlatformTools } from 'typeorm/platform/PlatformTools.js';
+import { CommandUtils } from 'typeorm/commands/CommandUtils.js';
+import ansi from 'ansis';
+let GenerateMigration = class GenerateMigration extends Provider {
+    static { GenerateMigration_1 = this; }
+    get extension() {
+        return this.outputJs ? '.js' : '.ts';
+    }
+    get filename() {
+        return this.timestamp + '-' + (this.dataSourceName ? this.dataSourceName : path.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(Application);
+        this.#dataSource = new 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(ansi.green `No changes in database schema were found`);
+                    if (this.exitProcess) {
+                        return this.#app.exit(0);
+                    }
+                    else {
+                        return;
+                    }
+                }
+                else {
+                    console.log(ansi.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(ansi.yellow `Please specify a migration path`);
+                return this.#app.exit(1);
+            }
+            const fileContent = this.outputJs
+                ? GenerateMigration_1.getJavascriptTemplate(path.basename(this.path), this.timestamp, upSqls, downSqls.reverse(), this.esm)
+                : GenerateMigration_1.getTemplate(path.basename(this.path), this.timestamp, upSqls, downSqls.reverse());
+            if (this.check) {
+                console.log(ansi.yellow `Unexpected changes in database schema were found in check mode:\n\n${ansi.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(ansi.green(`Migration ${ansi.blue(this.path + this.extension)} has content:\n\n${ansi.white(fileContent)}`));
+                if (this.exitProcess)
+                    return this.#app.exit(0);
+            }
+            else {
+                const migrationFileName = path.isAbsolute(this.path) ? path.join(this.path, this.filename) : path.join(process.cwd(), this.path, this.filename);
+                await CommandUtils.createFile(migrationFileName, fileContent);
+                console.log(ansi.green `Migration ${ansi.blue(migrationFileName)} has been generated successfully.`);
+                if (this.exitProcess) {
+                    return this.#app.exit(0);
+                }
+                else {
+                    return;
+                }
+            }
+        }
+        catch (err) {
+            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(readFileSync(path.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 = `${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 = `${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 = format(query, { indent: '    ' });
+        return ('\n' + formattedQuery.replace(/^/gm, '            ') + '\n        ');
+    }
+};
+__decorate([
+    Configurable(DTO.String().required()),
+    __metadata("design:type", String)
+], GenerateMigration.prototype, "path", void 0);
+__decorate([
+    Configurable(DTO.String().allow('').optional().default('')),
+    __metadata("design:type", String)
+], GenerateMigration.prototype, "dataSourceName", void 0);
+__decorate([
+    Configurable(),
+    __metadata("design:type", Object)
+], GenerateMigration.prototype, "dataSource", void 0);
+__decorate([
+    Configurable(DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], GenerateMigration.prototype, "pretty", void 0);
+__decorate([
+    Configurable(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], GenerateMigration.prototype, "outputJs", void 0);
+__decorate([
+    Configurable(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], GenerateMigration.prototype, "esm", void 0);
+__decorate([
+    Configurable(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], GenerateMigration.prototype, "dryRun", void 0);
+__decorate([
+    Configurable(DTO.Boolean().optional().default(false)),
+    __metadata("design:type", Boolean)
+], GenerateMigration.prototype, "check", void 0);
+__decorate([
+    Configurable(DTO.Number().optional().default(() => Date.now())),
+    __metadata("design:type", Number)
+], GenerateMigration.prototype, "timestamp", void 0);
+__decorate([
+    Configurable(DTO.Boolean().optional().default(true)),
+    __metadata("design:type", Boolean)
+], GenerateMigration.prototype, "exitProcess", void 0);
+GenerateMigration = GenerateMigration_1 = __decorate([
+    Transient()
+], GenerateMigration);
+export { GenerateMigration };

package/dist/esm/types/MigrationRunOptions.js

@@ -0,0 +1 @@
+export {};