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

package/commands/MigrationCommandFactory.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationCommandFactory = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const CLIHelper_1 = require("../CLIHelper");
+class MigrationCommandFactory {
+    static DESCRIPTIONS = {
+        create: "Create new migration with current schema diff",
+        up: "Migrate up to the latest version",
+        down: "Migrate one step down",
+        list: "List all executed migrations",
+        check: "Check if migrations are needed. Useful for bash scripts.",
+        pending: "List all pending migrations",
+        fresh: "Clear the database and rerun all migrations",
+    };
+    static create(command) {
+        return {
+            command: `migration:${command}`,
+            describe: MigrationCommandFactory.DESCRIPTIONS[command],
+            builder: (args) => MigrationCommandFactory.configureMigrationCommand(args, command),
+            handler: (args) => MigrationCommandFactory.handleMigrationCommand(args, command),
+        };
+    }
+    static configureMigrationCommand(args, method) {
+        if (method === "create") {
+            this.configureCreateCommand(args);
+        }
+        if (["up", "down"].includes(method)) {
+            this.configureUpDownCommand(args, method);
+        }
+        if (method === "fresh") {
+            this.configureFreshCommand(args);
+        }
+        return args;
+    }
+    static configureUpDownCommand(args, method) {
+        args.option("t", {
+            alias: "to",
+            type: "string",
+            desc: `Migrate ${method} to specific version`,
+        });
+        args.option("f", {
+            alias: "from",
+            type: "string",
+            desc: "Start migration from specific version",
+        });
+        args.option("o", {
+            alias: "only",
+            type: "string",
+            desc: "Migrate only specified versions",
+        });
+    }
+    static configureCreateCommand(args) {
+        args.option("b", {
+            alias: "blank",
+            type: "boolean",
+            desc: "Create blank migration",
+        });
+        args.option("i", {
+            alias: "initial",
+            type: "boolean",
+            desc: "Create initial migration",
+        });
+        args.option("d", {
+            alias: "dump",
+            type: "boolean",
+            desc: "Dumps all queries to console",
+        });
+        args.option("p", {
+            alias: "path",
+            type: "string",
+            desc: "Sets path to directory where to save entities",
+        });
+        args.option("n", {
+            alias: "name",
+            type: "string",
+            desc: "Specify custom name for the file",
+        });
+    }
+    static async handleMigrationCommand(args, method) {
+        // to be able to run have a master transaction, but run marked migrations outside of it, we need a second connection
+        const options = { pool: { min: 1, max: 2 } };
+        const orm = await CLIHelper_1.CLIHelper.getORM(undefined, options);
+        const migrator = orm.getMigrator();
+        switch (method) {
+            case "create":
+                await this.handleCreateCommand(migrator, args, orm.config);
+                break;
+            case "check":
+                await this.handleCheckCommand(migrator, orm);
+                break;
+            case "list":
+                await this.handleListCommand(migrator);
+                break;
+            case "pending":
+                await this.handlePendingCommand(migrator);
+                break;
+            case "up":
+            case "down":
+                await this.handleUpDownCommand(args, migrator, method);
+                break;
+            case "fresh":
+                await this.handleFreshCommand(args, migrator, orm);
+        }
+        await orm.close(true);
+    }
+    static configureFreshCommand(args) {
+        args.option("seed", {
+            type: "string",
+            desc: "Allows to seed the database after dropping it and rerunning all migrations",
+        });
+        args.option("drop-db", {
+            type: "boolean",
+            desc: "Drop the whole database",
+        });
+    }
+    static async handleUpDownCommand(args, migrator, method) {
+        const opts = MigrationCommandFactory.getUpDownOptions(args);
+        await migrator[method](opts);
+        const message = this.getUpDownSuccessMessage(method, opts);
+        CLIHelper_1.CLIHelper.dump(core_1.colors.green(message));
+    }
+    static async handlePendingCommand(migrator) {
+        const pending = await migrator.getPendingMigrations();
+        CLIHelper_1.CLIHelper.dumpTable({
+            columns: ["Name"],
+            rows: pending.map((row) => [row.name]),
+            empty: "No pending migrations",
+        });
+    }
+    static async handleListCommand(migrator) {
+        const executed = await migrator.getExecutedMigrations();
+        CLIHelper_1.CLIHelper.dumpTable({
+            columns: ["Name", "Executed at"],
+            rows: executed.map((row) => {
+                /* istanbul ignore next */
+                const executedAt = (row.executed_at ?? row.created_at)?.toISOString() ??
+                    "";
+                return [row.name.replace(/\.[jt]s$/, ""), executedAt];
+            }),
+            empty: "No migrations executed yet",
+        });
+    }
+    static async handleCreateCommand(migrator, args, config) {
+        const ret = await migrator.createMigration(args.path, args.blank, args.initial, args.name);
+        if (ret.diff.up.length === 0) {
+            return CLIHelper_1.CLIHelper.dump(core_1.colors.green(`No changes required, schema is up-to-date`));
+        }
+        if (args.dump) {
+            CLIHelper_1.CLIHelper.dump(core_1.colors.green("Creating migration with following queries:"));
+            CLIHelper_1.CLIHelper.dump(core_1.colors.green("up:"));
+            CLIHelper_1.CLIHelper.dump(ret.diff.up.map((sql) => "  " + sql).join("\n"), config);
+            /* istanbul ignore next */
+            if (config.getDriver().getPlatform().supportsDownMigrations()) {
+                CLIHelper_1.CLIHelper.dump(core_1.colors.green("down:"));
+                CLIHelper_1.CLIHelper.dump(ret.diff.down.map((sql) => "  " + sql).join("\n"), config);
+            }
+            else {
+                CLIHelper_1.CLIHelper.dump(core_1.colors.yellow(`(${config.getDriver().constructor.name} does not support automatic down migrations)`));
+            }
+        }
+        CLIHelper_1.CLIHelper.dump(core_1.colors.green(`${ret.fileName} successfully created`));
+    }
+    static async handleCheckCommand(migrator, orm) {
+        if (!(await migrator.checkMigrationNeeded())) {
+            return CLIHelper_1.CLIHelper.dump(core_1.colors.green(`No changes required, schema is up-to-date`));
+        }
+        await orm.close(true);
+        CLIHelper_1.CLIHelper.dump(core_1.colors.yellow(`Changes detected. Please create migration to update schema.`));
+        process.exit(1);
+    }
+    static async handleFreshCommand(args, migrator, orm) {
+        const generator = orm.getSchemaGenerator();
+        await generator.dropSchema({
+            dropMigrationsTable: true,
+            dropDb: args.dropDb,
+        });
+        CLIHelper_1.CLIHelper.dump(core_1.colors.green("Dropped schema successfully"));
+        const opts = MigrationCommandFactory.getUpDownOptions(args);
+        await migrator.up(opts);
+        const message = this.getUpDownSuccessMessage("up", opts);
+        CLIHelper_1.CLIHelper.dump(core_1.colors.green(message));
+        if (args.seed !== undefined) {
+            const seeder = orm.getSeeder();
+            const seederClass = args.seed || orm.config.get("seeder").defaultSeeder;
+            await seeder.seedString(seederClass);
+            CLIHelper_1.CLIHelper.dump(core_1.colors.green(`Database seeded successfully with seeder class ${seederClass}`));
+        }
+    }
+    static getUpDownOptions(flags) {
+        if (!flags.to && !flags.from && flags.only) {
+            return { migrations: flags.only.split(/[, ]+/) };
+        }
+        const ret = {};
+        ["from", "to"]
+            .filter((k) => flags[k])
+            .forEach((k) => (ret[k] = flags[k] === "0" ? 0 : flags[k]));
+        return ret;
+    }
+    static getUpDownSuccessMessage(method, options) {
+        const msg = `Successfully migrated ${method}`;
+        if (method === "down" && core_1.Utils.isEmpty(options)) {
+            return msg + " to previous version";
+        }
+        if (options.to === 0) {
+            const v = { down: "first", up: "latest" }[method];
+            return `${msg} to the ${v} version`;
+        }
+        if (method === "up" && core_1.Utils.isEmpty(options)) {
+            return msg + " to the latest version";
+        }
+        if (core_1.Utils.isString(options.to)) {
+            return msg + " to version " + options.to;
+        }
+        if (options.migrations && options.migrations.length === 1) {
+            return msg + " to version " + options.migrations[0];
+        }
+        return msg;
+    }
+}
+exports.MigrationCommandFactory = MigrationCommandFactory;

