@depup/typeorm-extension 3.9.0-depup.0 → 4.0.0-depup.0

package/bin/cli.mjs

@@ -1,273 +1,544 @@
 #!/usr/bin/env node
-import 'reflect-metadata';
-import process$1 from 'node:process';
-import yargs from 'yargs';
-import { hideBin } from 'yargs/helpers';
-import { consola } from 'consola';
-import { resolveFilePath, readTSConfig, adjustFilePath, parseFilePath, buildDataSourceOptions, createDatabase, dropDatabase, isDirectory, buildSeederFileTemplate, setDataSourceOptions, useDataSource, SeederExecutor } from 'typeorm-extension';
-import { getFileNameExtension, removeFileNameExtension } from 'locter';
-import fs from 'node:fs';
-import path from 'node:path';
-import { pascalCase } from 'pascal-case';
-
-class DatabaseCreateCommand {
-    builder(args) {
-        return args.option('preserveFilePaths', {
-            default: false,
-            type: 'boolean',
-            describe: 'This option indicates if file paths should be preserved.'
-        }).option('root', {
-            alias: 'r',
-            default: process.cwd(),
-            describe: 'Root directory of the project.'
-        }).option('tsconfig', {
-            alias: 'tc',
-            default: 'tsconfig.json',
-            describe: 'Name (or relative path incl. name) of the tsconfig file.'
-        }).option('dataSource', {
-            alias: 'd',
-            default: 'data-source',
-            describe: 'Name (or relative path incl. name) of the data-source file.'
-        }).option('synchronize', {
-            alias: 's',
-            default: 'yes',
-            describe: 'Create database schema for all entities.',
-            choices: [
-                'yes',
-                'no'
-            ]
-        }).option('initialDatabase', {
-            describe: 'Specify the initial database to connect to.'
-        });
-    }
-    async handler(raw) {
-        const args = raw;
-        let tsconfig;
-        let sourcePath = resolveFilePath(args.dataSource, args.root);
-        if (!args.preserveFilePaths) {
-            tsconfig = await readTSConfig(resolveFilePath(args.root, args.tsconfig));
-            sourcePath = await adjustFilePath(sourcePath, tsconfig);
-        }
-        const source = parseFilePath(sourcePath);
-        consola.info(`DataSource Directory: ${source.directory}`);
-        consola.info(`DataSource Name: ${source.name}`);
-        const dataSourceOptions = await buildDataSourceOptions({
-            directory: source.directory,
-            dataSourceName: source.name,
-            tsconfig,
-            preserveFilePaths: args.preserveFilePaths
-        });
-        const context = {
-            ifNotExist: true,
-            options: dataSourceOptions,
-            synchronize: args.synchronize === 'yes'
-        };
-        if (typeof args.initialDatabase === 'string' && args.initialDatabase !== '') {
-            context.initialDatabase = args.initialDatabase;
-        }
-        try {
-            await createDatabase(context);
-            consola.success('Created database.');
-            process.exit(0);
-        } catch (e) {
-            consola.warn('Failed to create database.');
-            consola.error(e);
-            process.exit(1);
-        }
-    }
-    constructor(){
-        this.command = 'db:create';
-        this.describe = 'Create database.';
-    }
+import "reflect-metadata";
+import { defineCommand, runMain } from "citty";
+import process from "node:process";
+import { PathResolverMode, SeederExecutor, buildDataSourceOptions, buildSeederFileName, buildSeederFileTemplate, createDatabase, createPathResolver, dropDatabase, getSchemaDrift, isDirectory, parseFilePath, setDataSourceOptions, useDataSource } from "typeorm-extension";
+import { removeFileNameExtension } from "locter";
+import fs from "node:fs";
+import path from "node:path";
+import { pascalCase } from "pascal-case";
+//#region src/cli/logger.ts
+const LogLevel = {
+	Silent: "silent",
+	Info: "info",
+	Debug: "debug"
+};
+const LOG_LEVEL_VALUES = Object.values(LogLevel);
+const RANK = {
+	[LogLevel.Silent]: 0,
+	[LogLevel.Info]: 1,
+	[LogLevel.Debug]: 2
+};
+const RESET = "\x1B[0m";
+const BOLD = "\x1B[1m";
+const DIM = "\x1B[2m";
+const RED = "\x1B[31m";
+const GREEN = "\x1B[32m";
+const YELLOW = "\x1B[33m";
+const BLUE = "\x1B[34m";
+const CYAN = "\x1B[36m";
+const ICON_INFO = "ℹ";
+const ICON_SUCCESS = "✔";
+const ICON_WARN = "⚠";
+const ICON_ERROR = "✖";
+const ICON_DEBUG = "›";
+function createLogger(level = LogLevel.Info) {
+	const enabled = (target) => RANK[level] >= RANK[target];
+	const tty = process.stderr.isTTY;
+	const tint = (code, text) => tty ? `${code}${text}${RESET}` : text;
+	const write = (line) => process.stderr.write(`${line}\n`);
+	return {
+		info: (msg) => {
+			if (enabled(LogLevel.Info)) write(`${tint(CYAN, ICON_INFO)} ${msg}`);
+		},
+		success: (msg) => {
+			if (enabled(LogLevel.Info)) write(`${tint(GREEN, ICON_SUCCESS)} ${msg}`);
+		},
+		warn: (msg) => {
+			if (enabled(LogLevel.Info)) write(`${tint(YELLOW, ICON_WARN)} ${msg}`);
+		},
+		error: (msg) => {
+			write(`${tint(RED, ICON_ERROR)} ${msg}`);
+		},
+		debug: (msg) => {
+			if (enabled(LogLevel.Debug)) write(`${tint(DIM, `${ICON_DEBUG} ${msg}`)}`);
+		},
+		section: (title) => {
+			if (enabled(LogLevel.Info)) {
+				write("");
+				write(tint(`${BOLD}${BLUE}`, title));
+			}
+		},
+		kv: (key, value, padTo = 0) => {
+			if (enabled(LogLevel.Info)) {
+				const pad = " ".repeat(Math.max(0, padTo - key.length));
+				write(`  ${tint(DIM, key)}${pad}  ${value}`);
+			}
+		},
+		blank: () => {
+			if (enabled(LogLevel.Info)) write("");
+		}
+	};
 }
-
-class DatabaseDropCommand {
-    builder(args) {
-        return args.option('preserveFilePaths', {
-            default: false,
-            type: 'boolean',
-            describe: 'This option indicates if file paths should be preserved.'
-        }).option('root', {
-            alias: 'r',
-            default: process.cwd(),
-            describe: 'Root directory of the project.'
-        }).option('tsconfig', {
-            alias: 'tc',
-            default: 'tsconfig.json',
-            describe: 'Name (or relative path incl. name) of the tsconfig file.'
-        }).option('dataSource', {
-            alias: 'd',
-            default: 'data-source',
-            describe: 'Name (or relative path incl. name) of the data-source file.'
-        }).option('initialDatabase', {
-            describe: 'Specify the initial database to connect to.'
-        });
-    }
-    async handler(raw) {
-        const args = raw;
-        let tsconfig;
-        let sourcePath = resolveFilePath(args.dataSource, args.root);
-        if (!args.preserveFilePaths) {
-            tsconfig = await readTSConfig(resolveFilePath(args.root, args.tsconfig));
-            sourcePath = await adjustFilePath(sourcePath, tsconfig);
-        }
-        const source = parseFilePath(sourcePath);
-        consola.info(`DataSource Directory: ${source.directory}`);
-        consola.info(`DataSource Name: ${source.name}`);
-        const dataSourceOptions = await buildDataSourceOptions({
-            directory: source.directory,
-            dataSourceName: source.name,
-            tsconfig,
-            preserveFilePaths: args.preserveFilePaths
-        });
-        const context = {
-            ifExist: true,
-            options: dataSourceOptions
-        };
-        if (typeof args.initialDatabase === 'string' && args.initialDatabase !== '') {
-            context.initialDatabase = args.initialDatabase;
-        }
-        try {
-            await dropDatabase(context);
-            consola.success('Dropped database.');
-            process.exit(0);
-        } catch (e) {
-            consola.warn('Failed to drop database.');
-            consola.error(e);
-            process.exit(1);
-        }
-    }
-    constructor(){
-        this.command = 'db:drop';
-        this.describe = 'Drop database.';
-    }
+function normalizeLogLevel(input) {
+	if (!input) return LogLevel.Info;
+	if (LOG_LEVEL_VALUES.includes(input)) return input;
+	throw new CLIUserError(`Unknown log level "${input}". Supported: ${LOG_LEVEL_VALUES.join(", ")}.`);
 }
-
-class SeedCreateCommand {
-    builder(args) {
-        return args.option('root', {
-            alias: 'r',
-            default: process.cwd(),
-            describe: 'Root directory of the project.'
-        }).option('timestamp', {
-            alias: 't',
-            type: 'number',
-            describe: 'Custom timestamp for the seeder name.'
-        }).option('javascript', {
-            alias: 'j',
-            type: 'boolean',
-            default: false,
-            describe: 'Generate a seeder file for JavaScript instead of TypeScript.'
-        }).option('name', {
-            alias: 'n',
-            describe: 'Name (or relative path incl. name) of the seeder.',
-            demandOption: true
-        });
-    }
-    async handler(raw) {
-        const args = raw;
-        let timestamp;
-        if (Number.isNaN(args.timestamp) || !args.timestamp) {
-            timestamp = Date.now();
-        } else {
-            timestamp = args.timestamp;
-        }
-        const sourcePath = parseFilePath(args.name, args.root);
-        const dirNameIsDirectory = await isDirectory(sourcePath.directory);
-        if (!dirNameIsDirectory) {
-            consola.warn(`The output directory ${sourcePath.directory} does not exist.`);
-            process.exit(1);
-        }
-        const extension = args.javascript ? '.js' : '.ts';
-        const nameExtension = getFileNameExtension(sourcePath.name);
-        const nameWithoutExtension = removeFileNameExtension(sourcePath.name);
-        let fileName;
-        if (nameExtension) {
-            fileName = `${timestamp}-${sourcePath.name}`;
-        } else {
-            fileName = `${timestamp}-${sourcePath.name}${extension}`;
-        }
-        const filePath = sourcePath.directory + path.sep + fileName;
-        const template = buildSeederFileTemplate(nameWithoutExtension, timestamp);
-        consola.info(`Seed Directory: ${sourcePath.directory}`);
-        consola.info(`Seed FileName: ${fileName}`);
-        consola.info(`Seed Name: ${pascalCase(nameWithoutExtension)}`);
-        try {
-            await fs.promises.writeFile(filePath, template, {
-                encoding: 'utf-8'
-            });
-        } catch (e) {
-            consola.warn(`The seed could not be written to the path ${filePath}.`);
-            process.exit(1);
-        }
-        process.exit(0);
-    }
-    constructor(){
-        this.command = 'seed:create';
-        this.describe = 'Create a seeder file.';
-    }
+var CLIUserError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CLIUserError";
+	}
+};
+//#endregion
+//#region src/cli/exit.ts
+const ExitCode = {
+	Success: 0,
+	UserError: 1,
+	InternalError: 2
+};
+async function runWithExitCode(logger, fn) {
+	try {
+		await fn();
+		process.exit(ExitCode.Success);
+	} catch (err) {
+		if (err instanceof CLIUserError) {
+			logger.error(err.message);
+			process.exit(ExitCode.UserError);
+		}
+		if (err instanceof Error) logger.error(err.stack ?? err.message);
+		else logger.error(String(err));
+		process.exit(ExitCode.InternalError);
+	}
 }
-
-class SeedRunCommand {
-    builder(args) {
-        return args.option('preserveFilePaths', {
-            default: false,
-            type: 'boolean',
-            describe: 'This option indicates if file paths should be preserved.'
-        }).option('root', {
-            alias: 'r',
-            default: process.cwd(),
-            describe: 'Root directory of the project.'
-        }).option('tsconfig', {
-            alias: 'tc',
-            default: 'tsconfig.json',
-            describe: 'Name (or relative path incl. name) of the tsconfig file.'
-        }).option('dataSource', {
-            alias: 'd',
-            default: 'data-source',
-            describe: 'Name (or relative path incl. name) of the data-source file.'
-        }).option('name', {
-            alias: 'n',
-            describe: 'Name (or relative path incl. name) of the seeder.'
-        });
-    }
-    async handler(raw) {
-        const args = raw;
-        let tsconfig;
-        let sourcePath = resolveFilePath(args.dataSource, args.root);
-        if (!args.preserveFilePaths) {
-            tsconfig = await readTSConfig(args.root);
-            sourcePath = await adjustFilePath(sourcePath, tsconfig);
-            args.name = await adjustFilePath(args.name, tsconfig);
-        }
-        const source = parseFilePath(sourcePath);
-        consola.info(`DataSource Directory: ${source.directory}`);
-        consola.info(`DataSource Name: ${source.name}`);
-        const dataSourceOptions = await buildDataSourceOptions({
-            dataSourceName: source.name,
-            directory: source.directory,
-            tsconfig,
-            preserveFilePaths: args.preserveFilePaths
-        });
-        setDataSourceOptions(dataSourceOptions);
-        if (args.name) {
-            consola.info(`Seed Name: ${args.name}`);
-        }
-        const dataSource = await useDataSource();
-        const executor = new SeederExecutor(dataSource, {
-            root: args.root,
-            tsconfig,
-            preserveFilePaths: args.preserveFilePaths
-        });
-        await executor.execute({
-            seedName: args.name
-        });
-        process.exit(0);
-    }
-    constructor(){
-        this.command = 'seed:run';
-        this.describe = 'Populate the database with an initial data set or generated data by a factory.';
-    }
+//#endregion
+//#region src/cli/commands/database/create.ts
+function defineCLIDatabaseCreateCommand() {
+	return defineCommand({
+		meta: {
+			name: "create",
+			description: "Create database."
+		},
+		args: {
+			preserveFilePaths: {
+				type: "boolean",
+				default: false,
+				description: "This option indicates if file paths should be preserved."
+			},
+			root: {
+				type: "string",
+				alias: "r",
+				default: process.cwd(),
+				description: "Root directory of the project."
+			},
+			tsconfig: {
+				type: "string",
+				alias: "tc",
+				default: "tsconfig.json",
+				description: "Name (or relative path incl. name) of the tsconfig file."
+			},
+			dataSource: {
+				type: "string",
+				alias: "d",
+				default: "data-source",
+				description: "Name (or relative path incl. name) of the data-source file."
+			},
+			synchronize: {
+				type: "enum",
+				alias: "s",
+				default: "yes",
+				options: ["yes", "no"],
+				description: "Create database schema for all entities."
+			},
+			initialDatabase: {
+				type: "string",
+				description: "Specify the initial database to connect to."
+			},
+			"log-level": {
+				type: "string",
+				description: "Logger verbosity.",
+				valueHint: LOG_LEVEL_VALUES.join("|"),
+				options: LOG_LEVEL_VALUES
+			}
+		},
+		async run({ args }) {
+			const logger = createLogger(normalizeLogLevel(args["log-level"]));
+			await runWithExitCode(logger, async () => {
+				logger.info("Creating database");
+				const pathResolver = createPathResolver({
+					root: args.root,
+					tsconfig: args.tsconfig,
+					mode: args.preserveFilePaths ? PathResolverMode.PRESERVE : PathResolverMode.AUTO
+				});
+				const source = parseFilePath(await pathResolver.resolve(args.dataSource));
+				logger.section("DataSource");
+				const pad = 9;
+				logger.kv("directory", source.directory, pad);
+				logger.kv("name", source.name, pad);
+				const context = {
+					ifNotExist: true,
+					options: await buildDataSourceOptions({
+						directory: source.directory,
+						dataSourceName: source.name,
+						tsconfig: await pathResolver.tsconfig(),
+						preserveFilePaths: args.preserveFilePaths
+					}),
+					synchronize: args.synchronize === "yes"
+				};
+				if (typeof args.initialDatabase === "string" && args.initialDatabase !== "") context.initialDatabase = args.initialDatabase;
+				logger.blank();
+				await createDatabase(context);
+				logger.success("Created database.");
+			});
+		}
+	});
+}
+//#endregion
+//#region src/cli/commands/database/drift.ts
+function defineCLIDatabaseDriftCommand() {
+	return defineCommand({
+		meta: {
+			name: "drift",
+			description: "Assert that the database schema matches the entity metadata."
+		},
+		args: {
+			preserveFilePaths: {
+				type: "boolean",
+				default: false,
+				description: "This option indicates if file paths should be preserved."
+			},
+			root: {
+				type: "string",
+				alias: "r",
+				default: process.cwd(),
+				description: "Root directory of the project."
+			},
+			tsconfig: {
+				type: "string",
+				alias: "tc",
+				default: "tsconfig.json",
+				description: "Name (or relative path incl. name) of the tsconfig file."
+			},
+			dataSource: {
+				type: "string",
+				alias: "d",
+				default: "data-source",
+				description: "Name (or relative path incl. name) of the data-source file."
+			},
+			skipWithoutMigrations: {
+				type: "boolean",
+				default: false,
+				description: "Report no drift if the data-source has no migrations registered."
+			},
+			"log-level": {
+				type: "string",
+				description: "Logger verbosity.",
+				valueHint: LOG_LEVEL_VALUES.join("|"),
+				options: LOG_LEVEL_VALUES
+			}
+		},
+		async run({ args }) {
+			const logger = createLogger(normalizeLogLevel(args["log-level"]));
+			await runWithExitCode(logger, async () => {
+				logger.info("Checking schema drift");
+				const pathResolver = createPathResolver({
+					root: args.root,
+					tsconfig: args.tsconfig,
+					mode: args.preserveFilePaths ? PathResolverMode.PRESERVE : PathResolverMode.AUTO
+				});
+				const source = parseFilePath(await pathResolver.resolve(args.dataSource));
+				logger.section("DataSource");
+				const pad = 9;
+				logger.kv("directory", source.directory, pad);
+				logger.kv("name", source.name, pad);
+				const dataSourceOptions = await buildDataSourceOptions({
+					directory: source.directory,
+					dataSourceName: source.name,
+					tsconfig: await pathResolver.tsconfig(),
+					preserveFilePaths: args.preserveFilePaths
+				});
+				logger.blank();
+				const drift = await getSchemaDrift(dataSourceOptions, { skipWithoutMigrations: args.skipWithoutMigrations });
+				if (!drift.exists) {
+					logger.success("No schema drift detected.");
+					return;
+				}
+				logger.section("Statements");
+				for (let i = 0; i < drift.up.length; i++) {
+					const statement = drift.up[i];
+					logger.warn(statement.parameters && statement.parameters.length > 0 ? `${statement.query} -- ${JSON.stringify(statement.parameters)}` : statement.query);
+				}
+				logger.blank();
+				throw new CLIUserError(`The database schema deviates from the entity metadata (${drift.up.length} statement(s) required to reconcile it).`);
+			});
+		}
+	});
+}
+//#endregion
+//#region src/cli/commands/database/drop.ts
+function defineCLIDatabaseDropCommand() {
+	return defineCommand({
+		meta: {
+			name: "drop",
+			description: "Drop database."
+		},
+		args: {
+			preserveFilePaths: {
+				type: "boolean",
+				default: false,
+				description: "This option indicates if file paths should be preserved."
+			},
+			root: {
+				type: "string",
+				alias: "r",
+				default: process.cwd(),
+				description: "Root directory of the project."
+			},
+			tsconfig: {
+				type: "string",
+				alias: "tc",
+				default: "tsconfig.json",
+				description: "Name (or relative path incl. name) of the tsconfig file."
+			},
+			dataSource: {
+				type: "string",
+				alias: "d",
+				default: "data-source",
+				description: "Name (or relative path incl. name) of the data-source file."
+			},
+			initialDatabase: {
+				type: "string",
+				description: "Specify the initial database to connect to."
+			},
+			"log-level": {
+				type: "string",
+				description: "Logger verbosity.",
+				valueHint: LOG_LEVEL_VALUES.join("|"),
+				options: LOG_LEVEL_VALUES
+			}
+		},
+		async run({ args }) {
+			const logger = createLogger(normalizeLogLevel(args["log-level"]));
+			await runWithExitCode(logger, async () => {
+				logger.info("Dropping database");
+				const pathResolver = createPathResolver({
+					root: args.root,
+					tsconfig: args.tsconfig,
+					mode: args.preserveFilePaths ? PathResolverMode.PRESERVE : PathResolverMode.AUTO
+				});
+				const source = parseFilePath(await pathResolver.resolve(args.dataSource));
+				logger.section("DataSource");
+				const pad = 9;
+				logger.kv("directory", source.directory, pad);
+				logger.kv("name", source.name, pad);
+				const context = {
+					ifExist: true,
+					options: await buildDataSourceOptions({
+						directory: source.directory,
+						dataSourceName: source.name,
+						tsconfig: await pathResolver.tsconfig(),
+						preserveFilePaths: args.preserveFilePaths
+					})
+				};
+				if (typeof args.initialDatabase === "string" && args.initialDatabase !== "") context.initialDatabase = args.initialDatabase;
+				logger.blank();
+				await dropDatabase(context);
+				logger.success("Dropped database.");
+			});
+		}
+	});
+}
+//#endregion
+//#region src/cli/commands/database/index.ts
+function defineCLIDatabaseCommand() {
+	return defineCommand({
+		meta: {
+			name: "db",
+			description: "Database operations."
+		},
+		subCommands: {
+			create: defineCLIDatabaseCreateCommand(),
+			drift: defineCLIDatabaseDriftCommand(),
+			drop: defineCLIDatabaseDropCommand()
+		}
+	});
+}
+//#endregion
+//#region src/cli/commands/seed/create.ts
+function defineCLISeedCreateCommand() {
+	return defineCommand({
+		meta: {
+			name: "create",
+			description: "Create a seeder file."
+		},
+		args: {
+			root: {
+				type: "string",
+				alias: "r",
+				default: process.cwd(),
+				description: "Root directory of the project."
+			},
+			timestamp: {
+				type: "string",
+				alias: "t",
+				description: "Custom timestamp for the seeder name."
+			},
+			javascript: {
+				type: "boolean",
+				alias: "j",
+				default: false,
+				description: "Generate a seeder file for JavaScript instead of TypeScript."
+			},
+			name: {
+				type: "string",
+				alias: "n",
+				required: true,
+				description: "Name (or relative path incl. name) of the seeder."
+			},
+			"log-level": {
+				type: "string",
+				description: "Logger verbosity.",
+				valueHint: LOG_LEVEL_VALUES.join("|"),
+				options: LOG_LEVEL_VALUES
+			}
+		},
+		async run({ args }) {
+			const logger = createLogger(normalizeLogLevel(args["log-level"]));
+			await runWithExitCode(logger, async () => {
+				logger.info("Creating seeder file");
+				const parsedTimestamp = typeof args.timestamp === "string" ? Number.parseInt(args.timestamp, 10) : NaN;
+				const timestamp = Number.isNaN(parsedTimestamp) ? Date.now() : parsedTimestamp;
+				const sourcePath = parseFilePath(args.name, args.root);
+				if (!await isDirectory(sourcePath.directory)) throw new CLIUserError(`The output directory ${sourcePath.directory} does not exist.`);
+				const nameWithoutExtension = removeFileNameExtension(sourcePath.name);
+				const fileName = buildSeederFileName(sourcePath.name, timestamp, { javascript: args.javascript });
+				const filePath = path.join(sourcePath.directory, fileName);
+				const template = buildSeederFileTemplate(nameWithoutExtension, timestamp);
+				logger.section("Seed");
+				const pad = 9;
+				logger.kv("directory", sourcePath.directory, pad);
+				logger.kv("fileName", fileName, pad);
+				logger.kv("name", pascalCase(nameWithoutExtension), pad);
+				try {
+					await fs.promises.writeFile(filePath, template, { encoding: "utf-8" });
+				} catch {
+					throw new CLIUserError(`The seed could not be written to the path ${filePath}.`);
+				}
+				logger.blank();
+				logger.success("Created seeder file.");
+			});
+		}
+	});
+}
+//#endregion
+//#region src/cli/commands/seed/run.ts
+function defineCLISeedRunCommand() {
+	return defineCommand({
+		meta: {
+			name: "run",
+			description: "Populate the database with an initial data set or generated data by a factory."
+		},
+		args: {
+			preserveFilePaths: {
+				type: "boolean",
+				default: false,
+				description: "This option indicates if file paths should be preserved."
+			},
+			root: {
+				type: "string",
+				alias: "r",
+				default: process.cwd(),
+				description: "Root directory of the project."
+			},
+			tsconfig: {
+				type: "string",
+				alias: "tc",
+				default: "tsconfig.json",
+				description: "Name (or relative path incl. name) of the tsconfig file."
+			},
+			dataSource: {
+				type: "string",
+				alias: "d",
+				default: "data-source",
+				description: "Name (or relative path incl. name) of the data-source file."
+			},
+			name: {
+				type: "string",
+				alias: "n",
+				description: "Name (or relative path incl. name) of the seeder."
+			},
+			"log-level": {
+				type: "string",
+				description: "Logger verbosity.",
+				valueHint: LOG_LEVEL_VALUES.join("|"),
+				options: LOG_LEVEL_VALUES
+			}
+		},
+		async run({ args }) {
+			const logger = createLogger(normalizeLogLevel(args["log-level"]));
+			await runWithExitCode(logger, async () => {
+				logger.info("Running seeders");
+				const pathResolver = createPathResolver({
+					root: args.root,
+					tsconfig: args.tsconfig,
+					mode: args.preserveFilePaths ? PathResolverMode.PRESERVE : PathResolverMode.AUTO
+				});
+				let { name } = args;
+				if (name) name = await pathResolver.transform(name);
+				const source = parseFilePath(await pathResolver.resolve(args.dataSource));
+				logger.section("DataSource");
+				const dsPad = 9;
+				logger.kv("directory", source.directory, dsPad);
+				logger.kv("name", source.name, dsPad);
+				setDataSourceOptions(await buildDataSourceOptions({
+					dataSourceName: source.name,
+					directory: source.directory,
+					tsconfig: await pathResolver.tsconfig(),
+					preserveFilePaths: args.preserveFilePaths
+				}));
+				if (name) {
+					logger.section("Seed");
+					logger.kv("name", name, 4);
+				}
+				const executor = new SeederExecutor(await useDataSource(), {
+					root: args.root,
+					tsconfig: await pathResolver.tsconfig(),
+					preserveFilePaths: args.preserveFilePaths
+				});
+				logger.blank();
+				await executor.execute({ seedName: name });
+				logger.success("Executed seeders.");
+			});
+		}
+	});
+}
+//#endregion
+//#region src/cli/commands/seed/index.ts
+function defineCLISeedCommand() {
+	return defineCommand({
+		meta: {
+			name: "seed",
+			description: "Seeder operations."
+		},
+		subCommands: {
+			create: defineCLISeedCreateCommand(),
+			run: defineCLISeedRunCommand()
+		}
+	});
+}
+//#endregion
+//#region src/cli/module.ts
+function createCLIEntryPointCommand() {
+	return defineCommand({
+		meta: {
+			name: "typeorm-extension",
+			description: "CLI for typeorm-extension."
+		},
+		subCommands: {
+			db: defineCLIDatabaseCommand(),
+			seed: defineCLISeedCommand(),
+			"db:create": defineCLIDatabaseCreateCommand(),
+			"db:drop": defineCLIDatabaseDropCommand(),
+			"seed:create": defineCLISeedCreateCommand(),
+			"seed:run": defineCLISeedRunCommand()
+		}
+	});
 }
+//#endregion
+//#region src/cli/index.ts
+runMain(createCLIEntryPointCommand());
+//#endregion
+export {};
 
-yargs(hideBin(process$1.argv)).scriptName('typeorm-extension').usage('Usage: $0 <command> [options]').demandCommand(1).command(new DatabaseCreateCommand()).command(new DatabaseDropCommand()).command(new SeedRunCommand()).command(new SeedCreateCommand()).strict().alias('v', 'version').help('h').alias('h', 'help').parse();
+//# sourceMappingURL=cli.mjs.map