@jorgebodega/typeorm-seeding 2.0.0-next.3 → 3.0.1

package/CHANGELOG.md

@@ -1,73 +1,48 @@
-# [2.0.0-next.3](https://github.com/jorgebodega/typeorm-seeding/compare/v2.0.0-next.2...v2.0.0-next.3) (2021-12-13)
+## [3.0.1](https://github.com/jorgebodega/typeorm-seeding/compare/v3.0.0...v3.0.1) (2022-01-08)
 
 
 ### Bug Fixes
 
-* Npm package not handling correctly entrypoint ([b51a099](https://github.com/jorgebodega/typeorm-seeding/commit/b51a099d20a7df30f017693852b15ced7587f04a))
-
-# [2.0.0-next.2](https://github.com/jorgebodega/typeorm-seeding/compare/v2.0.0-next.1...v2.0.0-next.2) (2021-12-13)
+* update dependencies and add rimraf to dev deps ([504cef2](https://github.com/jorgebodega/typeorm-seeding/commit/504cef2f94b1b8e2e47d6bfa6e0bb1e8325490e2))
 
+# [3.0.0](https://github.com/jorgebodega/typeorm-seeding/compare/v2.0.0...v3.0.0) (2022-01-06)
 
 ### Bug Fixes
 
-* npmignore not working properly ([2d1d898](https://github.com/jorgebodega/typeorm-seeding/commit/2d1d8986351ec647f88df7f3a72c37b149826fa3))
-
-# [2.0.0-next.1](https://github.com/jorgebodega/typeorm-seeding/compare/v1.6.2...v2.0.0-next.1) (2021-12-12)
-
+- adapt seeder to new schema ([aecf7b4](https://github.com/jorgebodega/typeorm-seeding/commit/aecf7b46d40221d00d11ae15d40e36bc8c3293c0))
+- remove factories option from config ([d66f0f1](https://github.com/jorgebodega/typeorm-seeding/commit/d66f0f184479eeca3fde1b3c5438ee17223ffa2f))
 
-* :construction_worker: ci: Add changes to how semantic-release work ([c4c34dd](https://github.com/jorgebodega/typeorm-seeding/commit/c4c34dd55882a445992882398c5da74459322a77))
+### chore
 
+- remove all faker usages from source folder ([1e14718](https://github.com/jorgebodega/typeorm-seeding/commit/1e1471829c4b707fa8f0c9cb44289438ea4a1f85))
+- remove faker from dependencies ([40f21c8](https://github.com/jorgebodega/typeorm-seeding/commit/40f21c86d5bab714581821f80480f091a91b6cf6))
 
 ### Features
 
-* add save options to create and createMany ([ca88005](https://github.com/jorgebodega/typeorm-seeding/commit/ca88005775d0aa37d1668d458ad17d260b192499))
-
+- adapt use seeders to new structure ([5bca471](https://github.com/jorgebodega/typeorm-seeding/commit/5bca471339a3f8ccdc461160eb3f6c7d551daeab))
+- move factory definition to new abstract class ([81ccdf6](https://github.com/jorgebodega/typeorm-seeding/commit/81ccdf6d295c9d36b68c803dffc197c84605a53b))
+- remove context from factories ([#23](https://github.com/jorgebodega/typeorm-seeding/issues/23)) ([b7ecba4](https://github.com/jorgebodega/typeorm-seeding/commit/b7ecba4d4064525cd4f02da783ef885a12af08a2))
+- remove deprecated elements ([d09e154](https://github.com/jorgebodega/typeorm-seeding/commit/d09e15479cbb49214a81ef5ef49bef6f6adce3a4))
+- remove factory helper methods and test associateds ([#30](https://github.com/jorgebodega/typeorm-seeding/issues/30)) ([3393724](https://github.com/jorgebodega/typeorm-seeding/commit/3393724fe85bb59437ea9b307768ac157d70ec19))
+- remove useFactories helper method ([#29](https://github.com/jorgebodega/typeorm-seeding/issues/29)) ([ddb5c2f](https://github.com/jorgebodega/typeorm-seeding/commit/ddb5c2f6576bdcde72cabb876a43013aff303e01))
+- seed command will execute now default seeder or seed param ([314d8c3](https://github.com/jorgebodega/typeorm-seeding/commit/314d8c30e3ec59cc02074a3846e5df773f337bc6))
 
 ### BREAKING CHANGES
 
-* just to enforce new major version
-
-# [2.0.0-next.1](https://github.com/jorgebodega/typeorm-seeding/compare/v1.6.2...v2.0.0-next.1) (2021-12-12)
-
-
-* :construction_worker: ci: Add changes to how semantic-release work ([c4c34dd](https://github.com/jorgebodega/typeorm-seeding/commit/c4c34dd55882a445992882398c5da74459322a77))
-
-
-### Features
-
-* add save options to create and createMany ([ca88005](https://github.com/jorgebodega/typeorm-seeding/commit/ca88005775d0aa37d1668d458ad17d260b192499))
-
-
-### BREAKING CHANGES
-
-* just to enforce new major version
-
-# [2.0.0-next.1](https://github.com/jorgebodega/typeorm-seeding/compare/v1.6.2...v2.0.0-next.1) (2021-12-12)
-
-
-* :construction_worker: ci: Add changes to how semantic-release work ([c4c34dd](https://github.com/jorgebodega/typeorm-seeding/commit/c4c34dd55882a445992882398c5da74459322a77))
-
-
-### Features
-
-* add save options to create and createMany ([ca88005](https://github.com/jorgebodega/typeorm-seeding/commit/ca88005775d0aa37d1668d458ad17d260b192499))
-
-
-### BREAKING CHANGES
-
-* just to enforce new major version
-
-# [2.0.0-next.1](https://github.com/jorgebodega/typeorm-seeding/compare/v1.6.2...v2.0.0-next.1) (2021-12-12)
-
-
-* :construction_worker: ci: Add changes to how semantic-release work ([c4c34dd](https://github.com/jorgebodega/typeorm-seeding/commit/c4c34dd55882a445992882398c5da74459322a77))
-
-
-### Features
-
-* add save options to create and createMany ([ca88005](https://github.com/jorgebodega/typeorm-seeding/commit/ca88005775d0aa37d1668d458ad17d260b192499))
+- `useSeeders` change its definition and is now incompatible with previous version
+- Faker is not available anymore as function param
+- Faker is removed from dependencies and now users must install it by themselves
+- Deprecated functions are removed
+- New abstract factory class is incompatible with previous version
+- `useFactories` will no longer be available as is useless in new architecture
+- Context is being removed from factories. This could break some applications that were using it
 
+# [2.0.0](https://github.com/jorgebodega/typeorm-seeding/compare/v1.6.2...v2.0.0) (2021-12-14)
 
 ### BREAKING CHANGES
 
-* just to enforce new major version
+- `useSeeders` has been renamed to `useFactories` to be more consistent with functionality
+- New `useSeeders` has been created. Returns every Seeder that complies glob pattern and could execute them.
+- `Seeder` is now an abstract class instead of an interface
+- `Seeder` must export default, as that is the one that is chosen on `useSeeder`
+- `tearDownDatabase` and `useRefreshDatabase` are deprecated

package/README.md

@@ -34,21 +34,23 @@
 
 <p align="center">
   <b>A delightful way to seed test data into your database.</b></br>
-  <span>Inspired by the awesome framework <a href="https://laravel.com/">laravel</a> in PHP and of the repositories from <a href="https://github.com/pleerock">pleerock</a></span></br>
+  <span>Inspired by the awesome framework <a href="https://laravel.com/">laravel</a> in PHP, <a href="https://mikro-orm.io/docs/next/seeding/">MikroORM seeding</a>  and the repositories from <a href="https://github.com/pleerock">pleerock</a></span></br>
+</p>
+
+<p align="center">
   <sub>Made with ❤️ by <a href="https://github.com/hirsch88">Gery Hirschfeld</a>, <a href="https://github.com/jorgebodega">Jorge Bodega</a> and <a href="https://github.com/w3tecch/typeorm-seeding/graphs/contributors">contributors</a></sub>
 </p>
 
 <br />
 
-## ❯ Table of contents
+## Additional contents
 
-- [Installation](#-installation)
-- [Introduction](#-introduction)
-- [Basic Seeder](#-basic-seeder)
-- [Using Entity Factory](#-using-entity-factory)
-- [Seeding Data in Testing](#-seeding-data-in-testing)
+- [Factory](#factory-1)
+- [Seeder](#seeder-1)
+- [CLI](#cli-configuration)
+- [Testing features](#testing-features)
 
-## ❯ Installation
+## Installation
 
 Before using this TypeORM extension please read the [TypeORM Getting Started](https://typeorm.io/#/) documentation. This explains how to setup a TypeORM project.
 
@@ -59,226 +61,118 @@ npm i [-D] @jorgebodega/typeorm-seeding
 yarn add [-D] @jorgebodega/typeorm-seeding
 ```
 
-Optional, install the type definitions of the `Faker` library.
-
-```bash
-npm install -D @types/faker
-```
-
 ### Configuration
 
-To configure the path to your seeds and factories change the TypeORM config file or use environment variables like TypeORM. If both are used the environment variables will be prioritized.
+To configure the path to your seeders change the TypeORM config file or use environment variables like TypeORM. If both are used the environment variables will be prioritized.
 
 **ormconfig.js**
 
-```JavaScript
+```typescript
 module.exports = {
   ...
-  seeds: ['src/seeds/**/*{.ts,.js}'],
-  factories: ['src/factories/**/*{.ts,.js}'],
+  seeders: ['src/seeds/**/*{.ts,.js}'],
+  defaultSeeder: RootSeeder,
+  ...
 }
 ```
 
 **.env**
 
 ```
-TYPEORM_SEEDING_FACTORIES=src/factories/**/*{.ts,.js}
-TYPEORM_SEEDING_SEEDS=src/seeds/**/*{.ts,.js}
-```
-
-### CLI Configuration
-
-Add the following scripts to your `package.json` file to configure the seed cli commands.
-
-```
-"scripts": {
-  "seed:config": "typeorm-seeding config",
-  "seed:run": "typeorm-seeding seed",
-  ...
-}
+TYPEORM_SEEDING_SEEDERS=src/seeds/**/*{.ts,.js}
+TYPEORM_SEEDING_DEFAULT_SEEDER=RootSeeder
 ```
 
-#### CLI Options
-
-| Option                 | Default               | Description                                                                  |
-| ---------------------- | --------------------- | ---------------------------------------------------------------------------- |
-| `--seed` or `-s`       | null                  | Option to specify a seeder class to run individually. (Only on seed command) |
-| `--connection` or `-c` | TypeORM default value | Name of the TypeORM connection. Required if there are multiple connections.  |
-| `--configName` or `-n` | TypeORM default value | Name to the TypeORM config file.                                             |
-| `--root` or `-r`       | TypeORM default value | Path to the TypeORM config file.                                             |
-
-## ❯ Introduction
+## Introduction
 
 Isn't it exhausting to create some sample data for your database, well this time is over!
 
-How does it work? Just create a entity factory for your entities (models) and a seed script.
+How does it work? Just create a entity factory and/or seed script.
 
 ### Entity
 
-First create your TypeORM entities.
-
 ```typescript
-// user.entity.ts
 @Entity()
-export class User {
+class User {
   @PrimaryGeneratedColumn('uuid') id: string
-  @Column({ nullable: true }) name: string
-  @Column({ type: 'varchar', length: 100, nullable: false }) password: string
-  @OneToMany((type) => Pet, (pet) => pet.user) pets: Pet[]
-
-  @BeforeInsert()
-  async setPassword(password: string) {
-    const salt = await bcrypt.genSalt()
-    this.password = await bcrypt.hash(password || this.password, salt)
-  }
-}
 
-// pet.entity.ts
-@Entity()
-export class Pet {
-  @PrimaryGeneratedColumn('uuid') id: string
   @Column() name: string
-  @Column() age: number
-  @ManyToOne((type) => User, (user) => user.pets)
-  @JoinColumn({ name: 'user_id' })
-  user: User
+
+  @Column() lastname: string
 }
 ```
 
 ### Factory
 
-Then for each entity define a factory. The purpose of a factory is to create new entites with generate data.
-
-> Note: Factories can also be used to generate data for testing.
-
 ```typescript
-// user.factory.ts
-define(User, (faker: typeof Faker) => {
-  const gender = faker.datatype.number(1)
-  const firstName = faker.name.firstName(gender)
-  const lastName = faker.name.lastName(gender)
+class UserFactory extends Factory<User> {
+  protected definition(): User {
+    const user = new User()
 
-  const user = new User()
-  user.name = `${firstName} ${lastName}`
-  user.password = faker.random.word()
-  return user
-})
-
-// pet.factory.ts
-define(Pet, (faker: typeof Faker) => {
-  const gender = faker.datatype.number(1)
-  const name = faker.name.firstName(gender)
+    user.name = 'John'
+    user.lastname = 'Doe'
 
-  const pet = new Pet()
-  pet.name = name
-  pet.age = faker.datatype.number()
-  pet.user = factory(User)() as any
-  return pet
-})
+    return user
+  }
+}
 ```
 
 ### Seeder
 
-And last but not least, create a seeder. The seeder can be called by the configured cli command `seed:run`. In this case it generates 10 pets with a owner (User).
-
-> Note: `seed:run` must be configured first. Go to [CLI Configuration](#cli-configuration).
-
 ```typescript
-// create-pets.seed.ts
-export default class CreatePets implements Seeder {
-  public async run(factory: Factory, connection: Connection): Promise<any> {
-    await factory(Pet)().createMany(10)
+export class UserExampleSeeder extends Seeder {
+  async run() {
+    await new UserFactory().create({
+      name: 'Jane',
+    })
   }
 }
 ```
 
-Until [this issue](https://github.com/w3tecch/typeorm-seeding/issues/119) is closed, seeder files must not contain any other export statement besides the one that exports the seeder class.
-
-## ❯ Basic Seeder
+## Factory
 
-A seeder class only use `run` method. Within this method, you may insert data into your database. For manually insertion use the [Query Builder](https://typeorm.io/#/select-query-builder) or use the [Entity Factory](#-using-entity-factory)
-
-> Note. The seeder files will be executed alphabetically.
+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
-export default class CreateUsers implements Seeder {
-  public async run(factory: EntityFactory, connection: Connection): Promise<any> {
-    await connection
-      .createQueryBuilder()
-      .insert()
-      .into(User)
-      .values([
-        { firstName: 'Timber', lastName: 'Saw' },
-        { firstName: 'Phantom', lastName: 'Lancer' },
-      ])
-      .execute()
+class UserFactory extends Factory<User> {
+  protected definition(): User {
+    ...
   }
 }
 ```
 
-## ❯ Using Entity Factory
-
-Of course, manually specifying the attributes for each entity seed is cumbersome. Instead, you can use entity factories to conveniently generate large amounts of database records.
-
-For all entities we want to create, we need to define a factory. To do so we give you the awesome [faker](https://github.com/marak/Faker.js/) library as a parameter into your factory. Then create your "fake" entity and return it. Those factory files should be in the `src/database/factories` folder and suffixed with `.factory` like `src/database/factories/user.factory.ts`.
-
-| Types           | Description                                                                     |
-| --------------- | ------------------------------------------------------------------------------- |
-| `Entity`        | TypeORM Entity like the user or the pet in the samples.                         |
-| `Context`       | Argument to pass some static data into the factory function.                    |
-| `EntityFactory` | This object is used to make new filled entities or create it into the database. |
-
-### `define`
-
-The define function creates a new entity factory.
+### `definition`
 
-```typescript
-define: <Entity, Context>(entity: Entity, factoryFn: FactoryFunction<Entity, Context>) => void;
-```
+This function is the one that needs to be defined when extending the class. It is called to instantiate the entity and the result will be used on the rest of factory lifecycle.
 
 ```typescript
-define(User, (faker: typeof Faker, context: { roles: string[] }) => {
-  const user = new User()
-  ...
-  return user
-})
-```
-
-### `factory`
-
-Factory retrieves the defined factory function and returns the EntityFactory to start creating new enities.
+protected definition(): User {
+    const user = new User()
 
-```typescript
-factory: (entity: Entity) => (context?: Context) => Factory<Entity, Context>
-```
+    user.name = 'John'
+    user.lastname = 'Doe'
 
-```typescript
-factory(Pet)()
-factory(Pet)({ name: 'Balou' })
+    return user
+}
 ```
 
-### Factory
+It is possible to create more than one factory related to a single entity, with different definition functions.
 
-#### `map`
+### `map`
 
 Use the `.map()` function to alter the generated value before they get processed.
 
 ```typescript
-map(mapFunction: (entity: Entity) => Promise<Entity>): Factory<Entity, Context>
+map(mapFunction: (entity: Entity) => void): Factory
 ```
 
 ```typescript
-await factory(User)()
-  .map(async (user: User) => {
-    const pets: Pet[] = await factory(Pet)().createMany(2)
-    const petIds = pets.map((pet: Pet) => pet.Id)
-    await user.pets().attach(petIds)
-    return user
-  })
-  .createMany(5)
+new UserFactory().map((user) => {
+  user.name = 'Jane'
+})
 ```
 
-#### `make` & `makeMany`
+### `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.
 
@@ -290,15 +184,15 @@ makeMany(amount: number, overrideParams: Partial<Entity> = {}): Promise<Entity>
 ```
 
 ```typescript
-await factory(User)().make()
-await factory(User)().makeMany(10)
+new UserFactory().make()
+new UserFactory().makeMany(10)
 
 // override the email
-await factory(User)().make({ email: 'other@mail.com' })
-await factory(User)().makeMany(10, { email: 'other@mail.com' })
+new UserFactory().make({ email: 'other@mail.com' })
+new UserFactory().makeMany(10, { email: 'other@mail.com' })
 ```
 
-#### `create` & `createMany`
+### `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.
 
@@ -311,64 +205,177 @@ createMany(amount: number, overrideParams: Partial<Entity> = {}, saveOptions?: S
 ```
 
 ```typescript
-await factory(User)().create()
-await factory(User)().createMany(10)
+new UserFactory().create()
+new UserFactory().createMany(10)
 
 // override the email
-await factory(User)().create({ email: 'other@mail.com' })
-await factory(User)().createMany(10, { email: 'other@mail.com' })
+new UserFactory().create({ email: 'other@mail.com' })
+new UserFactory().createMany(10, { email: 'other@mail.com' })
 
 // using save options
-await factory(User)().create({ email: 'other@mail.com' }, { listeners: false })
-await factory(User)().createMany(10, { email: 'other@mail.com' }, { listeners: false })
+new UserFactory().create({ email: 'other@mail.com' }, { listeners: false })
+new UserFactory().createMany(10, { email: 'other@mail.com' }, { listeners: false })
 ```
 
-#### Execution order
+### Execution order
 
 As the order of execution can be complex, you can check it here:
 
-1. **Context**: The context is used when the entity is being created
 2. **Map function**: Map function alters the already existing entity.
 3. **Override params**: Alters the already existing entity.
 4. **Promises**: If some attribute is a promise, the promise will be resolved before the entity is created.
 5. **Factories**: If some attribute is a factory, the factory will be executed with `make`/`create` like the previous one.
 
-## ❯ Seeding Data in Testing
+### Faker
 
-The entity factories can also be used in testing. To do so call the `useFactories` or `useSeeders` function.
+[Faker](https://github.com/marak/Faker.js/) package was previously a dependency of the project, but now it is optional due to its size. If you want to use faker, you may need to install it and import it.
 
-### `useFactories`
+Instead of the previous example:
 
-Loads the defined entity factories.
+```typescript
+define(User, (faker: typeof Faker) => {
+  const firstName = faker.name.firstName()
+  const lastName = faker.name.lastName()
+
+  const user = new User()
+  user.name = `${firstName} ${lastName}`
+  return user
+})
+```
+
+You can do:
 
 ```typescript
-useFactories(options?: Partial<ConnectionConfiguration>): Promise<void>
-useFactories(seeders?: string[], options?: Partial<ConnectionConfiguration>): Promise<void>
+import * as faker from 'faker'
+
+class UserFactory extends Factory<User> {
+  protected definition(): User {
+    const user = new User()
+
+    user.name = faker.name.firstName()
+    user.lastname = faker.name.lastName()
+
+    return user
+  }
+}
 ```
 
-### `useSeeders`
+## Seeder
 
-Loads the seeders, and could execute them.
+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
-useSeeders(executeSeeders?: boolean, options?: Partial<ConnectionConfiguration>): Promise<Seeder[]>
-useSeeders(executeSeeders?: boolean, seeders?: string[], options?: Partial<ConnectionConfiguration>): Promise<Seeder[]>
+class UserSeeder extends Seeder {
+  async run(connection: Connection) {
+    ...
+  }
+}
 ```
 
-### `runSeeder`
+### `run`
 
-Runs the given seeder class.
+This function is the one that needs to be defined when extending the class. Could use `call` to run some other seeders.
 
 ```typescript
-runSeeder(seeder: Seeder): Promise<void>
+run(connection: Connection): Promise<void>
 ```
 
-### `ConnectionConfiguration`
-
 ```typescript
-interface ConnectionConfiguration {
-  root?: string // path to the orm config file. Default = process.cwd()
-  configName?: string // name of the config file. eg. ormconfig.js
-  connection = 'default' // name of the database connection.
+async run(connection: Connection) {
+    await new UserFactory().createMany(10)
+
+    await this.call(connection, [PetSeeder])
+}
+```
+
+### `call`
+
+This function allow to run some other seeders in a sequential way.
+
+In order to use seeders from cli command, a default seeder class must be provided as root seeder, working as a tree structure.
+
+<p align="center">
+  <img src="./seeders.png" alt="logo" />
+</p>
+
+## CLI Configuration
+
+There are two possible commands to execute, one to see the current configuration and one to run a seeder.
+
+Add the following scripts to your `package.json` file to configure them.
+
+```json
+"scripts": {
+  "seed:config": "typeorm-seeding config",
+  "seed:run": "typeorm-seeding seed",
+  ...
 }
 ```
+
+### `config`
+
+This command just print the connection configuration.
+
+```bash
+typeorm-seeding config
+```
+
+Example result
+
+```json
+{
+  "name": "default",
+  "type": "sqlite",
+  "database": "/home/jorgebodega/projects/typeorm-seeding/test.db",
+  "entities": ["sample/entities/**/*{.ts,.js}"],
+  "seeders": ["sample/seeders/**/*{.ts,.js}"],
+  "defaultSeeder": "RootSeeder"
+}
+```
+
+##### Options
+
+| Option                 | Default               | Description                                                                  |
+| ---------------------- | --------------------- | ---------------------------------------------------------------------------- |
+| `--seed` or `-s`       | null                  | Option to specify a seeder class to run individually. (Only on seed command) |
+| `--connection` or `-c` | TypeORM default value | Name of the TypeORM connection. Required if there are multiple connections.  |
+| `--configName` or `-n` | TypeORM default value | Name to the TypeORM config file.                                             |
+| `--root` or `-r`       | TypeORM default value | Path to the TypeORM config file.                                             |
+
+### `seed`
+
+This command execute a seeder, that could be specified as a parameter.
+
+```bash
+typeorm-seeding seed
+```
+
+##### Options
+
+| Option                 | Default                              | Description                                                                 |
+| ---------------------- | ------------------------------------ | --------------------------------------------------------------------------- |
+| `--seed` or `-s`       | Default seeder specified config file | Option to specify a seeder class to run individually.                       |
+| `--connection` or `-c` | TypeORM default value                | Name of the TypeORM connection. Required if there are multiple connections. |
+| `--configName` or `-n` | TypeORM default value                | Name to the TypeORM config file.                                            |
+| `--root` or `-r`       | TypeORM default value                | Path to the TypeORM config file.                                            |
+
+## Testing features
+
+We provide some testing features that we already use to test this package, like connection configuration.
+The entity factories can also be used in testing. To do so call the `useFactories` or `useSeeders` function.
+
+### `useSeeders`
+
+Execute one or more seeders.
+
+```typescript
+useSeeders(entrySeeders: ClassConstructor<Seeder> | ClassConstructor<Seeder>[]): Promise<void>
+useSeeders(
+  entrySeeders: ClassConstructor<Seeder> | ClassConstructor<Seeder>[],
+  customOptions: Partial<ConnectionConfiguration>,
+): Promise<void>
+```
+
+### Factories
+
+If factories are being used to create entities, just remember to clean up fake data after every execution.

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

@@ -7,6 +7,9 @@ interface ConfigCommandArguments extends Arguments {
 export declare class ConfigCommand implements CommandModule {
     command: string;
     describe: string;
+    /**
+     * @inheritdoc
+     */
     builder(args: Argv): Argv<{
         n: string | undefined;
     } & {
@@ -14,6 +17,9 @@ export declare class ConfigCommand implements CommandModule {
     } & {
         r: string | undefined;
     }>;
+    /**
+     * @inheritdoc
+     */
     handler(args: ConfigCommandArguments): Promise<void>;
 }
 export {};