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

package/cli.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+"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/commands/ClearCacheCommand.d.ts

@@ -0,0 +1,9 @@
+import type { ArgumentsCamelCase, CommandModule } from "yargs";
+export declare class ClearCacheCommand implements CommandModule {
+    command: string;
+    describe: string;
+    /**
+     * @inheritDoc
+     */
+    handler(args: ArgumentsCamelCase): Promise<void>;
+}

package/commands/ClearCacheCommand.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClearCacheCommand = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const CLIHelper_1 = require("../CLIHelper");
+class ClearCacheCommand {
+    command = "cache:clear";
+    describe = "Clear metadata cache";
+    /**
+     * @inheritDoc
+     */
+    async handler(args) {
+        const config = await CLIHelper_1.CLIHelper.getConfiguration();
+        if (!config.get("metadataCache").enabled) {
+            CLIHelper_1.CLIHelper.dump(core_1.colors.red("Metadata cache is disabled in your configuration. Set cache.enabled to true to use this command."));
+            return;
+        }
+        const cache = config.getMetadataCacheAdapter();
+        await cache.clear();
+        CLIHelper_1.CLIHelper.dump(core_1.colors.green("Metadata cache was successfully cleared"));
+    }
+}
+exports.ClearCacheCommand = ClearCacheCommand;

package/commands/CreateDatabaseCommand.d.ts

@@ -0,0 +1,9 @@
+import type { ArgumentsCamelCase, CommandModule } from "yargs";
+export declare class CreateDatabaseCommand implements CommandModule {
+    command: string;
+    describe: string;
+    /**
+     * @inheritDoc
+     */
+    handler(args: ArgumentsCamelCase): Promise<void>;
+}

package/commands/CreateDatabaseCommand.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateDatabaseCommand = void 0;
+const CLIHelper_1 = require("../CLIHelper");
+class CreateDatabaseCommand {
+    command = "database:create";
+    describe = "Create your database if it does not exist";
+    /**
+     * @inheritDoc
+     */
+    async handler(args) {
+        const orm = (await CLIHelper_1.CLIHelper.getORM());
+        const schemaGenerator = orm.getSchemaGenerator();
+        await schemaGenerator.ensureDatabase();
+        await orm.close(true);
+    }
+}
+exports.CreateDatabaseCommand = CreateDatabaseCommand;

package/commands/CreateSeederCommand.d.ts

@@ -0,0 +1,20 @@
+import type { ArgumentsCamelCase, Argv, CommandModule } from "yargs";
+export declare class CreateSeederCommand<T> implements CommandModule<T, {
+    seeder: string;
+}> {
+    command: string;
+    describe: string;
+    builder: (args: Argv<T>) => Argv<{
+        seeder: string;
+    }>;
+    /**
+     * @inheritDoc
+     */
+    handler(args: ArgumentsCamelCase<{
+        seeder?: string;
+    }>): Promise<void>;
+    /**
+     * Will return a seeder name that is formatted like this EntitySeeder
+     */
+    private static getSeederClassName;
+}

package/commands/CreateSeederCommand.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateSeederCommand = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const CLIHelper_1 = require("../CLIHelper");
+class CreateSeederCommand {
+    command = "seeder:create <seeder>";
+    describe = "Create a new seeder class";
+    builder = (args) => {
+        args.positional("seeder", {
+            describe: 'Name for the seeder class. (e.g. "test" will generate "TestSeeder" or "TestSeeder" will generate "TestSeeder")',
+        });
+        args.demandOption("seeder");
+        return args;
+    };
+    /**
+     * @inheritDoc
+     */
+    async handler(args) {
+        const className = CreateSeederCommand.getSeederClassName(args.seeder);
+        const orm = await CLIHelper_1.CLIHelper.getORM();
+        const seeder = orm.getSeeder();
+        const path = await seeder.createSeeder(className);
+        CLIHelper_1.CLIHelper.dump(core_1.colors.green(`Seeder ${args.seeder} successfully created at ${path}`));
+        await orm.close(true);
+    }
+    /**
+     * Will return a seeder name that is formatted like this EntitySeeder
+     */
+    static getSeederClassName(name) {
+        name = name.match(/(.+)seeder/i)?.[1] ?? name;
+        const parts = name.split("-");
+        return (parts
+            .map((name) => name.charAt(0).toUpperCase() + name.slice(1))
+            .join("") + "Seeder");
+    }
+}
+exports.CreateSeederCommand = CreateSeederCommand;

