@jorgebodega/typeorm-seeding 5.0.1 → 6.0.0-next.1

package/CHANGELOG.md

@@ -1,3 +1,33 @@
+# [6.0.0-next.1](https://github.com/jorgebodega/typeorm-seeding/compare/v5.0.1-next.1...v6.0.0-next.1) (2022-08-18)
+
+
+### chore
+
+* remove factory definitions ([f2ede7c](https://github.com/jorgebodega/typeorm-seeding/commit/f2ede7c952a106db98ef817e6c9fc34a1a79dd96))
+
+
+### Features
+
+* force major version ([73ade47](https://github.com/jorgebodega/typeorm-seeding/commit/73ade475e1a1f44764d4090b04fe2abf9fcbe61b))
+
+
+### BREAKING CHANGES
+
+* Force version 6
+* remove all factory related code in favor of @jorgebodega/typeorm-factory
+
+## [5.0.1-next.2](https://github.com/jorgebodega/typeorm-seeding/compare/v5.0.1-next.1...v5.0.1-next.2) (2022-08-18)
+
+
+### chore
+
+* remove factory definitions ([f2ede7c](https://github.com/jorgebodega/typeorm-seeding/commit/f2ede7c952a106db98ef817e6c9fc34a1a79dd96))
+
+
+### BREAKING CHANGES
+
+* remove all factory related code in favor of @jorgebodega/typeorm-factory
+
 ## [5.0.1](https://github.com/jorgebodega/typeorm-seeding/compare/v5.0.0...v5.0.1) (2022-08-18)
 
 

package/README.md

@@ -4,33 +4,16 @@
 <h1 align="center" style="text-align: center;">TypeORM Seeding</h1>
 
 <p align="center">
-  <img alt="NPM" src="https://img.shields.io/npm/l/@jorgebodega/typeorm-seeding?style=for-the-badge">
-  <a href="https://www.npmjs.com/package/@jorgebodega/typeorm-seeding">
-    <img alt="NPM latest version" src="https://img.shields.io/npm/v/@jorgebodega/typeorm-seeding/latest?style=for-the-badge">
-  </a>
-  <a href="https://www.npmjs.com/package/@jorgebodega/typeorm-seeding/v/next">
-    <img alt="NPM next version" src="https://img.shields.io/npm/v/@jorgebodega/typeorm-seeding/next?style=for-the-badge">
-  </a>
+  <img alt="License" src="https://img.shields.io/npm/l/@jorgebodega/typeorm-seeding?style=for-the-badge">
   <a href="https://github.com/semantic-release/semantic-release">
     <img src="https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release&style=for-the-badge" alt="Semantic release" />
   </a>
-</p>
-
-<p align="center">
   <a href='https://coveralls.io/github/jorgebodega/typeorm-seeding'>
     <img alt="Coveralls master branch" src="https://img.shields.io/coveralls/github/jorgebodega/typeorm-seeding/master?style=for-the-badge">
   </a>
-  <a href='https://coveralls.io/github/jorgebodega/typeorm-seeding?branch=next'>
-    <img alt="Coveralls next branch" src="https://img.shields.io/coveralls/github/jorgebodega/typeorm-seeding/next?style=for-the-badge&label=coverage%40next">
-  </a>
 </p>
 
-<p align="center">
-  <img alt="Checks for master branch" src="https://img.shields.io/github/checks-status/jorgebodega/typeorm-seeding/master?style=for-the-badge">
-  <a href='https://coveralls.io/github/jorgebodega/typeorm-seeding'>
-    <img alt="Checks for next branch" src="https://img.shields.io/github/checks-status/jorgebodega/typeorm-seeding/next?label=checks%40next&style=for-the-badge">
-  </a>
-</p>
+
 
 <p align="center">
   <b>A delightful way to seed test data into your database.</b></br>
@@ -45,15 +28,6 @@
 
 # Contents
 
-- [Factory](#factory-1)
-  - [attrs](#attrs)
-    - [Simple value](#simple-value)
-    - [Function](#function)
-    - [InstanceAttribute](#instanceattribute)
-    - [LazyInstanceAttribute](#lazyinstanceattribute)
-    - [Subfactory](#subfactory)
-  - [make & makeMany](#make--makemany)
-  - [create & createMany](#create--createmany)
 - [Seeder](#seeder-1)
   - [run](#run)
 - [CLI](#cli-configuration)
@@ -72,27 +46,6 @@ yarn add [-D] @jorgebodega/typeorm-seeding
 pnpm add [-D] @jorgebodega/typeorm-seeding
 ```
 
-## Configuration
-
-To configure the path to your seeders extends the TypeORM config file or use environment variables like TypeORM. If both are used the environment variables will be prioritized.
-
-**ormconfig.js**
-
-```typescript
-module.exports = {
-  ...
-  seeders: ['src/seeds/**/*{.ts,.js}'],
-  defaultSeeder: RootSeeder,
-  ...
-}
-```
-
-**.env**
-
-```
-TYPEORM_SEEDING_SEEDERS=src/seeds/**/*{.ts,.js}
-TYPEORM_SEEDING_DEFAULT_SEEDER=RootSeeder
-```
 
 # Introduction
 
@@ -126,226 +79,24 @@ class User {
 }
 ```
 
-### Factory
-
-```typescript
-class UserFactory extends Factory<User> {
-  protected entity = User
-  protected attrs: FactorizedAttrs<User> = {
-    name: faker.name.firstName(),
-    lastName: async () => faker.name.lastName(),
-    email: new InstanceAttribute((instance) =>
-      [instance.name.toLowerCase(), instance.lastName.toLowerCase(), '@email.com'].join(''),
-    ),
-    country: new Subfactory(CountryFactory),
-  }
-}
-```
-
 ### Seeder
 
 ```typescript
 class UserSeeder extends Seeder {
-  async run(connection: Connection) {
-    await new UserFactory().createMany(10)
-
-    await this.call(connection, [PetSeeder])
-  }
-}
-```
-
-# Factory
-
-Factory is how we provide a way to simplify entities creation, implementing a [factory creational pattern](https://refactoring.guru/design-patterns/factory-method). It is defined as an abstract class with generic typing, so you have to extend over it.
-
-```typescript
-class UserFactory extends Factory<User> {
-  protected entity = User
-  protected attrs: FactorizedAttrs<User> = {
-    ...
+  async run(dataSource: DataSource) {
+    const users: User[] = [...]
+    await dataSource.createEntityManager().save<User>(users)
   }
 }
 ```
 
-## `attrs`
-
-Attributes objects are superset from the original entity attributes.
-
-```typescript
-protected attrs: FactorizedAttrs<User> = {
-  name: faker.name.firstName(),
-  lastName: async () => faker.name.lastName(),
-  email: new InstanceAttribute((instance) =>
-    [instance.name.toLowerCase(), instance.lastName.toLowerCase(), '@email.com'].join(''),
-  ),
-  country: new Subfactory(CountryFactory),
-}
-```
-
-Those factorized attributes resolves to the value of the original attribute, and could be one of the following types:
-
-- [Simple value](#simple-value)
-- [Function](#function)
-- [InstanceAttribute](#instanceattribute)
-- [LazyInstanceAttribute](#lazyinstanceattribute)
-- [Subfactory](#subfactory)
-
-### Simple value
-
-Nothing special, just a value with same type.
-
-```typescript
-protected attrs: FactorizedAttrs<User> = {
-  name: faker.name.firstName(),
-}
-```
-
-### Function
-
-Function that could be sync or async, and return a value of the same type. This function will be executed once per entity.
-
-```typescript
-protected attrs: FactorizedAttrs<User> = {
-  lastName: async () => faker.name.lastName(),
-}
-```
-
-### `InstanceAttribute`
-
-```typescript
-class InstanceAttribute<T, V> {
-  constructor(private callback: (entity: T) => V) {}
-
-  ...
-}
-```
-
-Class with a function that receive the current instance and returns a value of the same type. It is ideal for attributes that could depend on some others to be computed.
-
-Will be executed after the entity has been created and the rest of the attributes have been calculated, but before persistance (in case of `create` or `createMany`).
-
-```typescript
-protected attrs: FactorizedAttrs<User> = {
-  name: faker.name.firstName(),
-  lastName: async () => faker.name.lastName(),
-  email: new InstanceAttribute((instance) =>
-    [instance.name.toLowerCase(), instance.lastName.toLowerCase(), '@email.com'].join(''),
-  ),
-}
-```
-
-In this simple case, if `name` or `lastName` override the value in any way, the `email` attribute will be affected too.
-
-### `LazyInstanceAttribute`
-
-```typescript
-class LazyInstanceAttribute<T, V> {
-  constructor(private callback: (entity: T) => V) {}
-
-  ...
-}
-```
-
-Class with similar functionality than `InstanceAttribute`, but it will be executed only after persistance. This is useful for attributes that depends on the database id, like relations.
-
-Just remember that, if you use `make` or `makeMany`, the only difference between `InstanceAttribute` and `LazyInstanceAttribute` is that `LazyInstanceAttribute` will be processed the last.
-
-```typescript
-protected attrs: FactorizedAttrs<User> = {
-  name: faker.name.firstName(),
-  email: new LazyInstanceAttribute((instance) =>
-    [instance.name.toLowerCase(), instance.id, '@email.com'].join(''),
-  ),
-}
-```
-
-### `Subfactory`
-
-```typescript
-export class Subfactory<T> {
-  constructor(factory: Constructable<Factory<T>>)
-  constructor(factory: Constructable<Factory<T>>, values?: Partial<FactorizedAttrs<T>>)
-  constructor(factory: Constructable<Factory<T>>, count?: number)
-  constructor(factory: Constructable<Factory<T>>, values?: Partial<FactorizedAttrs<T>>, count?: number)
-
-  ...
-}
-```
-
-Subfactories are just a wrapper of another factory, to avoid explicit operations that could lead to unexpected results over that factory, like
-
-```typescript
-protected attrs: FactorizedAttrs<User> = {
-  country: async () => new CountryFactory().create({
-    name: faker.address.country(),
-  }),
-}
-```
-
-instead of
-
-```typescript
-protected attrs: FactorizedAttrs<User> = {
-  country: new Subfactory(CountryFactory, {
-    name: faker.address.country(),
-  }),
-}
-```
-
-Subfactory just execute the same kind of operation (`make` or `create`) over the factory. If `count` param is provided, it will execute `makeMany`/`createMany` instead of `make`/`create`, and returns an array.
-
-## `make` & `makeMany`
-
-Make and makeMany executes the factory functions and return a new instance of the given entity. The instance is filled with the generated values from the factory function, but not saved in the database.
-
-- **overrideParams** - Override some of the attributes of the entity.
-
-```typescript
-make(overrideParams: Partial<FactorizedAttrs<T>> = {}): Promise<T>
-makeMany(amount: number, overrideParams: Partial<FactorizedAttrs<T>> = {}): Promise<T[]>
-```
-
-```typescript
-new UserFactory().make()
-new UserFactory().makeMany(10)
-
-// override the email
-new UserFactory().make({ email: 'other@mail.com' })
-new UserFactory().makeMany(10, { email: 'other@mail.com' })
-```
-
-## `create` & `createMany`
-
-the create and createMany method is similar to the make and makeMany method, but at the end the created entity instance gets persisted in the database using TypeORM entity manager.
-
-- **overrideParams** - Override some of the attributes of the entity.
-- **saveOptions** - [Save options](https://github.com/typeorm/typeorm/blob/master/src/repository/SaveOptions.ts) from TypeORM
-
-```typescript
-create(overrideParams: Partial<FactorizedAttrs<T>> = {}, saveOptions?: SaveOptions): Promise<T>
-createMany(amount: number, overrideParams: Partial<FactorizedAttrs<T>> = {}, saveOptions?: SaveOptions): Promise<T[]>
-```
-
-```typescript
-new UserFactory().create()
-new UserFactory().createMany(10)
-
-// override the email
-new UserFactory().create({ email: 'other@mail.com' })
-new UserFactory().createMany(10, { email: 'other@mail.com' })
-
-// using save options
-new UserFactory().create({ email: 'other@mail.com' }, { listeners: false })
-new UserFactory().createMany(10, { email: 'other@mail.com' }, { listeners: false })
-```
-
 # Seeder
 
 Seeder class is how we provide a way to insert data into databases, and could be executed by the command line or by helper method. Is an abstract class with one method to be implemented, and a helper function to run some more seeder sequentially.
 
 ```typescript
 class UserSeeder extends Seeder {
-  async run(connection: Connection) {
+  async run(dataSource: DataSource) {
     ...
   }
 }
@@ -353,42 +104,45 @@ class UserSeeder extends Seeder {
 
 ## `run`
 
-This function is the one that needs to be defined when extending the class. Could use `call` to run some other seeders.
+This function is the one that needs to be defined when extending the class.
 
 ```typescript
-run(connection: Connection): Promise<void>
+run(dataSource: DataSource): Promise<void>
 ```
 
 ```typescript
-async run(connection: Connection) {
-    await new UserFactory().createMany(10)
-
-    await this.call(connection, [PetSeeder])
+async run(dataSource: DataSource) {
+    const users: User[] = [...]
+    await dataSource.createEntityManager().save<User>(users)
 }
 ```
 
 # CLI Configuration
 
-There are two possible commands to execute, one to see the current configuration and one to run a seeder.
+There is a command that allows you to execute multiple seeders from cli.
+
+```bash
+typeorm-seeding seed -d path/to/datasource src/seeders/*.ts
+```
 
-Add the following scripts to your `package.json` file to configure them.
+Add the following script to your `package.json` file to configure them.
 
 ```json
 "scripts": {
-  "seed:run": "typeorm-seeding seed",
+  "seed:run": "typeorm-seeding seed -d path/to/datasource",
   ...
 }
 ```
 
 ## `seed`
 
-This command execute a seeder, that could be specified as a parameter.
+This command execute a seeder, that could be specified as a parameter. Glob pattern is supported.
 
 ```bash
 typeorm-seeding seed <path>
 ```
 
-The name of the seeder to execute (either set with the `--seed` option or with default in [configs](#configuration)) must be the seeder's class name, and thus, the seeder must be exported with a named export. Please avoid default export for seeders: it may imply unwanted behavior. (See [\#75](https://github.com/jorgebodega/typeorm-seeding/issues/75)).
+CLI command only executes default seeders.
 
 ##### Options
 
@@ -427,3 +181,7 @@ useDataSource(
   forceInitialization: boolean,
 ): Promise<void>
 ```
+
+# Factory
+
+Factory related code has been removed from this package, now on [@jorgebodega/typeorm-factory](https://github.com/jorgebodega/typeorm-factory).

package/dist/cli.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import 'reflect-metadata';
+export {};

package/dist/cli.js

@@ -1,17 +1,7 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-/* istanbul ignore file */
-require("reflect-metadata");
-const yargs_1 = tslib_1.__importDefault(require("yargs"));
 const seed_command_1 = require("./commands/seed.command");
-yargs_1.default
-    .usage('Usage: $0 <command> [options]')
-    .command(new seed_command_1.SeedCommand())
-    .recommendCommands()
-    .demandCommand(1)
-    .strict()
-    .help('h')
-    .alias('h', 'help').argv;
+/* istanbul ignore file */
+(0, seed_command_1.bootstrap)(process.argv);
 //# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -1 +1 @@
-{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";;;;AACA,0BAA0B;AAC1B,4BAAyB;AACzB,0DAAyB;AACzB,0DAAqD;AAErD,eAAK;KACF,KAAK,CAAC,+BAA+B,CAAC;KACtC,OAAO,CAAC,IAAI,0BAAW,EAAE,CAAC;KAC1B,iBAAiB,EAAE;KACnB,aAAa,CAAC,CAAC,CAAC;KAChB,MAAM,EAAE;KACR,IAAI,CAAC,GAAG,CAAC;KACT,KAAK,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,IAAI,CAAA"}
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";;;AACA,0DAAmD;AACnD,0BAA0B;AAC1B,IAAA,wBAAS,EAAC,OAAO,CAAC,IAAI,CAAC,CAAA"}

package/dist/commands/seed.command.d.ts

@@ -1,25 +1 @@
-import { DataSource } from 'typeorm';
-import { Arguments, Argv, CommandModule } from 'yargs';
-import { Seeder } from '../seeder';
-import type { Constructable } from '../types';
-interface SeedCommandArguments extends Arguments {
-    dataSource?: string;
-    path?: string;
-}
-export declare class SeedCommand implements CommandModule {
-    command: string;
-    describe: string;
-    /**
-     * @inheritdoc
-     */
-    builder(args: Argv): Argv<{
-        d: string;
-    }>;
-    /**
-     * @inheritdoc
-     */
-    handler(args: SeedCommandArguments): Promise<void>;
-    static loadDataSource(dataSourceFilePath: string): Promise<DataSource>;
-    static loadSeeders(seederPaths: string[]): Promise<Constructable<Seeder>[]>;
-}
-export {};
+export declare function bootstrap(argv: string[]): Promise<void>;

package/dist/commands/seed.command.js

@@ -1,145 +1,64 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SeedCommand = void 0;
+exports.bootstrap = void 0;
 const tslib_1 = require("tslib");
 const node_path_1 = require("node:path");
+const commander_1 = require("commander");
 const ora_1 = tslib_1.__importDefault(require("ora"));
-const typeorm_1 = require("typeorm");
-const yargs_1 = require("yargs");
-const seeder_1 = require("../seeder");
-const useSeeders_1 = require("../helpers/useSeeders");
-const fileHandling_1 = require("../utils/fileHandling");
+const errors_1 = require("../errors");
+const DataSourceImportationError_1 = require("../errors/DataSourceImportationError");
+const SeederExecutionError_1 = require("../errors/SeederExecutionError");
 const helpers_1 = require("../helpers");
-class SeedCommand {
-    constructor() {
-        this.command = 'seed <path>';
-        this.describe = 'Runs the seeders';
+const utils_1 = require("../utils");
+async function run(path) {
+    const opts = seedCommand.opts();
+    const spinner = (0, ora_1.default)({ isSilent: process.env.NODE_ENV === 'test' }).start();
+    spinner.start('Loading datasource');
+    let dataSource;
+    try {
+        const dataSourcePath = (0, node_path_1.resolve)(process.cwd(), opts.dataSource);
+        dataSource = await utils_1.CommandUtils.loadDataSource(dataSourcePath);
+        spinner.succeed('Datasource loaded');
     }
-    /**
-     * @inheritdoc
-     */
-    builder(args) {
-        return args
-            .option('d', {
-            alias: 'dataSource',
-            type: 'string',
-            describe: 'Path to the file where your DataSource instance is defined.',
-            required: true,
-        })
-            .fail((message, error) => {
-            if (error)
-                throw error; // preserve stack
-            else {
-                console.error(message);
-                (0, yargs_1.showHelp)();
-            }
-        });
+    catch (error) {
+        spinner.fail('Could not load the data source!');
+        throw new DataSourceImportationError_1.DataSourceImportationError('Could not load the data source!', { cause: error });
     }
-    /**
-     * @inheritdoc
-     */
-    async handler(args) {
-        const spinner = (0, ora_1.default)({ isSilent: process.env.NODE_ENV === 'test' }).start();
-        spinner.start('Loading datasource');
-        let dataSource;
-        try {
-            const dataSourcePath = (0, node_path_1.resolve)(process.cwd(), args.dataSource);
-            dataSource = await SeedCommand.loadDataSource(dataSourcePath);
-            spinner.succeed('Datasource loaded');
-        }
-        catch (error) {
-            spinner.fail('Could not load the data source!');
-            throw error;
-        }
-        spinner.start('Importing seeders');
-        let seeders;
-        try {
-            const absolutePath = (0, node_path_1.resolve)(process.cwd(), args.path);
-            const seederFiles = (0, fileHandling_1.calculateFilePath)(absolutePath);
-            seeders = await SeedCommand.loadSeeders(seederFiles);
-            spinner.succeed('Seeder imported');
-        }
-        catch (error) {
-            spinner.fail('Could not load seeders!');
-            await dataSource.destroy();
-            throw error;
-        }
-        // Run seeder
-        spinner.start(`Executing seeders`);
-        try {
-            await (0, helpers_1.useDataSource)(dataSource);
-            for (const seeder of seeders) {
-                await (0, useSeeders_1.useSeeders)(seeder);
-                spinner.succeed(`Seeder ${seeder.name} executed`);
-            }
-        }
-        catch (error) {
-            spinner.fail('Could not execute seeder!');
-            await dataSource.destroy();
-            throw error;
-        }
-        spinner.succeed('Finished seeding');
-        await dataSource.destroy();
+    spinner.start('Importing seeders');
+    let seeders;
+    try {
+        const seederFiles = (0, utils_1.calculateFilePath)(path);
+        seeders = await utils_1.CommandUtils.loadSeeders(seederFiles);
+        spinner.succeed('Seeder imported');
     }
-    static async loadDataSource(dataSourceFilePath) {
-        let dataSourceFileExports;
-        try {
-            dataSourceFileExports = await Promise.resolve().then(() => tslib_1.__importStar(require(dataSourceFilePath)));
-        }
-        catch (err) {
-            throw new Error(`Unable to open file: "${dataSourceFilePath}"`);
-        }
-        if (!dataSourceFileExports || typeof dataSourceFileExports !== 'object') {
-            throw new Error(`Given data source file must contain export of a DataSource instance`);
-        }
-        const dataSourceExports = [];
-        for (const fileExport in dataSourceFileExports) {
-            const dataSourceExport = dataSourceFileExports[fileExport];
-            if (dataSourceExport instanceof typeorm_1.DataSource) {
-                dataSourceExports.push(dataSourceExport);
-            }
-        }
-        if (dataSourceExports.length === 0) {
-            throw new Error(`Given data source file must contain export of a DataSource instance`);
-        }
-        if (dataSourceExports.length > 1) {
-            throw new Error(`Given data source file must contain only one export of DataSource instance`);
-        }
-        const dataSource = dataSourceExports[0];
-        dataSource.setOptions({
-            synchronize: false,
-            migrationsRun: false,
-            dropSchema: false,
-            logging: false,
-        });
-        await dataSource.initialize();
-        return dataSource;
+    catch (error) {
+        spinner.fail('Could not load seeders!');
+        throw new errors_1.SeederImportationError('Could not load seeders!', { cause: error });
     }
-    static async loadSeeders(seederPaths) {
-        let seederFileExports;
-        try {
-            seederFileExports = await Promise.all(seederPaths.map((seederFile) => Promise.resolve().then(() => tslib_1.__importStar(require(seederFile))))).then((seederExports) => {
-                return seederExports
-                    .map((seederExport) => seederExport.default)
-                    .filter((seederExport) => Boolean(seederExport));
-            });
-        }
-        catch (err) {
-            throw new Error(`Unable to open files ${err.message}`);
-        }
-        if (seederFileExports.length === 0) {
-            throw new Error(`No default seeders found`);
+    spinner.info(`Executing seeders...`);
+    try {
+        await (0, helpers_1.useDataSource)(dataSource, true);
+        for (const seeder of seeders) {
+            spinner.start(`Executing ${seeder.name}`);
+            await (0, helpers_1.useSeeders)(seeder);
+            spinner.succeed(`Seeder ${seeder.name} executed`);
         }
-        const seeders = [];
-        for (const fileExport in seederFileExports) {
-            const seederExport = seederFileExports[fileExport];
-            const instance = new seederExport();
-            if (instance instanceof seeder_1.Seeder) {
-                seeders.push(seederExport);
-            }
-        }
-        return seeders;
     }
+    catch (error) {
+        spinner.fail('Could not execute seeder!');
+        await dataSource.destroy();
+        throw new SeederExecutionError_1.SeederExecutionError('Could not execute seeder!', { cause: error });
+    }
+    spinner.succeed('Finished seeding');
+    await dataSource.destroy();
+}
+const seedCommand = new commander_1.Command('seed')
+    .description('Run the seeders specified by the path. Glob pattern is allowed.')
+    .requiredOption('-d, --dataSource <dataSourcePath>', 'Path to the file where your DataSource instance is defined.', './datasource.ts')
+    .argument('<path>', 'Path to the seeders. Glob pattern is allowed.')
+    .action(run);
+async function bootstrap(argv) {
+    await seedCommand.parseAsync(argv);
 }
-exports.SeedCommand = SeedCommand;
+exports.bootstrap = bootstrap;
 //# sourceMappingURL=seed.command.js.map