package/commands/SchemaCommandFactory.d.ts

@@ -0,0 +1,34 @@
+import type { ArgumentsCamelCase, Argv, CommandModule } from "yargs";
+export declare class SchemaCommandFactory {
+    static readonly DESCRIPTIONS: {
+        create: string;
+        update: string;
+        drop: string;
+        fresh: string;
+    };
+    static readonly SUCCESS_MESSAGES: {
+        create: string;
+        update: string;
+        drop: string;
+        fresh: string;
+    };
+    static create<U extends Options = Options>(command: SchemaMethod): CommandModule<unknown, U> & {
+        builder: (args: Argv) => Argv<U>;
+        handler: (args: ArgumentsCamelCase<U>) => Promise<void>;
+    };
+    static configureSchemaCommand(args: Argv, command: SchemaMethod): Argv<{}>;
+    static handleSchemaCommand(args: ArgumentsCamelCase<Options>, method: SchemaMethod, successMessage: string): Promise<void>;
+}
+type SchemaMethod = "create" | "update" | "drop" | "fresh";
+export type Options = {
+    dump: boolean;
+    run: boolean;
+    fkChecks: boolean;
+    dropMigrationsTable: boolean;
+    dropDb: boolean;
+    dropTables: boolean;
+    safe: boolean;
+    seed: string;
+    schema: string;
+};
+export {};