package/commands/DatabaseSeedCommand.d.ts

@@ -0,0 +1,16 @@
+import type { ArgumentsCamelCase, Argv, CommandModule } from "yargs";
+export declare class DatabaseSeedCommand<T> implements CommandModule<T, {
+    class: string;
+}> {
+    command: string;
+    describe: string;
+    builder: (args: Argv<T>) => Argv<{
+        class: string;
+    }>;
+    /**
+     * @inheritDoc
+     */
+    handler(args: ArgumentsCamelCase<{
+        class?: string;
+    }>): Promise<void>;
+}

package/commands/DatabaseSeedCommand.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseSeedCommand = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const CLIHelper_1 = require("../CLIHelper");
+class DatabaseSeedCommand {
+    command = "seeder:run";
+    describe = "Seed the database using the seeder class";
+    builder = (args) => {
+        args.option("c", {
+            alias: "class",
+            type: "string",
+            desc: "Seeder class to run",
+        });
+        return args;
+    };
+    /**
+     * @inheritDoc
+     */
+    async handler(args) {
+        const orm = await CLIHelper_1.CLIHelper.getORM();
+        const className = args.class ?? orm.config.get("seeder").defaultSeeder;
+        await orm.getSeeder().seedString(className);
+        CLIHelper_1.CLIHelper.dump(core_1.colors.green(`Seeder ${className} successfully executed`));
+        await orm.close(true);
+    }
+}
+exports.DatabaseSeedCommand = DatabaseSeedCommand;

package/commands/DebugCommand.d.ts

@@ -0,0 +1,10 @@
+import type { CommandModule } from "yargs";
+export declare class DebugCommand implements CommandModule {
+    command: string;
+    describe: string;
+    /**
+     * @inheritDoc
+     */
+    handler(): Promise<void>;
+    private static checkPaths;
+}

package/commands/DebugCommand.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugCommand = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const CLIHelper_1 = require("../CLIHelper");
+class DebugCommand {
+    command = "debug";
+    describe = "Debug CLI configuration";
+    /**
+     * @inheritDoc
+     */
+    async handler() {
+        CLIHelper_1.CLIHelper.dump(`Current ${core_1.colors.cyan("MikroORM")} CLI configuration`);
+        await CLIHelper_1.CLIHelper.dumpDependencies();
+        const settings = await core_1.ConfigurationLoader.getSettings();
+        if (settings.useTsNode) {
+            CLIHelper_1.CLIHelper.dump(" - ts-node " + core_1.colors.green("enabled"));
+        }
+        const configPaths = await CLIHelper_1.CLIHelper.getConfigPaths();
+        CLIHelper_1.CLIHelper.dump(" - searched config paths:");
+        await DebugCommand.checkPaths(configPaths, "yellow");
+        try {
+            const config = await CLIHelper_1.CLIHelper.getConfiguration();
+            CLIHelper_1.CLIHelper.dump(` - configuration ${core_1.colors.green("found")}`);
+            const isConnected = await CLIHelper_1.CLIHelper.isDBConnected();
+            if (isConnected) {
+                CLIHelper_1.CLIHelper.dump(` - ${core_1.colors.green("database connection succesful")}`);
+            }
+            else {
+                CLIHelper_1.CLIHelper.dump(` - ${core_1.colors.yellow("database connection failed")}`);
+            }
+            const tsNode = config.get("tsNode");
+            if ([true, false].includes(tsNode)) {
+                const warning = tsNode
+                    ? " (this value should be set to `false` when running compiled code!)"
+                    : "";
+                CLIHelper_1.CLIHelper.dump(` - \`tsNode\` flag explicitly set to ${tsNode}, will use \`entities${tsNode ? "Ts" : ""}\` array${warning}`);
+            }
+            const entities = config.get("entities", []);
+            if (entities.length > 0) {
+                const refs = entities.filter((p) => !core_1.Utils.isString(p));
+                const paths = entities.filter((p) => core_1.Utils.isString(p));
+                const will = !config.get("tsNode") ? "will" : "could";
+                CLIHelper_1.CLIHelper.dump(` - ${will} use \`entities\` array (contains ${refs.length} references and ${paths.length} paths)`);
+                if (paths.length > 0) {
+                    await DebugCommand.checkPaths(paths, "red", config.get("baseDir"));
+                }
+            }
+            const entitiesTs = config.get("entitiesTs", []);
+            if (entitiesTs.length > 0) {
+                const refs = entitiesTs.filter((p) => !core_1.Utils.isString(p));
+                const paths = entitiesTs.filter((p) => core_1.Utils.isString(p));
+                /* istanbul ignore next */
+                const will = config.get("tsNode") ? "will" : "could";
+                CLIHelper_1.CLIHelper.dump(` - ${will} use \`entitiesTs\` array (contains ${refs.length} references and ${paths.length} paths)`);
+                /* istanbul ignore else */
+                if (paths.length > 0) {
+                    await DebugCommand.checkPaths(paths, "red", config.get("baseDir"));
+                }
+            }
+        }
+        catch (e) {
+            CLIHelper_1.CLIHelper.dump(`- configuration ${core_1.colors.red("not found")} ${core_1.colors.red(`(${e.message})`)}`);
+        }
+    }
+    static async checkPaths(paths, failedColor, baseDir) {
+        for (let path of paths) {
+            path = core_1.Utils.absolutePath(path, baseDir);
+            path = core_1.Utils.normalizePath(path);
+            const found = await core_1.Utils.pathExists(path);
+            if (found) {
+                CLIHelper_1.CLIHelper.dump(`   - ${path} (${core_1.colors.green("found")})`);
+            }
+            else {
+                CLIHelper_1.CLIHelper.dump(`   - ${path} (${core_1.colors[failedColor]("not found")})`);
+            }
+        }
+    }
+}
+exports.DebugCommand = DebugCommand;

