@ackplus/nest-seeder 1.1.17 → 2.0.0

package/dist/cli.js

@@ -1,256 +1,616 @@
 #!/usr/bin/env node
-"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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.seeder = void 0;
-const seeder_module_1 = require("./lib/seeder/seeder.module");
-const yargs_1 = __importDefault(require("yargs"));
-const core_1 = require("@nestjs/core");
-const seeder_service_1 = require("./lib/seeder/seeder.service");
-const path = __importStar(require("path"));
-const fs = __importStar(require("fs"));
-async function parseArguments() {
-    const argv = await (0, yargs_1.default)(process.argv.slice(2))
-        .option('refresh', {
-        alias: 'r',
-        type: 'boolean',
-        description: 'Drop all data before seeding',
-        default: false
-    })
-        .option('name', {
-        alias: 'n',
-        type: 'array',
-        string: true,
-        description: 'Specific seeder names to run',
-    })
-        .option('dummyData', {
-        alias: 'd',
-        type: 'boolean',
-        description: 'Include dummy data',
-        default: false
-    })
-        .option('config', {
-        alias: 'c',
-        type: 'string',
-        description: 'Path to seeder configuration file',
-        demandOption: true
-    })
-        .help()
-        .example('nest-seed -c ./seeder.config.ts', 'Run all seeders')
-        .example('nest-seed -c ./seeder.config.ts --refresh', 'Drop and reseed all data')
-        .example('nest-seed -c ./seeder.config.ts --name UserSeeder', 'Run specific seeder')
-        .parseAsync();
-    return {
-        refresh: argv.refresh,
-        name: argv.name,
-        dummyData: argv.dummyData,
-        config: argv.config,
-    };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/cli.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var import_core = require("@nestjs/core");
+var import_yargs = __toESM(require("yargs"));
+var import_helpers = require("yargs/helpers");
+
+// src/lib/decorators/seeder.decorator.ts
+var SEEDER_NAME = /* @__PURE__ */ Symbol.for("nest-seeder:name");
+function getSeederName(seeder) {
+  const ctor = typeof seeder === "function" ? seeder : seeder?.constructor;
+  return ctor?.[SEEDER_NAME] || ctor?.seederName || ctor?.name || "UnknownSeeder";
 }
-function setupTsNode(force = false) {
-    if (!force && require.extensions['.ts']) {
-        return;
+
+// src/lib/cli/load-config.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var DEFAULT_CONFIG_NAMES = [
+  "seeder.config.ts",
+  "seeder.config.js",
+  "seeder.config.cjs",
+  "seeder.config.mjs"
+];
+function resolveConfigPath(configPath) {
+  if (configPath) {
+    const resolved = path.resolve(process.cwd(), configPath);
+    return fs.existsSync(resolved) ? resolved : null;
+  }
+  for (const name of DEFAULT_CONFIG_NAMES) {
+    const candidate = path.resolve(process.cwd(), name);
+    if (fs.existsSync(candidate)) {
+      return candidate;
     }
-    try {
-        const tsNodePath = require.resolve('ts-node', {
-            paths: [process.cwd(), __dirname]
-        });
-        const tsNode = require(tsNodePath);
-        tsNode.register({
-            transpileOnly: true,
-            skipProject: true,
-            compilerOptions: {
-                module: 'commonjs',
-                moduleResolution: 'node',
-                experimentalDecorators: true,
-                emitDecoratorMetadata: true,
-                esModuleInterop: true,
-                allowSyntheticDefaultImports: true,
-                skipLibCheck: true,
-                target: 'ES2020',
-                resolveJsonModule: true,
-                strict: false,
-            }
-        });
+  }
+  return null;
+}
+var tsNodeRegistered = false;
+function setupTsNode() {
+  if (tsNodeRegistered || require.extensions[".ts"]) {
+    tsNodeRegistered = true;
+    return;
+  }
+  let tsNodePath;
+  try {
+    tsNodePath = require.resolve("ts-node", {
+      paths: [process.cwd(), __dirname]
+    });
+  } catch {
+    throw new Error(
+      'TypeScript config files require "ts-node" and "typescript" to be installed.\n  Install them with:  npm install -D ts-node typescript\n  Or use a JavaScript config file (seeder.config.js).'
+    );
+  }
+  const tsNode = require(tsNodePath);
+  tsNode.register({
+    transpileOnly: true,
+    skipProject: true,
+    compilerOptions: {
+      module: "commonjs",
+      moduleResolution: "node",
+      experimentalDecorators: true,
+      emitDecoratorMetadata: true,
+      esModuleInterop: true,
+      allowSyntheticDefaultImports: true,
+      skipLibCheck: true,
+      target: "ES2021",
+      resolveJsonModule: true,
+      strict: false
     }
-    catch (error) {
-        if (!force) {
-            console.error('\n❌ TypeScript configuration files require ts-node to be installed.');
-            console.error('\nPlease install ts-node and typescript as dev dependencies:');
-            console.error('   npm install -D ts-node typescript');
-            console.error('   # or');
-            console.error('   pnpm add -D ts-node typescript');
-            console.error('\nAlternatively, you can use a JavaScript config file (.js extension).\n');
-            process.exit(1);
-        }
+  });
+  tsNodeRegistered = true;
+}
+async function loadSeederConfig(absolutePath) {
+  const ext = path.extname(absolutePath);
+  if (ext === ".ts") {
+    setupTsNode();
+  }
+  let configModule;
+  try {
+    if (ext === ".mjs") {
+      configModule = await import(absolutePath);
+    } else {
+      delete require.cache[absolutePath];
+      configModule = require(absolutePath);
     }
+  } catch (error) {
+    if (ext === ".ts" && (error?.code === "ERR_REQUIRE_ESM" || error?.code === "ERR_UNKNOWN_FILE_EXTENSION")) {
+      configModule = await import(absolutePath);
+    } else {
+      throw error;
+    }
+  }
+  const config = configModule?.default ?? configModule;
+  if (!config || typeof config !== "object") {
+    throw new Error(
+      "The config file must export a configuration object as its default export."
+    );
+  }
+  return config;
+}
+
+// src/lib/cli/templates.ts
+var FACTORY = `import { Factory } from '@ackplus/nest-seeder';
+
+export class UserFactory {
+  @Factory((faker) => faker.person.firstName())
+  firstName: string;
+
+  @Factory((faker) => faker.person.lastName())
+  lastName: string;
+
+  @Factory((faker, ctx) => faker.internet.email({ firstName: ctx.firstName, lastName: ctx.lastName }).toLowerCase(), ['firstName', 'lastName'])
+  email: string;
+
+  @Factory((faker) => faker.helpers.arrayElement(['admin', 'user', 'guest']))
+  role: string;
+}
+`;
+var SEEDER_TYPEORM = `import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { Seeder, SeederName, DataFactory } from '@ackplus/nest-seeder';
+
+import { User } from '../entities/user.entity';
+import { UserFactory } from '../factories/user.factory';
+
+@Injectable()
+@SeederName('users')
+export class UserSeeder implements Seeder {
+  constructor(
+    @InjectRepository(User)
+    private readonly userRepository: Repository<User>,
+  ) {}
+
+  async seed(): Promise<void> {
+    const factory = DataFactory.createForClass(UserFactory);
+    const users = factory.generate(10);
+    await this.userRepository.save(users);
+  }
+
+  async drop(): Promise<void> {
+    await this.userRepository.delete({});
+  }
 }
-async function loadSeederConfig(configPath) {
-    const resolvedPath = path.resolve(process.cwd(), configPath);
-    if (!fs.existsSync(resolvedPath)) {
-        console.error(`Configuration file not found: ${resolvedPath}`);
-        process.exit(1);
+`;
+var SEEDER_MONGOOSE = `import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { Seeder, SeederName, DataFactory } from '@ackplus/nest-seeder';
+
+import { User } from '../schemas/user.schema';
+import { UserFactory } from '../factories/user.factory';
+
+@Injectable()
+@SeederName('users')
+export class UserSeeder implements Seeder {
+  constructor(
+    @InjectModel(User.name)
+    private readonly userModel: Model<User>,
+  ) {}
+
+  async seed(): Promise<void> {
+    const factory = DataFactory.createForClass(UserFactory);
+    const users = factory.generate(10);
+    await this.userModel.insertMany(users);
+  }
+
+  async drop(): Promise<void> {
+    await this.userModel.deleteMany({});
+  }
+}
+`;
+var CONFIG_TYPEORM = `import { TypeOrmModule } from '@nestjs/typeorm';
+import { defineSeederConfig } from '@ackplus/nest-seeder';
+
+import { User } from './src/database/entities/user.entity';
+import { UserSeeder } from './src/database/seeders/user.seeder';
+
+export default defineSeederConfig({
+  imports: [
+    TypeOrmModule.forRoot({
+      type: 'postgres',
+      host: process.env.DB_HOST ?? 'localhost',
+      port: Number(process.env.DB_PORT ?? 5432),
+      username: process.env.DB_USERNAME ?? 'postgres',
+      password: process.env.DB_PASSWORD ?? 'postgres',
+      database: process.env.DB_DATABASE ?? 'app',
+      entities: [User],
+      synchronize: true,
+    }),
+    TypeOrmModule.forFeature([User]),
+  ],
+  seeders: [UserSeeder],
+});
+`;
+var CONFIG_MONGOOSE = `import { MongooseModule } from '@nestjs/mongoose';
+import { defineSeederConfig } from '@ackplus/nest-seeder';
+
+import { User, UserSchema } from './src/database/schemas/user.schema';
+import { UserSeeder } from './src/database/seeders/user.seeder';
+
+export default defineSeederConfig({
+  imports: [
+    MongooseModule.forRoot(process.env.MONGO_URI ?? 'mongodb://localhost/app'),
+    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+  ],
+  seeders: [UserSeeder],
+});
+`;
+function scaffoldFiles(orm) {
+  return [
+    { path: "seeder.config.ts", contents: orm === "mongoose" ? CONFIG_MONGOOSE : CONFIG_TYPEORM },
+    { path: "src/database/factories/user.factory.ts", contents: FACTORY },
+    {
+      path: "src/database/seeders/user.seeder.ts",
+      contents: orm === "mongoose" ? SEEDER_MONGOOSE : SEEDER_TYPEORM
     }
-    if (configPath.endsWith('.ts')) {
-        setupTsNode();
+  ];
+}
+
+// src/lib/seeder/seeder.module.ts
+var import_common2 = require("@nestjs/common");
+
+// src/lib/seeder/seeder.service.ts
+var import_common = require("@nestjs/common");
+var SeederService = class {
+  constructor(seeders = [], options = {}) {
+    this.seeders = seeders;
+    this.options = options;
+  }
+  seeders;
+  options;
+  logger = new import_common.Logger("Seeder");
+  /**
+   * Runs the configured seeders. In `refresh` mode every selected seeder is
+   * dropped first (in reverse order to respect foreign-key dependencies),
+   * then all are seeded.
+   */
+  async run() {
+    const seeders = this.getSeedersToRun();
+    if (seeders.length === 0) {
+      this.logger.warn("No seeders to run.");
+      return;
     }
-    const tryLoad = async (useImport = false) => {
-        if (!useImport) {
-            delete require.cache[resolvedPath];
-        }
-        let configModule;
-        if (!useImport && (configPath.endsWith('.ts') || configPath.endsWith('.js'))) {
-            configModule = require(resolvedPath);
-        }
-        else {
-            configModule = await import(resolvedPath);
-        }
-        return configModule;
-    };
-    try {
-        let configModule;
-        try {
-            configModule = await tryLoad(false);
-        }
-        catch (error) {
-            if (configPath.endsWith('.ts') && (error.code === 'ERR_UNKNOWN_FILE_EXTENSION' ||
-                error.code === 'ERR_REQUIRE_ESM' ||
-                error.message.includes('Unknown file extension') ||
-                error.message.includes('must use import to load ES Module'))) {
-                setupTsNode(true);
-                try {
-                    configModule = await tryLoad(true);
-                }
-                catch (importError) {
-                    if (importError.code === 'ERR_UNKNOWN_FILE_EXTENSION') {
-                        console.error('\n❌ To load ESM TypeScript files, you must use the ts-node loader.');
-                        console.error('Please run with: node --loader ts-node/esm ...\n');
-                    }
-                    throw importError;
-                }
-            }
-            else {
-                throw error;
-            }
-        }
-        const config = configModule.default || configModule;
-        if (!config) {
-            throw new Error('Configuration file must export a default configuration object');
-        }
-        return config;
+    if (this.options.dryRun) {
+      this.logger.log("Dry run \u2014 the following seeders would execute:");
+      seeders.forEach((seeder, index) => {
+        this.logger.log(`  ${index + 1}. ${getSeederName(seeder)}`);
+      });
+      return;
     }
-    catch (error) {
-        console.error('Error loading seeder configuration:');
-        console.error(error.message);
-        console.error('\nMake sure your configuration file:');
-        console.error('1. Exists at the specified path');
-        console.error('2. Exports a default configuration object');
-        console.error('3. Has proper TypeScript setup if using .ts files');
-        process.exit(1);
+    if (this.options.refresh) {
+      await this.drop(seeders);
     }
-}
-async function runSeeder() {
-    try {
-        const args = await parseArguments();
-        console.log('🌱 Starting NestJS Seeder...');
-        console.log(`📁 Loading configuration from: ${args.config}`);
-        const seederConfig = await loadSeederConfig(args.config);
-        const cliOptions = {
-            refresh: args.refresh,
-            name: args.name,
-            dummyData: args.dummyData,
-        };
-        if (args.refresh) {
-            console.log('🔄 Refresh mode: Will drop existing data before seeding');
-        }
-        if (args.name && args.name.length > 0) {
-            console.log(`🎯 Running specific seeders: ${args.name.join(', ')}`);
+    await this.seed(seeders);
+  }
+  /** Seeds the given seeders (defaults to the configured selection). */
+  async seed(seeders = this.getSeedersToRun()) {
+    for (const seeder of seeders) {
+      const name = getSeederName(seeder);
+      try {
+        this.logger.log(`Seeding: ${name}`);
+        await seeder.seed(this.options);
+        this.logger.log(`Completed: ${name}`);
+      } catch (error) {
+        this.handleError(name, "seed", error);
+      }
+    }
+  }
+  /** Drops the given seeders in reverse order (defaults to the selection). */
+  async drop(seeders = this.getSeedersToRun()) {
+    for (const seeder of [...seeders].reverse()) {
+      const name = getSeederName(seeder);
+      if (typeof seeder.drop !== "function") {
+        this.logger.debug(`Skipping drop for ${name} (no drop() defined)`);
+        continue;
+      }
+      try {
+        this.logger.log(`Dropping: ${name}`);
+        await seeder.drop(this.options);
+        this.logger.log(`Dropped: ${name}`);
+      } catch (error) {
+        this.handleError(name, "drop", error);
+      }
+    }
+  }
+  /** Resolves the seeders to run based on the `name` option. */
+  getSeedersToRun() {
+    const names = this.normalizeNames(this.options.name);
+    if (!names) {
+      if (this.seeders.length === 0) {
+        this.logger.warn(
+          'No seeders registered. Did you add them to the "seeders" array in your config?'
+        );
+      }
+      return this.seeders;
+    }
+    const wanted = new Set(names.map((name) => name.toLowerCase()));
+    const matched = this.seeders.filter((seeder) => {
+      const name = getSeederName(seeder).toLowerCase();
+      return wanted.has(name) || wanted.has(name.replace(/seeder$/, ""));
+    });
+    if (matched.length === 0) {
+      const available = this.seeders.map((seeder) => getSeederName(seeder));
+      this.logger.warn(
+        `No seeders matched [${names.join(", ")}]. Available seeders: ${available.length ? available.join(", ") : "(none)"}`
+      );
+    }
+    return matched;
+  }
+  handleError(name, phase, error) {
+    const message = error?.message ?? error;
+    if (this.options.continueOnError) {
+      this.logger.error(`Seeder "${name}" failed during ${phase}: ${message}`);
+      return;
+    }
+    throw error;
+  }
+  normalizeNames(name) {
+    if (!name) {
+      return void 0;
+    }
+    const list = (Array.isArray(name) ? name : [name]).filter(Boolean);
+    return list.length ? list : void 0;
+  }
+};
+SeederService = __decorateClass([
+  (0, import_common.Injectable)()
+], SeederService);
+
+// src/lib/seeder/seeder.module.ts
+var SEEDER_MODULE_OPTIONS = "SEEDER_MODULE_OPTIONS";
+var SeederModule = class {
+  static register(options) {
+    return {
+      module: SeederModule,
+      imports: options.imports || [],
+      providers: [
+        ...options.providers || [],
+        ...options.seeders || [],
+        {
+          provide: SeederService,
+          useFactory: (...seeders) => {
+            return new SeederService(seeders, options);
+          },
+          inject: options.seeders || []
         }
-        if (args.dummyData) {
-            console.log('🎲 Dummy data mode enabled');
+      ]
+    };
+  }
+  static forRootAsync(options) {
+    return {
+      module: SeederModule,
+      global: options.isGlobal,
+      imports: options.imports || [],
+      providers: [
+        ...this.createAsyncProviders(options),
+        {
+          provide: SeederService,
+          useFactory: (seederOptions, ...seeders) => {
+            return new SeederService(seeders, seederOptions);
+          },
+          inject: [SEEDER_MODULE_OPTIONS, ...options.inject || []]
         }
-        const app = await core_1.NestFactory.createApplicationContext(seeder_module_1.SeederModule.register({
-            ...seederConfig,
-            ...cliOptions,
-        }));
-        const seedersService = app.get(seeder_service_1.SeederService);
-        await seedersService.run();
-        await app.close();
-        console.log('✅ Seeding completed successfully!');
-        process.exit(0);
+      ]
+    };
+  }
+  static createAsyncProviders(options) {
+    if (options.useExisting || options.useFactory) {
+      return [this.createAsyncOptionsProvider(options)];
     }
-    catch (error) {
-        console.error('❌ Error running seeder:');
-        console.error(error.message);
-        if (error.stack && process.env.NODE_ENV === 'development') {
-            console.error('\nStack trace:');
-            console.error(error.stack);
-        }
-        process.exit(1);
+    return [
+      this.createAsyncOptionsProvider(options),
+      {
+        provide: options.useClass,
+        useClass: options.useClass
+      }
+    ];
+  }
+  static createAsyncOptionsProvider(options) {
+    if (options.useFactory) {
+      return {
+        provide: SEEDER_MODULE_OPTIONS,
+        useFactory: options.useFactory,
+        inject: options.inject || []
+      };
     }
-}
-const seeder = (options) => {
     return {
-        async run(extraOptions) {
-            const cliOptions = {};
-            const argv = (0, yargs_1.default)(process.argv).argv;
-            if (argv.r || argv.refresh) {
-                cliOptions.refresh = true;
-            }
-            if (argv.n || argv.name) {
-                cliOptions.name = argv.n || argv.name;
-            }
-            if (argv.d || argv.dummyData) {
-                cliOptions.dummyData = argv.d || argv.dummyData;
-            }
-            extraOptions = Object.assign(extraOptions, cliOptions);
-            const app = await core_1.NestFactory.createApplicationContext(seeder_module_1.SeederModule.register({
-                ...options,
-                ...extraOptions,
-            }));
-            const seedersService = app.get(seeder_service_1.SeederService);
-            await seedersService.run();
-            await app.close();
-        },
+      provide: SEEDER_MODULE_OPTIONS,
+      useFactory: async (optionsFactory) => await optionsFactory.createSeederOptions(),
+      inject: [options.useExisting || options.useClass]
     };
+  }
+};
+SeederModule = __decorateClass([
+  (0, import_common2.Module)({})
+], SeederModule);
+
+// src/cli.ts
+var log = {
+  info: (msg) => console.log(msg),
+  error: (msg) => console.error(`\x1B[31m${msg}\x1B[0m`),
+  success: (msg) => console.log(`\x1B[32m${msg}\x1B[0m`),
+  dim: (msg) => console.log(`\x1B[2m${msg}\x1B[0m`)
 };
-exports.seeder = seeder;
+function parseContext(raw) {
+  if (!raw) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(`--context must be valid JSON. Received: ${raw}`);
+  }
+}
+async function createContext(configOption) {
+  const configPath = resolveConfigPath(configOption);
+  if (!configPath) {
+    throw new Error(
+      configOption ? `Config file not found: ${configOption}` : 'No seeder config found. Create a seeder.config.ts (try "nest-seed init") or pass one with --config.'
+    );
+  }
+  log.dim(`Using config: ${path2.relative(process.cwd(), configPath)}`);
+  const config = await loadSeederConfig(configPath);
+  return { config, configPath };
+}
+async function runCommand(argv) {
+  const { config } = await createContext(argv.config);
+  const options = {
+    refresh: argv.refresh,
+    name: argv.name,
+    dryRun: argv["dry-run"],
+    continueOnError: argv["continue-on-error"],
+    dummyData: argv["dummy-data"],
+    context: parseContext(argv.context)
+  };
+  if (options.refresh) log.info("\u{1F504} Refresh mode: dropping data before seeding");
+  if (options.dryRun) log.info("\u{1F50E} Dry run: no data will be written");
+  if (options.name) {
+    const names = Array.isArray(options.name) ? options.name : [options.name];
+    log.info(`\u{1F3AF} Seeders: ${names.join(", ")}`);
+  }
+  const app = await import_core.NestFactory.createApplicationContext(
+    SeederModule.register({ ...config, ...options }),
+    { logger: ["error", "warn", "log"] }
+  );
+  try {
+    await app.get(SeederService).run();
+  } finally {
+    await app.close();
+  }
+  log.success("\u2705 Seeding completed successfully!");
+}
+async function listCommand(argv) {
+  const { config } = await createContext(argv.config);
+  const seeders = config.seeders ?? [];
+  if (seeders.length === 0) {
+    log.info("No seeders registered in the config.");
+    return;
+  }
+  log.info(`Registered seeders (${seeders.length}):`);
+  seeders.forEach((seeder, index) => {
+    const className = seeder?.name ?? "Unknown";
+    const stableName = getSeederName(seeder);
+    const alias = stableName !== className ? `  (--name ${stableName})` : "";
+    log.info(`  ${index + 1}. ${className}${alias}`);
+  });
+}
+function initCommand(argv) {
+  const orm = argv.orm;
+  const force = Boolean(argv.force);
+  const files = scaffoldFiles(orm);
+  let created = 0;
+  let skipped = 0;
+  for (const file of files) {
+    const absolute = path2.resolve(process.cwd(), file.path);
+    if (fs2.existsSync(absolute) && !force) {
+      log.dim(`\u2022 skipped (exists): ${file.path}`);
+      skipped++;
+      continue;
+    }
+    fs2.mkdirSync(path2.dirname(absolute), { recursive: true });
+    fs2.writeFileSync(absolute, file.contents);
+    log.success(`\u2022 created: ${file.path}`);
+    created++;
+  }
+  log.info(`
+Scaffolded ${created} file(s)${skipped ? `, skipped ${skipped}` : ""}.`);
+  log.info("\nNext steps:");
+  log.info("  1. Adjust seeder.config.ts for your database and entities.");
+  log.info("  2. Add a script to package.json:");
+  log.dim('       "seed": "nest-seed"');
+  log.info("  3. Run it:");
+  log.dim("       npm run seed");
+  if (skipped && !force) {
+    log.dim("\nUse --force to overwrite existing files.");
+  }
+}
+async function main() {
+  await (0, import_yargs.default)((0, import_helpers.hideBin)(process.argv)).scriptName("nest-seed").usage("$0 [command] [options]").command(
+    ["$0", "run"],
+    "Run seeders (default command)",
+    (y) => y.option("config", {
+      alias: "c",
+      type: "string",
+      describe: "Path to the seeder config file (auto-detected if omitted)"
+    }).option("refresh", {
+      alias: "r",
+      type: "boolean",
+      default: false,
+      describe: "Drop data before seeding"
+    }).option("name", {
+      alias: "n",
+      type: "array",
+      string: true,
+      describe: "Run only the named seeder(s)"
+    }).option("dry-run", {
+      type: "boolean",
+      default: false,
+      describe: "Show which seeders would run without executing them"
+    }).option("continue-on-error", {
+      type: "boolean",
+      default: false,
+      describe: "Keep going when a seeder fails"
+    }).option("context", {
+      type: "string",
+      describe: "JSON forwarded to every seeder via options.context"
+    }).option("dummy-data", {
+      alias: "d",
+      type: "boolean",
+      default: false,
+      describe: "[deprecated] forwarded as options.dummyData"
+    }),
+    runCommand
+  ).command(
+    "init",
+    "Scaffold a seeder config, factory and seeder",
+    (y) => y.option("orm", {
+      type: "string",
+      choices: ["typeorm", "mongoose"],
+      default: "typeorm",
+      describe: "Which ORM template to scaffold"
+    }).option("force", {
+      type: "boolean",
+      default: false,
+      describe: "Overwrite existing files"
+    }),
+    (argv) => initCommand(argv)
+  ).command(
+    "list",
+    "List the seeders registered in the config",
+    (y) => y.option("config", {
+      alias: "c",
+      type: "string",
+      describe: "Path to the seeder config file (auto-detected if omitted)"
+    }),
+    listCommand
+  ).example("$0", "Run all seeders using the auto-detected config").example("$0 --refresh", "Drop and reseed all data").example("$0 --name users posts", 'Run only the "users" and "posts" seeders').example("$0 init", "Scaffold starter files").example("$0 list", "List available seeders").strict().alias("h", "help").alias("v", "version").fail((msg, err) => {
+    if (err) throw err;
+    log.error(`
+${msg}`);
+    console.error('\nRun "nest-seed --help" for usage.');
+    process.exit(1);
+  }).parseAsync();
+}
+async function bootstrap() {
+  log.info("\u{1F331} nest-seeder");
+  try {
+    await main();
+    process.exit(0);
+  } catch (error) {
+    log.error(`
+\u274C ${error?.message ?? error}`);
+    if (error?.stack && process.env.NEST_SEEDER_DEBUG) {
+      console.error(error.stack);
+    } else {
+      log.dim("Set NEST_SEEDER_DEBUG=1 for a full stack trace.");
+    }
+    process.exit(1);
+  }
+}
 if (require.main === module) {
-    runSeeder();
+  bootstrap();
 }
 //# sourceMappingURL=cli.js.map