package/commands/SchemaCommandFactory.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaCommandFactory = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const CLIHelper_1 = require("../CLIHelper");
+class SchemaCommandFactory {
+    static DESCRIPTIONS = {
+        create: "Create database schema based on current metadata",
+        update: "Update database schema based on current metadata",
+        drop: "Drop database schema based on current metadata",
+        fresh: "Drop and recreate database schema based on current metadata",
+    };
+    static SUCCESS_MESSAGES = {
+        create: "Schema successfully created",
+        update: "Schema successfully updated",
+        drop: "Schema successfully dropped",
+        fresh: "Schema successfully dropped and recreated",
+    };
+    static create(command) {
+        const successMessage = SchemaCommandFactory.SUCCESS_MESSAGES[command];
+        return {
+            command: `schema:${command}`,
+            describe: SchemaCommandFactory.DESCRIPTIONS[command],
+            builder: (args) => SchemaCommandFactory.configureSchemaCommand(args, command),
+            handler: (args) => SchemaCommandFactory.handleSchemaCommand(args, command, successMessage),
+        };
+    }
+    static configureSchemaCommand(args, command) {
+        args.option("r", {
+            alias: "run",
+            type: "boolean",
+            desc: "Runs queries",
+        });
+        if (command !== "fresh") {
+            args.option("d", {
+                alias: "dump",
+                type: "boolean",
+                desc: "Dumps all queries to console",
+            });
+            args.option("fk-checks", {
+                type: "boolean",
+                desc: "Do not skip foreign key checks",
+            });
+        }
+        args.option("schema", {
+            type: "string",
+            desc: "Set the current schema for wildcard schema entities",
+        });
+        if (["create", "fresh"].includes(command)) {
+            args.option("seed", {
+                type: "string",
+                desc: "Allows to seed the database on create or drop and recreate",
+            });
+        }
+        if (command === "update") {
+            args.option("safe", {
+                type: "boolean",
+                desc: "Allows to disable table and column dropping",
+                default: false,
+            });
+            args.option("drop-tables", {
+                type: "boolean",
+                desc: "Allows to disable table dropping",
+                default: true,
+            });
+        }
+        if (command === "drop") {
+            args.option("drop-migrations-table", {
+                type: "boolean",
+                desc: "Drop also migrations table",
+            });
+        }
+        if (["drop", "fresh"].includes(command)) {
+            args.option("drop-db", {
+                type: "boolean",
+                desc: "Drop the whole database",
+            });
+        }
+        return args;
+    }
+    static async handleSchemaCommand(args, method, successMessage) {
+        if (!args.run && !args.dump) {
+            return CLIHelper_1.CLIHelper.showHelp();
+        }
+        const orm = await CLIHelper_1.CLIHelper.getORM();
+        const generator = orm.getSchemaGenerator();
+        const params = {
+            wrap: args.fkChecks == null ? undefined : !args.fkChecks,
+            ...args,
+        };
+        if (args.dump) {
+            const m = `get${method.substr(0, 1).toUpperCase()}${method.substr(1)}SchemaSQL`;
+            const dump = await generator[m](params);
+            /* istanbul ignore next */
+            if (dump) {
+                CLIHelper_1.CLIHelper.dump(dump, orm.config);
+                successMessage = "";
+            }
+            else {
+                successMessage = "Schema is up-to-date";
+            }
+        }
+        else if (method === "fresh") {
+            await generator.dropSchema(params);
+            await generator.createSchema(params);
+        }
+        else {
+            const m = (method + "Schema");
+            await generator[m](params);
+        }
+        if (args.seed !== undefined) {
+            const seeder = orm.getSeeder();
+            await seeder.seedString(args.seed || orm.config.get("seeder").defaultSeeder);
+        }
+        CLIHelper_1.CLIHelper.dump(core_1.colors.green(successMessage));
+        await orm.close(true);
+    }
+}
+exports.SchemaCommandFactory = SchemaCommandFactory;