package/commands/GenerateCacheCommand.d.ts

@@ -0,0 +1,15 @@
+import type { ArgumentsCamelCase, Argv, CommandModule } from "yargs";
+type CacheArgs = {
+    ts?: boolean;
+    combined?: string;
+};
+export declare class GenerateCacheCommand<T> implements CommandModule<T, CacheArgs> {
+    command: string;
+    describe: string;
+    builder: (args: Argv<T>) => Argv<CacheArgs>;
+    /**
+     * @inheritDoc
+     */
+    handler(args: ArgumentsCamelCase<CacheArgs>): Promise<void>;
+}
+export {};

package/commands/GenerateCacheCommand.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateCacheCommand = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const CLIHelper_1 = require("../CLIHelper");
+class GenerateCacheCommand {
+    command = "cache:generate";
+    describe = "Generate metadata cache";
+    builder = (args) => {
+        args.option("ts-node", {
+            alias: "ts",
+            type: "boolean",
+            desc: `Use ts-node to generate '.ts' cache`,
+        });
+        args.option("combined", {
+            alias: "c",
+            desc: `Generate production cache into a single JSON file that can be used with the GeneratedCacheAdapter.`,
+        });
+        return args;
+    };
+    /**
+     * @inheritDoc
+     */
+    async handler(args) {
+        const options = args.combined ? { combined: "./metadata.json" } : {};
+        const config = await CLIHelper_1.CLIHelper.getConfiguration(true, {
+            metadataCache: { enabled: true, adapter: core_1.FileCacheAdapter, options },
+        });
+        config.getMetadataCacheAdapter().clear();
+        config.set("logger", CLIHelper_1.CLIHelper.dump.bind(null));
+        config.set("debug", true);
+        const discovery = new core_1.MetadataDiscovery(core_1.MetadataStorage.init(), config.getDriver().getPlatform(), config);
+        await discovery.discover(args.ts ?? false);
+        const combined = args.combined && config.get("metadataCache").combined;
+        CLIHelper_1.CLIHelper.dump(core_1.colors.green(`${combined ? "Combined " : ""}${args.ts ? "TS" : "JS"} metadata cache was successfully generated${combined ? " to " + combined : ""}`));
+    }
+}
+exports.GenerateCacheCommand = GenerateCacheCommand;

package/commands/GenerateEntitiesCommand.d.ts

@@ -0,0 +1,19 @@
+import type { ArgumentsCamelCase, Argv, CommandModule } from 'yargs';
+export type Options = {
+    dump: boolean;
+    save: boolean;
+    path: string;
+    schema: string;
+};
+export declare class GenerateEntitiesCommand<U extends Options = Options> implements CommandModule<unknown, U> {
+    command: string;
+    describe: string;
+    /**
+     * @inheritDoc
+     */
+    builder(args: Argv): Argv<U>;
+    /**
+     * @inheritDoc
+     */
+    handler(args: ArgumentsCamelCase<U>): Promise<void>;
+}

