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

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+## [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)
+
+
+### Bug Fixes
+
+* no application seeds ([30f82f6](https://github.com/jorgebodega/typeorm-seeding/commit/30f82f6c3f3c5c249ed32c78452f066cc7c1ab06))
+
 ## [5.0.1-next.1](https://github.com/jorgebodega/typeorm-seeding/compare/v5.0.0...v5.0.1-next.1) (2022-08-17)
 
 

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,21 +28,9 @@
 
 # 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)
-  - [faker](#faker)
 - [Seeder](#seeder-1)
   - [run](#run)
-  - [call](#call)
 - [CLI](#cli-configuration)
-  - [config](#config)
   - [seed](#seed)
 - [Testing features](#testing-features)
 
@@ -72,29 +43,9 @@ After that install the extension with `npm` or `yarn`. Add development flag if y
 ```bash
 npm i [-D] @jorgebodega/typeorm-seeding
 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
 
@@ -128,243 +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 })
-```
-
-## faker
-
-[Faker](https://github.com/faker-js/faker) package has been removed from `dependencies`. If you want to use it, please install it manually and just import when needed.
-
-```bash
-npm i [-D] @faker-js/faker
-yarn add [-D] @faker-js/faker
-```
-
-```typescript
-import { faker } from '@faker-js/faker'
-
-class UserFactory extends Factory<User> {
-  ...
-}
-```
-
 # 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) {
     ...
   }
 }
@@ -372,61 +104,51 @@ 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)
 }
 ```
 
-## `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.
+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
+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
 
 | Option                 | Default                              | Description                                           |
 | ---------------------- | ------------------------------------ | ----------------------------------------------------- |
-| `--seed` or `-s`       | Default seeder specified config file | Option to specify a seeder class to run individually. |
 | `--dataSource` or `-d` |                                      | Path of the data source                               |
-| `--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
 
@@ -444,3 +166,22 @@ useSeeders(
   customOptions: Partial<ConnectionConfiguration>,
 ): Promise<void>
 ```
+
+## `useDataSource`
+
+Use specific data source on the factories. If the data source is not initialized when provided, can be initialized with the `forceInitialization` flag.
+
+```typescript
+useDataSource(dataSource: DataSource): Promise<void>
+useDataSource(dataSource: DataSource, overrideOptions: Partial<DataSourceOptions>): Promise<void>
+useDataSource(dataSource: DataSource, forceInitialization: boolean): Promise<void>
+useDataSource(
+  dataSource: DataSource,
+  overrideOptions: Partial<DataSourceOptions>,
+  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>;