package/esm

@@ -0,0 +1,18 @@
+#!/usr/bin/env -S node --loader ts-node/esm --no-warnings=ExperimentalWarning
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+require('@jercle/yargonaut')
+    .style('blue')
+    .style('yellow', 'required')
+    .helpStyle('green')
+    .errorsStyle('red');
+const CLIHelper_1 = require("./CLIHelper");
+const CLIConfigurator_1 = require("./CLIConfigurator");
+(async () => {
+    const argv = await CLIConfigurator_1.CLIConfigurator.configure();
+    const args = await argv.parse(process.argv.slice(2));
+    if (args._.length === 0) {
+        CLIHelper_1.CLIHelper.showHelp();
+    }
+})();

package/esm.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node --loader ts-node/esm --no-warnings=ExperimentalWarning "%~dp0\esm" %*

package/esm.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env -S node --loader ts-node/esm --no-warnings=ExperimentalWarning
+export {};

package/esm.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env -S node --loader ts-node/esm --no-warnings=ExperimentalWarning
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+require('@jercle/yargonaut')
+    .style('blue')
+    .style('yellow', 'required')
+    .helpStyle('green')
+    .errorsStyle('red');
+const CLIHelper_1 = require("./CLIHelper");
+const CLIConfigurator_1 = require("./CLIConfigurator");
+(async () => {
+    const argv = await CLIConfigurator_1.CLIConfigurator.configure();
+    const args = await argv.parse(process.argv.slice(2));
+    if (args._.length === 0) {
+        CLIHelper_1.CLIHelper.showHelp();
+    }
+})();

package/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @packageDocumentation
+ * @module cli
+ */
+export * from './CLIHelper';
+export * from './CLIConfigurator';

package/index.js

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

package/index.mjs

@@ -0,0 +1,5 @@
+import mod from "./index.js";
+
+export default mod;
+export const CLIConfigurator = mod.CLIConfigurator;
+export const CLIHelper = mod.CLIHelper;

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@yandjin-mikro-orm/cli",
+  "version": "6.1.4-rc-sti-changes-1",
+  "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
+  "main": "index.js",
+  "module": "index.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./index.mjs"
+      },
+      "require": "./index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
+  "keywords": [
+    "orm",
+    "mongo",
+    "mongodb",
+    "mysql",
+    "mariadb",
+    "postgresql",
+    "sqlite",
+    "sqlite3",
+    "ts",
+    "typescript",
+    "js",
+    "javascript",
+    "entity",
+    "ddd",
+    "mikro-orm",
+    "unit-of-work",
+    "data-mapper",
+    "identity-map"
+  ],
+  "author": "Martin Adámek",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mikro-orm/mikro-orm/issues"
+  },
+  "homepage": "https://mikro-orm.io",
+  "bin": {
+    "mikro-orm": "./cli",
+    "mikro-orm-esm": "./esm"
+  },
+  "engines": {
+    "node": ">= 18.12.0"
+  },
+  "scripts": {
+    "build": "yarn clean && yarn compile && yarn copy && yarn run -T gen-esm-wrapper index.js index.mjs",
+    "clean": "yarn run -T rimraf ./dist",
+    "compile": "yarn run -T tsc -p tsconfig.build.json",
+    "copy": "node ../../scripts/copy.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@jercle/yargonaut": "1.1.5",
+    "@yandjin-mikro-orm/core": "6.1.4-rc-sti-changes-1",
+    "@yandjin-mikro-orm/knex": "6.1.4-rc-sti-changes-1",
+    "fs-extra": "11.2.0",
+    "tsconfig-paths": "4.2.0",
+    "yargs": "17.7.2"
+  },
+  "devDependencies": {
+    "@yandjin-mikro-orm/entity-generator": "^6.1.4-rc-sti-changes-1",
+    "@yandjin-mikro-orm/migrations": "^6.1.4-rc-sti-changes-1",
+    "@yandjin-mikro-orm/seeder": "^6.1.4-rc-sti-changes-1"
+  }
+}