package/commands/GenerateEntitiesCommand.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateEntitiesCommand = void 0;
+const CLIHelper_1 = require("../CLIHelper");
+class GenerateEntitiesCommand {
+    command = 'generate-entities';
+    describe = 'Generate entities based on current database schema';
+    /**
+     * @inheritDoc
+     */
+    builder(args) {
+        args.option('s', {
+            alias: 'save',
+            type: 'boolean',
+            desc: 'Saves entities to directory defined by --path',
+        });
+        args.option('d', {
+            alias: 'dump',
+            type: 'boolean',
+            desc: 'Dumps all entities to console',
+        });
+        args.option('p', {
+            alias: 'path',
+            type: 'string',
+            desc: 'Sets path to directory where to save entities',
+        });
+        args.option('schema', {
+            type: 'string',
+            desc: 'Generates entities only for given schema',
+        });
+        return args;
+    }
+    /**
+     * @inheritDoc
+     */
+    async handler(args) {
+        if (!args.save && !args.dump) {
+            return CLIHelper_1.CLIHelper.showHelp();
+        }
+        const orm = await CLIHelper_1.CLIHelper.getORM(false);
+        const dump = await orm.entityGenerator.generate({
+            save: args.save,
+            path: args.path,
+            schema: args.schema,
+        });
+        if (args.dump) {
+            CLIHelper_1.CLIHelper.dump(dump.join('\n\n'));
+        }
+        await orm.close(true);
+    }
+}
+exports.GenerateEntitiesCommand = GenerateEntitiesCommand;

package/commands/ImportCommand.d.ts

@@ -0,0 +1,9 @@
+import type { ArgumentsCamelCase, CommandModule } from "yargs";
+export declare class ImportCommand implements CommandModule {
+    command: string;
+    describe: string;
+    /**
+     * @inheritDoc
+     */
+    handler(args: ArgumentsCamelCase): Promise<void>;
+}

package/commands/ImportCommand.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportCommand = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const CLIHelper_1 = require("../CLIHelper");
+class ImportCommand {
+    command = "database:import <file>";
+    describe = "Imports the SQL file to the database";
+    /**
+     * @inheritDoc
+     */
+    async handler(args) {
+        const orm = (await CLIHelper_1.CLIHelper.getORM());
+        await orm.em.getConnection().loadFile(args.file);
+        CLIHelper_1.CLIHelper.dump(core_1.colors.green(`File ${args.file} successfully imported`));
+        await orm.close(true);
+    }
+}
+exports.ImportCommand = ImportCommand;

package/commands/MigrationCommandFactory.d.ts

@@ -0,0 +1,48 @@
+import type { ArgumentsCamelCase, Argv, CommandModule } from "yargs";
+export declare class MigrationCommandFactory {
+    static readonly DESCRIPTIONS: {
+        create: string;
+        up: string;
+        down: string;
+        list: string;
+        check: string;
+        pending: string;
+        fresh: string;
+    };
+    static create<U extends Opts = Opts>(command: MigratorMethod): CommandModule<unknown, U> & {
+        builder: (args: Argv) => Argv<U>;
+        handler: (args: ArgumentsCamelCase<U>) => Promise<void>;
+    };
+    static configureMigrationCommand(args: Argv, method: MigratorMethod): Argv<{}>;
+    private static configureUpDownCommand;
+    private static configureCreateCommand;
+    static handleMigrationCommand(args: ArgumentsCamelCase<Opts>, method: MigratorMethod): Promise<void>;
+    private static configureFreshCommand;
+    private static handleUpDownCommand;
+    private static handlePendingCommand;
+    private static handleListCommand;
+    private static handleCreateCommand;
+    private static handleCheckCommand;
+    private static handleFreshCommand;
+    private static getUpDownOptions;
+    private static getUpDownSuccessMessage;
+}
+type MigratorMethod = "create" | "check" | "up" | "down" | "list" | "pending" | "fresh";
+type CliUpDownOptions = {
+    to?: string | number;
+    from?: string | number;
+    only?: string;
+};
+type GenerateOptions = {
+    dump?: boolean;
+    blank?: boolean;
+    initial?: boolean;
+    path?: string;
+    disableFkChecks?: boolean;
+    seed: string;
+    name?: string;
+};
+type Opts = GenerateOptions & CliUpDownOptions & {
+    dropDb?: boolean;
+};
+export {};