From c8f64df7e1f69ee8c0973baf7fe3acfea4403bcf Mon Sep 17 00:00:00 2001 From: Jorge Bodega Fernanz Date: Sat, 22 Jun 2024 13:38:00 +0200 Subject: [PATCH] feat: add biome instead of prettier and eslint (#178) --- .eslintrc.json | 34 - .github/renovate.json | 38 +- .gitignore | 6 + .npmignore | 3 +- .prettierrc | 8 - .releaserc.json | 70 +- biome.json | 17 + examples/1-to-1-chained-related/dataSource.ts | 10 +- .../entities/Pet.entity.ts | 32 +- .../entities/Refuge.entity.ts | 22 +- .../entities/User.entity.ts | 32 +- .../factories/Pet.factory.ts | 36 +- .../factories/Refuge.factory.ts | 26 +- .../factories/User.factory.ts | 28 +- .../test/PetFactory.test.ts | 298 ++-- .../test/RefugeFactory.test.ts | 263 +-- .../test/UserFactory.test.ts | 304 ++-- .../1-to-1-nullable-related/dataSource.ts | 10 +- .../entities/Pet.entity.ts | 22 +- .../entities/User.entity.ts | 32 +- .../factories/Pet.factory.ts | 26 +- .../factories/User.factory.ts | 24 +- .../test/PetFactory.test.ts | 202 +-- .../test/UserFactory.test.ts | 430 ++--- examples/1-to-1-related/dataSource.ts | 10 +- .../1-to-1-related/entities/Pet.entity.ts | 22 +- .../1-to-1-related/entities/User.entity.ts | 32 +- .../1-to-1-related/factories/Pet.factory.ts | 26 +- .../1-to-1-related/factories/User.factory.ts | 28 +- .../1-to-1-related/test/PetFactory.test.ts | 202 +-- .../1-to-1-related/test/UserFactory.test.ts | 260 +-- examples/1-to-N-related/dataSource.ts | 10 +- .../1-to-N-related/entities/Pet.entity.ts | 22 +- .../1-to-N-related/entities/User.entity.ts | 32 +- .../1-to-N-related/factories/Pet.factory.ts | 26 +- .../1-to-N-related/factories/User.factory.ts | 26 +- .../1-to-N-related/test/PetFactory.test.ts | 202 +-- .../1-to-N-related/test/UserFactory.test.ts | 454 ++--- examples/N-to-M-related/dataSource.ts | 10 +- .../N-to-M-related/entities/Pet.entity.ts | 19 +- .../N-to-M-related/entities/User.entity.ts | 47 +- .../N-to-M-related/factories/Pet.factory.ts | 24 +- .../N-to-M-related/factories/User.factory.ts | 26 +- .../N-to-M-related/test/PetFactory.test.ts | 502 +++--- .../N-to-M-related/test/UserFactory.test.ts | 486 ++--- examples/single-entity/dataSource.ts | 10 +- .../single-entity/entities/User.entity.ts | 22 +- .../single-entity/factories/User.factory.ts | 24 +- .../single-entity/test/UserFactory.test.ts | 180 +- jest.config.ts | 8 +- package.json | 113 +- pnpm-lock.yaml | 1581 +---------------- src/factory.ts | 229 +-- src/index.ts | 8 +- .../eagerInstanceAttribute.ts | 2 +- src/instanceAttributes/index.ts | 6 +- src/instanceAttributes/instanceAttribute.ts | 10 +- .../lazyInstanceAttribute.ts | 2 +- src/subfactories/baseSubfactory.ts | 24 +- src/subfactories/collectionSubfactory.ts | 32 +- src/subfactories/index.ts | 6 +- src/subfactories/singleSubfactory.ts | 20 +- src/types.ts | 20 +- test/factory.test.ts | 647 +++---- test/fixtures/Pet.entity.ts | 21 +- test/fixtures/Pet.factory.ts | 30 +- test/fixtures/User.entity.ts | 43 +- test/fixtures/User.factory.ts | 32 +- test/fixtures/dataSource.ts | 10 +- tsconfig.build.json | 25 +- tsconfig.json | 57 +- 71 files changed, 3123 insertions(+), 4478 deletions(-) delete mode 100644 .eslintrc.json delete mode 100644 .prettierrc create mode 100644 biome.json diff --git a/.eslintrc.json b/.eslintrc.json deleted file mode 100644 index 10ddb0c..0000000 --- a/.eslintrc.json +++ /dev/null @@ -1,34 +0,0 @@ -{ - "env": { - "jest": true, - "node": true - }, - "extends": [ - "eslint:recommended", - "plugin:@typescript-eslint/recommended", - "plugin:import/recommended", - "plugin:import/typescript", - "prettier" - ], - "parser": "@typescript-eslint/parser", - "parserOptions": { - "project": "tsconfig.json", - "sourceType": "module" - }, - "plugins": [ - "@typescript-eslint" - ], - "rules": { - "@typescript-eslint/interface-name-prefix": "off", - "@typescript-eslint/explicit-function-return-type": "off", - "@typescript-eslint/no-explicit-any": "off", - "import/order": [ - "warn", - { - "alphabetize": { - "order": "asc" - } - } - ] - } -} \ No newline at end of file diff --git a/.github/renovate.json b/.github/renovate.json index 45a4e72..243b8d9 100644 --- a/.github/renovate.json +++ b/.github/renovate.json @@ -1,21 +1,21 @@ { - "extends": [ - "config:base", - "group:allNonMajor", - "schedule:monthly", - ":assignAndReview(jorgebodega)", - ":automergeDisabled", - ":semanticCommits", - ":semanticCommitScopeDisabled", - ":separatePatchReleases", - ":timezone(UTC+1)" - ], - "baseBranches": ["next"], - "packageRules": [ - { - "matchPackagePatterns": ["typeorm"], - "groupName": "typeorm", - "automerge": false - } - ] + "extends": [ + "config:base", + "group:allNonMajor", + "schedule:monthly", + ":assignAndReview(jorgebodega)", + ":automergeDisabled", + ":semanticCommits", + ":semanticCommitScopeDisabled", + ":separatePatchReleases", + ":timezone(UTC+1)" + ], + "baseBranches": ["next"], + "packageRules": [ + { + "matchPackagePatterns": ["typeorm"], + "groupName": "typeorm", + "automerge": false + } + ] } diff --git a/.gitignore b/.gitignore index 0374464..030f53a 100644 --- a/.gitignore +++ b/.gitignore @@ -6,3 +6,9 @@ test.db ### node ### node_modules + +# IDE +.vscode/* +!.vscode/extensions.json +!.vscode/launch.json +!.vscode/settings.json diff --git a/.npmignore b/.npmignore index 7329482..d59567c 100644 --- a/.npmignore +++ b/.npmignore @@ -1,11 +1,10 @@ .commitlintrc -.eslintrc.js .github .node-version -.prettierrc .releaserc.json .sgcrc .vscode +biome.json examples jest.config.ts src diff --git a/.prettierrc b/.prettierrc deleted file mode 100644 index 1bb5f91..0000000 --- a/.prettierrc +++ /dev/null @@ -1,8 +0,0 @@ -{ - "singleQuote": true, - "semi": false, - "trailingComma": "all", - "tabWidth": 2, - "bracketSameLine": true, - "printWidth": 120 -} diff --git a/.releaserc.json b/.releaserc.json index 986af24..5d5d2fb 100644 --- a/.releaserc.json +++ b/.releaserc.json @@ -1,37 +1,37 @@ { - "branches": ["main", { "name": "next", "channel": "next", "prerelease": true }], - "plugins": [ - [ - "@semantic-release/commit-analyzer", - { - "releaseRules": [{ "type": "chore", "release": "patch" }], - "parserOpts": { - "noteKeywords": ["BREAKING CHANGE", "BREAKING CHANGES"] - } - } - ], - [ - "@semantic-release/release-notes-generator", - { - "parserOpts": { - "noteKeywords": ["BREAKING CHANGE", "BREAKING CHANGES"] - } - } - ], - [ - "@semantic-release/changelog", - { - "changelogFile": "CHANGELOG.md" - } - ], - "@semantic-release/npm", - [ - "@semantic-release/git", - { - "assets": ["package.json", "pnpm-lock.yaml", "CHANGELOG.md"], - "message": "chore: release ${nextRelease.version}\n\n${nextRelease.notes}" - } - ], - ["@semantic-release/github", { "successComment": false, "failComment": false, "failTitle": false }] - ] + "branches": ["main", { "name": "next", "channel": "next", "prerelease": true }], + "plugins": [ + [ + "@semantic-release/commit-analyzer", + { + "releaseRules": [{ "type": "chore", "release": "patch" }], + "parserOpts": { + "noteKeywords": ["BREAKING CHANGE", "BREAKING CHANGES"] + } + } + ], + [ + "@semantic-release/release-notes-generator", + { + "parserOpts": { + "noteKeywords": ["BREAKING CHANGE", "BREAKING CHANGES"] + } + } + ], + [ + "@semantic-release/changelog", + { + "changelogFile": "CHANGELOG.md" + } + ], + "@semantic-release/npm", + [ + "@semantic-release/git", + { + "assets": ["package.json", "pnpm-lock.yaml", "CHANGELOG.md"], + "message": "chore: release ${nextRelease.version}\n\n${nextRelease.notes}" + } + ], + ["@semantic-release/github", { "successComment": false, "failComment": false, "failTitle": false }] + ] } diff --git a/biome.json b/biome.json new file mode 100644 index 0000000..4e8bd21 --- /dev/null +++ b/biome.json @@ -0,0 +1,17 @@ +{ + "$schema": "https://biomejs.dev/schemas/1.8.2/schema.json", + "formatter": { + "ignore": ["**/dist/**"], + "lineWidth": 120 + }, + "linter": { + "enabled": true, + "ignore": ["**/dist/**"], + "rules": { + "recommended": true + } + }, + "organizeImports": { + "enabled": true + } +} diff --git a/examples/1-to-1-chained-related/dataSource.ts b/examples/1-to-1-chained-related/dataSource.ts index 814a18c..20429aa 100644 --- a/examples/1-to-1-chained-related/dataSource.ts +++ b/examples/1-to-1-chained-related/dataSource.ts @@ -1,7 +1,7 @@ -import { DataSource } from 'typeorm' +import { DataSource } from "typeorm"; export const dataSource = new DataSource({ - type: 'sqlite', - database: ':memory:', - entities: [`${__dirname}/**/*.entity.ts`], -}) + type: "sqlite", + database: ":memory:", + entities: [`${__dirname}/**/*.entity.ts`], +}); diff --git a/examples/1-to-1-chained-related/entities/Pet.entity.ts b/examples/1-to-1-chained-related/entities/Pet.entity.ts index 9d966f5..824d1e0 100644 --- a/examples/1-to-1-chained-related/entities/Pet.entity.ts +++ b/examples/1-to-1-chained-related/entities/Pet.entity.ts @@ -1,19 +1,27 @@ -import { Entity, PrimaryGeneratedColumn, Column, JoinColumn, OneToOne } from 'typeorm' -import { Refuge } from './Refuge.entity' -import { User } from './User.entity' +import { Entity, PrimaryGeneratedColumn, Column, JoinColumn, OneToOne } from "typeorm"; +import { Refuge } from "./Refuge.entity"; +import { User } from "./User.entity"; @Entity() export class Pet { - @PrimaryGeneratedColumn('increment') - id!: string + @PrimaryGeneratedColumn("increment") + id!: string; - @Column() - name!: string + @Column() + name!: string; - @OneToOne(() => User, (user) => user.pet, { nullable: false }) - @JoinColumn({ name: 'owner_id' }) - owner!: User + @OneToOne( + () => User, + (user) => user.pet, + { nullable: false }, + ) + @JoinColumn({ name: "owner_id" }) + owner!: User; - @OneToOne(() => Refuge, (refuge) => refuge.pet, { nullable: false }) - refuge!: Refuge + @OneToOne( + () => Refuge, + (refuge) => refuge.pet, + { nullable: false }, + ) + refuge!: Refuge; } diff --git a/examples/1-to-1-chained-related/entities/Refuge.entity.ts b/examples/1-to-1-chained-related/entities/Refuge.entity.ts index d707da2..fcaad34 100644 --- a/examples/1-to-1-chained-related/entities/Refuge.entity.ts +++ b/examples/1-to-1-chained-related/entities/Refuge.entity.ts @@ -1,15 +1,19 @@ -import { Entity, PrimaryGeneratedColumn, Column, JoinColumn, OneToOne } from 'typeorm' -import { Pet } from './Pet.entity' +import { Entity, PrimaryGeneratedColumn, Column, JoinColumn, OneToOne } from "typeorm"; +import { Pet } from "./Pet.entity"; @Entity() export class Refuge { - @PrimaryGeneratedColumn('increment') - id!: string + @PrimaryGeneratedColumn("increment") + id!: string; - @Column() - name!: string + @Column() + name!: string; - @OneToOne(() => Pet, (pet) => pet.refuge, { nullable: false }) - @JoinColumn({ name: 'pet_id' }) - pet!: Pet + @OneToOne( + () => Pet, + (pet) => pet.refuge, + { nullable: false }, + ) + @JoinColumn({ name: "pet_id" }) + pet!: Pet; } diff --git a/examples/1-to-1-chained-related/entities/User.entity.ts b/examples/1-to-1-chained-related/entities/User.entity.ts index 0d58bf2..63b63b9 100644 --- a/examples/1-to-1-chained-related/entities/User.entity.ts +++ b/examples/1-to-1-chained-related/entities/User.entity.ts @@ -1,23 +1,27 @@ -import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn, OneToOne } from 'typeorm' -import { Pet } from './Pet.entity' +import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn, OneToOne } from "typeorm"; +import { Pet } from "./Pet.entity"; @Entity() export class User { - @PrimaryGeneratedColumn('increment') - id!: number + @PrimaryGeneratedColumn("increment") + id!: number; - @CreateDateColumn({ name: 'created_at' }) - createdAt!: Date + @CreateDateColumn({ name: "created_at" }) + createdAt!: Date; - @UpdateDateColumn({ name: 'updated_at' }) - updatedAt!: Date + @UpdateDateColumn({ name: "updated_at" }) + updatedAt!: Date; - @Column() - name!: string + @Column() + name!: string; - @Column({ name: 'last_name' }) - lastName!: string + @Column({ name: "last_name" }) + lastName!: string; - @OneToOne(() => Pet, (pet) => pet.owner, { nullable: false }) - pet!: Pet + @OneToOne( + () => Pet, + (pet) => pet.owner, + { nullable: false }, + ) + pet!: Pet; } diff --git a/examples/1-to-1-chained-related/factories/Pet.factory.ts b/examples/1-to-1-chained-related/factories/Pet.factory.ts index 7b2a559..82a4f3d 100644 --- a/examples/1-to-1-chained-related/factories/Pet.factory.ts +++ b/examples/1-to-1-chained-related/factories/Pet.factory.ts @@ -1,19 +1,25 @@ -import { faker } from '@faker-js/faker' -import { EagerInstanceAttribute, FactorizedAttrs, Factory, LazyInstanceAttribute, SingleSubfactory } from '../../../src' -import { dataSource } from '../dataSource' -import { Pet } from '../entities/Pet.entity' -import { RefugeFactory } from './Refuge.factory' -import { UserFactory } from './User.factory' +import { faker } from "@faker-js/faker"; +import { + EagerInstanceAttribute, + type FactorizedAttrs, + Factory, + LazyInstanceAttribute, + SingleSubfactory, +} from "../../../src"; +import { dataSource } from "../dataSource"; +import { Pet } from "../entities/Pet.entity"; +import { RefugeFactory } from "./Refuge.factory"; +import { UserFactory } from "./User.factory"; export class PetFactory extends Factory { - protected entity = Pet - protected dataSource = dataSource + protected entity = Pet; + protected dataSource = dataSource; - protected attrs(): FactorizedAttrs { - return { - name: faker.animal.insect(), - owner: new EagerInstanceAttribute((instance) => new SingleSubfactory(UserFactory, { pet: instance })), - refuge: new LazyInstanceAttribute((instance) => new SingleSubfactory(RefugeFactory, { pet: instance })), - } - } + protected attrs(): FactorizedAttrs { + return { + name: faker.animal.insect(), + owner: new EagerInstanceAttribute((instance) => new SingleSubfactory(UserFactory, { pet: instance })), + refuge: new LazyInstanceAttribute((instance) => new SingleSubfactory(RefugeFactory, { pet: instance })), + }; + } } diff --git a/examples/1-to-1-chained-related/factories/Refuge.factory.ts b/examples/1-to-1-chained-related/factories/Refuge.factory.ts index 6dcf880..8c9d41f 100644 --- a/examples/1-to-1-chained-related/factories/Refuge.factory.ts +++ b/examples/1-to-1-chained-related/factories/Refuge.factory.ts @@ -1,17 +1,17 @@ -import { faker } from '@faker-js/faker' -import { EagerInstanceAttribute, FactorizedAttrs, Factory, SingleSubfactory } from '../../../src' -import { dataSource } from '../dataSource' -import { Refuge } from '../entities/Refuge.entity' -import { PetFactory } from './Pet.factory' +import { faker } from "@faker-js/faker"; +import { EagerInstanceAttribute, type FactorizedAttrs, Factory, SingleSubfactory } from "../../../src"; +import { dataSource } from "../dataSource"; +import { Refuge } from "../entities/Refuge.entity"; +import { PetFactory } from "./Pet.factory"; export class RefugeFactory extends Factory { - protected entity = Refuge - protected dataSource = dataSource + protected entity = Refuge; + protected dataSource = dataSource; - protected attrs(): FactorizedAttrs { - return { - name: faker.company.name(), - pet: new EagerInstanceAttribute((instance) => new SingleSubfactory(PetFactory, { refuge: instance })), - } - } + protected attrs(): FactorizedAttrs { + return { + name: faker.company.name(), + pet: new EagerInstanceAttribute((instance) => new SingleSubfactory(PetFactory, { refuge: instance })), + }; + } } diff --git a/examples/1-to-1-chained-related/factories/User.factory.ts b/examples/1-to-1-chained-related/factories/User.factory.ts index 71f24c7..238eeb9 100644 --- a/examples/1-to-1-chained-related/factories/User.factory.ts +++ b/examples/1-to-1-chained-related/factories/User.factory.ts @@ -1,18 +1,18 @@ -import { faker } from '@faker-js/faker' -import { FactorizedAttrs, Factory, LazyInstanceAttribute, SingleSubfactory } from '../../../src' -import { dataSource } from '../dataSource' -import { User } from '../entities/User.entity' -import { PetFactory } from './Pet.factory' +import { faker } from "@faker-js/faker"; +import { type FactorizedAttrs, Factory, LazyInstanceAttribute, SingleSubfactory } from "../../../src"; +import { dataSource } from "../dataSource"; +import { User } from "../entities/User.entity"; +import { PetFactory } from "./Pet.factory"; export class UserFactory extends Factory { - protected entity = User - protected dataSource = dataSource + protected entity = User; + protected dataSource = dataSource; - protected attrs(): FactorizedAttrs { - return { - name: faker.person.firstName(), - lastName: faker.person.lastName(), - pet: new LazyInstanceAttribute((instance) => new SingleSubfactory(PetFactory, { owner: instance })), - } - } + protected attrs(): FactorizedAttrs { + return { + name: faker.person.firstName(), + lastName: faker.person.lastName(), + pet: new LazyInstanceAttribute((instance) => new SingleSubfactory(PetFactory, { owner: instance })), + }; + } } diff --git a/examples/1-to-1-chained-related/test/PetFactory.test.ts b/examples/1-to-1-chained-related/test/PetFactory.test.ts index 707043c..f65b310 100644 --- a/examples/1-to-1-chained-related/test/PetFactory.test.ts +++ b/examples/1-to-1-chained-related/test/PetFactory.test.ts @@ -1,150 +1,152 @@ -import { dataSource } from '../dataSource' -import { Pet } from '../entities/Pet.entity' -import { Refuge } from '../entities/Refuge.entity' -import { User } from '../entities/User.entity' -import { PetFactory } from '../factories/Pet.factory' +import { dataSource } from "../dataSource"; +import { Pet } from "../entities/Pet.entity"; +import { Refuge } from "../entities/Refuge.entity"; +import { User } from "../entities/User.entity"; +import { PetFactory } from "../factories/Pet.factory"; describe(PetFactory, () => { - const factory = new PetFactory() - - describe(PetFactory.prototype.make, () => { - test('Should make a new entity', async () => { - const petMaked = await factory.make() - - expect(petMaked).toBeInstanceOf(Pet) - expect(petMaked.id).toBeUndefined() - expect(petMaked.name).toBeDefined() - - expect(petMaked.refuge).toBeInstanceOf(Refuge) - expect(petMaked.refuge.id).toBeUndefined() - expect(petMaked.refuge.name).toBeDefined() - - expect(petMaked.owner).toBeInstanceOf(User) - expect(petMaked.owner.id).toBeUndefined() - expect(petMaked.owner.name).toBeDefined() - }) - - test('Should make two entities with different attributes', async () => { - const petMaked1 = await factory.make() - const petMaked2 = await factory.make() - - expect(petMaked1).not.toStrictEqual(petMaked2) - }) - }) - - describe(PetFactory.prototype.makeMany, () => { - test('Should make many new entities', async () => { - const count = 2 - const entitiesMaked = await factory.makeMany(count) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeUndefined() - - expect(entity.refuge).toBeInstanceOf(Refuge) - expect(entity.refuge.id).toBeUndefined() - - expect(entity.owner).toBeInstanceOf(User) - expect(entity.owner.id).toBeUndefined() - }) - }) - }) - - describe(PetFactory.prototype.create, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create a new entity', async () => { - const petCreated = await factory.create() - - expect(petCreated).toBeInstanceOf(Pet) - expect(petCreated.id).toBeDefined() - expect(petCreated.name).toBeDefined() - - expect(petCreated.refuge).toBeInstanceOf(Refuge) - expect(petCreated.refuge.id).toBeDefined() - expect(petCreated.refuge.name).toBeDefined() - expect(petCreated.refuge.pet).toEqual(petCreated) - - expect(petCreated.owner).toBeInstanceOf(User) - expect(petCreated.owner.id).toBeDefined() - expect(petCreated.owner.name).toBeDefined() - }) - - test('Should create one entity of each type', async () => { - await factory.create() - - const [totalUsers, totalPets, totalRefuges] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - dataSource.createEntityManager().count(Refuge), - ]) - - expect(totalUsers).toBe(1) - expect(totalPets).toBe(1) - expect(totalRefuges).toBe(1) - }) - - test('Should create two entities with different attributes', async () => { - const petCreated1 = await factory.create() - const petCreated2 = await factory.create() - - expect(petCreated1).not.toStrictEqual(petCreated2) - }) - }) - - describe(PetFactory.prototype.createMany, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create many new entities', async () => { - const count = 2 - const entitiesCreated = await factory.createMany(count) - - expect(entitiesCreated).toHaveLength(count) - entitiesCreated.forEach((entity) => { - expect(entity.id).toBeDefined() - - expect(entity.refuge).toBeInstanceOf(Refuge) - expect(entity.refuge.id).toBeDefined() - expect(entity.refuge.pet).toEqual(entity) - - expect(entity.owner).toBeInstanceOf(User) - expect(entity.owner.id).toBeDefined() - }) - }) - - test('Should create many entities of each type', async () => { - const count = 2 - await factory.createMany(2) - - const [totalUsers, totalPets, totalRefuges] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - dataSource.createEntityManager().count(Refuge), - ]) - - expect(totalUsers).toBe(count) - expect(totalPets).toBe(count) - expect(totalRefuges).toBe(count) - }) - }) -}) + const factory = new PetFactory(); + + describe(PetFactory.prototype.make, () => { + test("Should make a new entity", async () => { + const petMaked = await factory.make(); + + expect(petMaked).toBeInstanceOf(Pet); + expect(petMaked.id).toBeUndefined(); + expect(petMaked.name).toBeDefined(); + + expect(petMaked.refuge).toBeInstanceOf(Refuge); + expect(petMaked.refuge.id).toBeUndefined(); + expect(petMaked.refuge.name).toBeDefined(); + + expect(petMaked.owner).toBeInstanceOf(User); + expect(petMaked.owner.id).toBeUndefined(); + expect(petMaked.owner.name).toBeDefined(); + }); + + test("Should make two entities with different attributes", async () => { + const petMaked1 = await factory.make(); + const petMaked2 = await factory.make(); + + expect(petMaked1).not.toStrictEqual(petMaked2); + }); + }); + + describe(PetFactory.prototype.makeMany, () => { + test("Should make many new entities", async () => { + const count = 2; + const entitiesMaked = await factory.makeMany(count); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeUndefined(); + + expect(entity.refuge).toBeInstanceOf(Refuge); + expect(entity.refuge.id).toBeUndefined(); + + expect(entity.owner).toBeInstanceOf(User); + expect(entity.owner.id).toBeUndefined(); + } + }); + }); + + describe(PetFactory.prototype.create, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create a new entity", async () => { + const petCreated = await factory.create(); + + expect(petCreated).toBeInstanceOf(Pet); + expect(petCreated.id).toBeDefined(); + expect(petCreated.name).toBeDefined(); + + expect(petCreated.refuge).toBeInstanceOf(Refuge); + expect(petCreated.refuge.id).toBeDefined(); + expect(petCreated.refuge.name).toBeDefined(); + expect(petCreated.refuge.pet).toEqual(petCreated); + + expect(petCreated.owner).toBeInstanceOf(User); + expect(petCreated.owner.id).toBeDefined(); + expect(petCreated.owner.name).toBeDefined(); + }); + + test("Should create one entity of each type", async () => { + await factory.create(); + + const [totalUsers, totalPets, totalRefuges] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + dataSource.createEntityManager().count(Refuge), + ]); + + expect(totalUsers).toBe(1); + expect(totalPets).toBe(1); + expect(totalRefuges).toBe(1); + }); + + test("Should create two entities with different attributes", async () => { + const petCreated1 = await factory.create(); + const petCreated2 = await factory.create(); + + expect(petCreated1).not.toStrictEqual(petCreated2); + }); + }); + + describe(PetFactory.prototype.createMany, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create many new entities", async () => { + const count = 2; + const entitiesCreated = await factory.createMany(count); + + expect(entitiesCreated).toHaveLength(count); + + for (const entity of entitiesCreated) { + expect(entity.id).toBeDefined(); + + expect(entity.refuge).toBeInstanceOf(Refuge); + expect(entity.refuge.id).toBeDefined(); + expect(entity.refuge.pet).toEqual(entity); + + expect(entity.owner).toBeInstanceOf(User); + expect(entity.owner.id).toBeDefined(); + } + }); + + test("Should create many entities of each type", async () => { + const count = 2; + await factory.createMany(2); + + const [totalUsers, totalPets, totalRefuges] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + dataSource.createEntityManager().count(Refuge), + ]); + + expect(totalUsers).toBe(count); + expect(totalPets).toBe(count); + expect(totalRefuges).toBe(count); + }); + }); +}); diff --git a/examples/1-to-1-chained-related/test/RefugeFactory.test.ts b/examples/1-to-1-chained-related/test/RefugeFactory.test.ts index fd8cef2..bdef4fb 100644 --- a/examples/1-to-1-chained-related/test/RefugeFactory.test.ts +++ b/examples/1-to-1-chained-related/test/RefugeFactory.test.ts @@ -1,133 +1,134 @@ -import { dataSource } from '../dataSource' -import { Pet } from '../entities/Pet.entity' -import { Refuge } from '../entities/Refuge.entity' -import { User } from '../entities/User.entity' -import { RefugeFactory } from '../factories/Refuge.factory' +import { dataSource } from "../dataSource"; +import { Pet } from "../entities/Pet.entity"; +import { Refuge } from "../entities/Refuge.entity"; +import { User } from "../entities/User.entity"; +import { RefugeFactory } from "../factories/Refuge.factory"; describe(RefugeFactory, () => { - const factory = new RefugeFactory() - - describe(RefugeFactory.prototype.make, () => { - test('Should make a new entity', async () => { - const refugeMaked = await factory.make() - - expect(refugeMaked).toBeInstanceOf(Refuge) - expect(refugeMaked.id).toBeUndefined() - expect(refugeMaked.name).toBeDefined() - - expect(refugeMaked.pet).toBeInstanceOf(Pet) - expect(refugeMaked.pet.id).toBeUndefined() - expect(refugeMaked.pet.name).toBeDefined() - - expect(refugeMaked.pet.owner).toBeInstanceOf(User) - expect(refugeMaked.pet.owner.id).toBeUndefined() - expect(refugeMaked.pet.owner.name).toBeDefined() - }) - - test('Should make two entities with different attributes', async () => { - const refugeMaked1 = await factory.make() - const refugeMaked2 = await factory.make() - - expect(refugeMaked1).not.toStrictEqual(refugeMaked2) - }) - }) - - describe(RefugeFactory.prototype.makeMany, () => { - test('Should make many new entities', async () => { - const count = 2 - const entitiesMaked = await factory.makeMany(count) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeUndefined() - - expect(entity.pet).toBeInstanceOf(Pet) - expect(entity.pet.id).toBeUndefined() - - expect(entity.pet.owner).toBeInstanceOf(User) - expect(entity.pet.owner.id).toBeUndefined() - }) - }) - }) - - describe(RefugeFactory.prototype.create, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create a new entity', async () => { - const refugeCreated = await factory.create() - - expect(refugeCreated).toBeInstanceOf(Refuge) - expect(refugeCreated.id).toBeDefined() - expect(refugeCreated.name).toBeDefined() - - expect(refugeCreated.pet).toBeInstanceOf(Pet) - expect(refugeCreated.pet.id).toBeDefined() - expect(refugeCreated.pet.name).toBeDefined() - - expect(refugeCreated.pet.owner).toBeInstanceOf(User) - expect(refugeCreated.pet.owner.id).toBeDefined() - expect(refugeCreated.pet.owner.name).toBeDefined() - }) - - test('Should create one entity of each type', async () => { - await factory.create() - - const [totalUsers, totalPets, totalRefuges] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - dataSource.createEntityManager().count(Refuge), - ]) - - expect(totalUsers).toBe(1) - expect(totalPets).toBe(1) - expect(totalRefuges).toBe(1) - }) - - test('Should create two entities with different attributes', async () => { - const petCreated1 = await factory.create() - const petCreated2 = await factory.create() - - expect(petCreated1).not.toStrictEqual(petCreated2) - }) - }) - - describe(RefugeFactory.prototype.createMany, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create many new entities', async () => { - const count = 2 - const entitiesCreated = await factory.createMany(count) - - expect(entitiesCreated).toHaveLength(count) - entitiesCreated.forEach((entity) => { - expect(entity.id).toBeDefined() - - expect(entity.pet).toBeInstanceOf(Pet) - expect(entity.pet.id).toBeDefined() - - expect(entity.pet.owner).toBeInstanceOf(User) - expect(entity.pet.owner.id).toBeDefined() - }) - }) - }) -}) + const factory = new RefugeFactory(); + + describe(RefugeFactory.prototype.make, () => { + test("Should make a new entity", async () => { + const refugeMaked = await factory.make(); + + expect(refugeMaked).toBeInstanceOf(Refuge); + expect(refugeMaked.id).toBeUndefined(); + expect(refugeMaked.name).toBeDefined(); + + expect(refugeMaked.pet).toBeInstanceOf(Pet); + expect(refugeMaked.pet.id).toBeUndefined(); + expect(refugeMaked.pet.name).toBeDefined(); + + expect(refugeMaked.pet.owner).toBeInstanceOf(User); + expect(refugeMaked.pet.owner.id).toBeUndefined(); + expect(refugeMaked.pet.owner.name).toBeDefined(); + }); + + test("Should make two entities with different attributes", async () => { + const refugeMaked1 = await factory.make(); + const refugeMaked2 = await factory.make(); + + expect(refugeMaked1).not.toStrictEqual(refugeMaked2); + }); + }); + + describe(RefugeFactory.prototype.makeMany, () => { + test("Should make many new entities", async () => { + const count = 2; + const entitiesMaked = await factory.makeMany(count); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeUndefined(); + + expect(entity.pet).toBeInstanceOf(Pet); + expect(entity.pet.id).toBeUndefined(); + + expect(entity.pet.owner).toBeInstanceOf(User); + expect(entity.pet.owner.id).toBeUndefined(); + } + }); + }); + + describe(RefugeFactory.prototype.create, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create a new entity", async () => { + const refugeCreated = await factory.create(); + + expect(refugeCreated).toBeInstanceOf(Refuge); + expect(refugeCreated.id).toBeDefined(); + expect(refugeCreated.name).toBeDefined(); + + expect(refugeCreated.pet).toBeInstanceOf(Pet); + expect(refugeCreated.pet.id).toBeDefined(); + expect(refugeCreated.pet.name).toBeDefined(); + + expect(refugeCreated.pet.owner).toBeInstanceOf(User); + expect(refugeCreated.pet.owner.id).toBeDefined(); + expect(refugeCreated.pet.owner.name).toBeDefined(); + }); + + test("Should create one entity of each type", async () => { + await factory.create(); + + const [totalUsers, totalPets, totalRefuges] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + dataSource.createEntityManager().count(Refuge), + ]); + + expect(totalUsers).toBe(1); + expect(totalPets).toBe(1); + expect(totalRefuges).toBe(1); + }); + + test("Should create two entities with different attributes", async () => { + const petCreated1 = await factory.create(); + const petCreated2 = await factory.create(); + + expect(petCreated1).not.toStrictEqual(petCreated2); + }); + }); + + describe(RefugeFactory.prototype.createMany, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create many new entities", async () => { + const count = 2; + const entitiesCreated = await factory.createMany(count); + + expect(entitiesCreated).toHaveLength(count); + for (const entity of entitiesCreated) { + expect(entity.id).toBeDefined(); + + expect(entity.pet).toBeInstanceOf(Pet); + expect(entity.pet.id).toBeDefined(); + + expect(entity.pet.owner).toBeInstanceOf(User); + expect(entity.pet.owner.id).toBeDefined(); + } + }); + }); +}); diff --git a/examples/1-to-1-chained-related/test/UserFactory.test.ts b/examples/1-to-1-chained-related/test/UserFactory.test.ts index a0445ba..f817a2d 100644 --- a/examples/1-to-1-chained-related/test/UserFactory.test.ts +++ b/examples/1-to-1-chained-related/test/UserFactory.test.ts @@ -1,153 +1,155 @@ -import { dataSource } from '../dataSource' -import { Pet } from '../entities/Pet.entity' -import { Refuge } from '../entities/Refuge.entity' -import { User } from '../entities/User.entity' -import { UserFactory } from '../factories/User.factory' +import { dataSource } from "../dataSource"; +import { Pet } from "../entities/Pet.entity"; +import { Refuge } from "../entities/Refuge.entity"; +import { User } from "../entities/User.entity"; +import { UserFactory } from "../factories/User.factory"; describe(UserFactory, () => { - const factory = new UserFactory() - - describe(UserFactory.prototype.make, () => { - test('Should make a new entity', async () => { - const userMaked = await factory.make() - - expect(userMaked).toBeInstanceOf(User) - expect(userMaked.id).toBeUndefined() - expect(userMaked.name).toBeDefined() - expect(userMaked.lastName).toBeDefined() - - expect(userMaked.pet).toBeInstanceOf(Pet) - expect(userMaked.pet.id).toBeUndefined() - expect(userMaked.pet.name).toBeDefined() - expect(userMaked.pet.owner).toEqual(userMaked) - - expect(userMaked.pet.refuge).toBeInstanceOf(Refuge) - expect(userMaked.pet.refuge.id).toBeUndefined() - expect(userMaked.pet.refuge.name).toBeDefined() - }) - - test('Should make two entities with different attributes', async () => { - const userMaked1 = await factory.make() - const userMaked2 = await factory.make() - - expect(userMaked1).not.toStrictEqual(userMaked2) - }) - }) - - describe(UserFactory.prototype.makeMany, () => { - test('Should make many new entities', async () => { - const count = 2 - const entitiesMaked = await factory.makeMany(count) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeUndefined() - - expect(entity.pet).toBeInstanceOf(Pet) - expect(entity.pet.id).toBeUndefined() - - expect(entity.pet.refuge).toBeInstanceOf(Refuge) - expect(entity.pet.refuge.id).toBeUndefined() - }) - }) - }) - - describe(UserFactory.prototype.create, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create a new entity', async () => { - const userCreated = await factory.create() - - expect(userCreated).toBeInstanceOf(User) - expect(userCreated.id).toBeDefined() - expect(userCreated.name).toBeDefined() - expect(userCreated.lastName).toBeDefined() - - expect(userCreated.pet).toBeInstanceOf(Pet) - expect(userCreated.pet.id).toBeDefined() - expect(userCreated.pet.name).toBeDefined() - expect(userCreated.pet.owner).toEqual(userCreated) - - expect(userCreated.pet.refuge).toBeInstanceOf(Refuge) - expect(userCreated.pet.refuge.id).toBeDefined() - expect(userCreated.pet.refuge.name).toBeDefined() - }) - - test('Should create one entity of each type', async () => { - await factory.create() - - const [totalUsers, totalPets, totalRefuges] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - dataSource.createEntityManager().count(Refuge), - ]) - - expect(totalUsers).toBe(1) - expect(totalPets).toBe(1) - expect(totalRefuges).toBe(1) - }) - - test('Should create two entities with different attributes', async () => { - const userCreated1 = await factory.create() - const userCreated2 = await factory.create() - - expect(userCreated1).not.toStrictEqual(userCreated2) - }) - }) - - describe(UserFactory.prototype.createMany, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create many new entities', async () => { - const count = 2 - const entitiesCreated = await factory.createMany(count) - - expect(entitiesCreated).toHaveLength(count) - entitiesCreated.forEach((entity) => { - expect(entity.id).toBeDefined() - - expect(entity.pet).toBeInstanceOf(Pet) - expect(entity.pet.id).toBeDefined() - expect(entity.pet.owner).toEqual(entity) - - expect(entity.pet.refuge).toBeInstanceOf(Refuge) - expect(entity.pet.refuge.id).toBeDefined() - }) - }) - - test('Should create many entities of each type', async () => { - const count = 2 - await factory.createMany(2) - - const [totalUsers, totalPets, totalRefuges] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - dataSource.createEntityManager().count(Refuge), - ]) - - expect(totalUsers).toBe(count) - expect(totalPets).toBe(count) - expect(totalRefuges).toBe(count) - }) - }) -}) + const factory = new UserFactory(); + + describe(UserFactory.prototype.make, () => { + test("Should make a new entity", async () => { + const userMaked = await factory.make(); + + expect(userMaked).toBeInstanceOf(User); + expect(userMaked.id).toBeUndefined(); + expect(userMaked.name).toBeDefined(); + expect(userMaked.lastName).toBeDefined(); + + expect(userMaked.pet).toBeInstanceOf(Pet); + expect(userMaked.pet.id).toBeUndefined(); + expect(userMaked.pet.name).toBeDefined(); + expect(userMaked.pet.owner).toEqual(userMaked); + + expect(userMaked.pet.refuge).toBeInstanceOf(Refuge); + expect(userMaked.pet.refuge.id).toBeUndefined(); + expect(userMaked.pet.refuge.name).toBeDefined(); + }); + + test("Should make two entities with different attributes", async () => { + const userMaked1 = await factory.make(); + const userMaked2 = await factory.make(); + + expect(userMaked1).not.toStrictEqual(userMaked2); + }); + }); + + describe(UserFactory.prototype.makeMany, () => { + test("Should make many new entities", async () => { + const count = 2; + const entitiesMaked = await factory.makeMany(count); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeUndefined(); + + expect(entity.pet).toBeInstanceOf(Pet); + expect(entity.pet.id).toBeUndefined(); + + expect(entity.pet.refuge).toBeInstanceOf(Refuge); + expect(entity.pet.refuge.id).toBeUndefined(); + } + }); + }); + + describe(UserFactory.prototype.create, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create a new entity", async () => { + const userCreated = await factory.create(); + + expect(userCreated).toBeInstanceOf(User); + expect(userCreated.id).toBeDefined(); + expect(userCreated.name).toBeDefined(); + expect(userCreated.lastName).toBeDefined(); + + expect(userCreated.pet).toBeInstanceOf(Pet); + expect(userCreated.pet.id).toBeDefined(); + expect(userCreated.pet.name).toBeDefined(); + expect(userCreated.pet.owner).toEqual(userCreated); + + expect(userCreated.pet.refuge).toBeInstanceOf(Refuge); + expect(userCreated.pet.refuge.id).toBeDefined(); + expect(userCreated.pet.refuge.name).toBeDefined(); + }); + + test("Should create one entity of each type", async () => { + await factory.create(); + + const [totalUsers, totalPets, totalRefuges] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + dataSource.createEntityManager().count(Refuge), + ]); + + expect(totalUsers).toBe(1); + expect(totalPets).toBe(1); + expect(totalRefuges).toBe(1); + }); + + test("Should create two entities with different attributes", async () => { + const userCreated1 = await factory.create(); + const userCreated2 = await factory.create(); + + expect(userCreated1).not.toStrictEqual(userCreated2); + }); + }); + + describe(UserFactory.prototype.createMany, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create many new entities", async () => { + const count = 2; + const entitiesCreated = await factory.createMany(count); + + expect(entitiesCreated).toHaveLength(count); + + for (const entity of entitiesCreated) { + expect(entity.id).toBeDefined(); + + expect(entity.pet).toBeInstanceOf(Pet); + expect(entity.pet.id).toBeDefined(); + expect(entity.pet.owner).toEqual(entity); + + expect(entity.pet.refuge).toBeInstanceOf(Refuge); + expect(entity.pet.refuge.id).toBeDefined(); + } + }); + + test("Should create many entities of each type", async () => { + const count = 2; + await factory.createMany(2); + + const [totalUsers, totalPets, totalRefuges] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + dataSource.createEntityManager().count(Refuge), + ]); + + expect(totalUsers).toBe(count); + expect(totalPets).toBe(count); + expect(totalRefuges).toBe(count); + }); + }); +}); diff --git a/examples/1-to-1-nullable-related/dataSource.ts b/examples/1-to-1-nullable-related/dataSource.ts index 814a18c..20429aa 100644 --- a/examples/1-to-1-nullable-related/dataSource.ts +++ b/examples/1-to-1-nullable-related/dataSource.ts @@ -1,7 +1,7 @@ -import { DataSource } from 'typeorm' +import { DataSource } from "typeorm"; export const dataSource = new DataSource({ - type: 'sqlite', - database: ':memory:', - entities: [`${__dirname}/**/*.entity.ts`], -}) + type: "sqlite", + database: ":memory:", + entities: [`${__dirname}/**/*.entity.ts`], +}); diff --git a/examples/1-to-1-nullable-related/entities/Pet.entity.ts b/examples/1-to-1-nullable-related/entities/Pet.entity.ts index 40937fd..1c56a92 100644 --- a/examples/1-to-1-nullable-related/entities/Pet.entity.ts +++ b/examples/1-to-1-nullable-related/entities/Pet.entity.ts @@ -1,15 +1,19 @@ -import { Entity, PrimaryGeneratedColumn, Column, JoinColumn, OneToOne } from 'typeorm' -import { User } from './User.entity' +import { Entity, PrimaryGeneratedColumn, Column, JoinColumn, OneToOne } from "typeorm"; +import { User } from "./User.entity"; @Entity() export class Pet { - @PrimaryGeneratedColumn('increment') - id!: string + @PrimaryGeneratedColumn("increment") + id!: string; - @Column() - name!: string + @Column() + name!: string; - @OneToOne(() => User, (user) => user.pet, { nullable: false }) - @JoinColumn({ name: 'owner_id' }) - owner!: User + @OneToOne( + () => User, + (user) => user.pet, + { nullable: false }, + ) + @JoinColumn({ name: "owner_id" }) + owner!: User; } diff --git a/examples/1-to-1-nullable-related/entities/User.entity.ts b/examples/1-to-1-nullable-related/entities/User.entity.ts index 80b6ddb..cf831c9 100644 --- a/examples/1-to-1-nullable-related/entities/User.entity.ts +++ b/examples/1-to-1-nullable-related/entities/User.entity.ts @@ -1,23 +1,27 @@ -import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn, OneToOne } from 'typeorm' -import { Pet } from './Pet.entity' +import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn, OneToOne } from "typeorm"; +import { Pet } from "./Pet.entity"; @Entity() export class User { - @PrimaryGeneratedColumn('increment') - id!: number + @PrimaryGeneratedColumn("increment") + id!: number; - @CreateDateColumn({ name: 'created_at' }) - createdAt!: Date + @CreateDateColumn({ name: "created_at" }) + createdAt!: Date; - @UpdateDateColumn({ name: 'updated_at' }) - updatedAt!: Date + @UpdateDateColumn({ name: "updated_at" }) + updatedAt!: Date; - @Column() - name!: string + @Column() + name!: string; - @Column({ name: 'last_name' }) - lastName!: string + @Column({ name: "last_name" }) + lastName!: string; - @OneToOne(() => Pet, (pet) => pet.owner, { nullable: true }) - pet?: Pet + @OneToOne( + () => Pet, + (pet) => pet.owner, + { nullable: true }, + ) + pet?: Pet; } diff --git a/examples/1-to-1-nullable-related/factories/Pet.factory.ts b/examples/1-to-1-nullable-related/factories/Pet.factory.ts index 7f19f11..4908d5b 100644 --- a/examples/1-to-1-nullable-related/factories/Pet.factory.ts +++ b/examples/1-to-1-nullable-related/factories/Pet.factory.ts @@ -1,17 +1,17 @@ -import { faker } from '@faker-js/faker' -import { EagerInstanceAttribute, FactorizedAttrs, Factory, SingleSubfactory } from '../../../src' -import { dataSource } from '../dataSource' -import { Pet } from '../entities/Pet.entity' -import { UserFactory } from './User.factory' +import { faker } from "@faker-js/faker"; +import { EagerInstanceAttribute, type FactorizedAttrs, Factory, SingleSubfactory } from "../../../src"; +import { dataSource } from "../dataSource"; +import { Pet } from "../entities/Pet.entity"; +import { UserFactory } from "./User.factory"; export class PetFactory extends Factory { - protected entity = Pet - protected dataSource = dataSource + protected entity = Pet; + protected dataSource = dataSource; - protected attrs(): FactorizedAttrs { - return { - name: faker.animal.insect(), - owner: new EagerInstanceAttribute((instance) => new SingleSubfactory(UserFactory, { pet: instance })), - } - } + protected attrs(): FactorizedAttrs { + return { + name: faker.animal.insect(), + owner: new EagerInstanceAttribute((instance) => new SingleSubfactory(UserFactory, { pet: instance })), + }; + } } diff --git a/examples/1-to-1-nullable-related/factories/User.factory.ts b/examples/1-to-1-nullable-related/factories/User.factory.ts index 632cf90..cab8a10 100644 --- a/examples/1-to-1-nullable-related/factories/User.factory.ts +++ b/examples/1-to-1-nullable-related/factories/User.factory.ts @@ -1,16 +1,16 @@ -import { faker } from '@faker-js/faker' -import { FactorizedAttrs, Factory } from '../../../src' -import { dataSource } from '../dataSource' -import { User } from '../entities/User.entity' +import { faker } from "@faker-js/faker"; +import { type FactorizedAttrs, Factory } from "../../../src"; +import { dataSource } from "../dataSource"; +import { User } from "../entities/User.entity"; export class UserFactory extends Factory { - protected entity = User - protected dataSource = dataSource + protected entity = User; + protected dataSource = dataSource; - protected attrs(): FactorizedAttrs { - return { - name: faker.person.firstName(), - lastName: faker.person.lastName(), - } - } + protected attrs(): FactorizedAttrs { + return { + name: faker.person.firstName(), + lastName: faker.person.lastName(), + }; + } } diff --git a/examples/1-to-1-nullable-related/test/PetFactory.test.ts b/examples/1-to-1-nullable-related/test/PetFactory.test.ts index dc1df47..889addd 100644 --- a/examples/1-to-1-nullable-related/test/PetFactory.test.ts +++ b/examples/1-to-1-nullable-related/test/PetFactory.test.ts @@ -1,102 +1,104 @@ -import { dataSource } from '../dataSource' -import { Pet } from '../entities/Pet.entity' -import { User } from '../entities/User.entity' -import { PetFactory } from '../factories/Pet.factory' +import { dataSource } from "../dataSource"; +import { Pet } from "../entities/Pet.entity"; +import { User } from "../entities/User.entity"; +import { PetFactory } from "../factories/Pet.factory"; describe(PetFactory, () => { - const factory = new PetFactory() - - describe(PetFactory.prototype.make, () => { - test('Should make a new entity', async () => { - const petMaked = await factory.make() - - expect(petMaked).toBeInstanceOf(Pet) - expect(petMaked.id).toBeUndefined() - expect(petMaked.name).toBeDefined() - - expect(petMaked.owner).toBeInstanceOf(User) - expect(petMaked.owner.id).toBeUndefined() - expect(petMaked.owner.name).toBeDefined() - }) - - test('Should make two entities with different attributes', async () => { - const petMaked1 = await factory.make() - const petMaked2 = await factory.make() - - expect(petMaked1).not.toStrictEqual(petMaked2) - }) - }) - - describe(PetFactory.prototype.makeMany, () => { - test('Should make many new entities', async () => { - const count = 2 - const entitiesMaked = await factory.makeMany(count) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeUndefined() - expect(entity.owner).toBeInstanceOf(User) - expect(entity.owner.id).toBeUndefined() - }) - }) - }) - - describe(PetFactory.prototype.create, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create a new entity', async () => { - const petCreated = await factory.create() - - expect(petCreated).toBeInstanceOf(Pet) - expect(petCreated.id).toBeDefined() - expect(petCreated.name).toBeDefined() - - expect(petCreated.owner).toBeInstanceOf(User) - expect(petCreated.owner.id).toBeDefined() - expect(petCreated.owner.name).toBeDefined() - }) - - test('Should create two entities with different attributes', async () => { - const petCreated1 = await factory.create() - const petCreated2 = await factory.create() - - expect(petCreated1).not.toStrictEqual(petCreated2) - }) - }) - - describe(PetFactory.prototype.createMany, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create many new entities', async () => { - const count = 2 - const entitiesCreated = await factory.createMany(count) - - expect(entitiesCreated).toHaveLength(count) - entitiesCreated.forEach((entity) => { - expect(entity.id).toBeDefined() - expect(entity.owner).toBeInstanceOf(User) - expect(entity.owner.id).toBeDefined() - }) - }) - }) -}) + const factory = new PetFactory(); + + describe(PetFactory.prototype.make, () => { + test("Should make a new entity", async () => { + const petMaked = await factory.make(); + + expect(petMaked).toBeInstanceOf(Pet); + expect(petMaked.id).toBeUndefined(); + expect(petMaked.name).toBeDefined(); + + expect(petMaked.owner).toBeInstanceOf(User); + expect(petMaked.owner.id).toBeUndefined(); + expect(petMaked.owner.name).toBeDefined(); + }); + + test("Should make two entities with different attributes", async () => { + const petMaked1 = await factory.make(); + const petMaked2 = await factory.make(); + + expect(petMaked1).not.toStrictEqual(petMaked2); + }); + }); + + describe(PetFactory.prototype.makeMany, () => { + test("Should make many new entities", async () => { + const count = 2; + const entitiesMaked = await factory.makeMany(count); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeUndefined(); + expect(entity.owner).toBeInstanceOf(User); + expect(entity.owner.id).toBeUndefined(); + } + }); + }); + + describe(PetFactory.prototype.create, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create a new entity", async () => { + const petCreated = await factory.create(); + + expect(petCreated).toBeInstanceOf(Pet); + expect(petCreated.id).toBeDefined(); + expect(petCreated.name).toBeDefined(); + + expect(petCreated.owner).toBeInstanceOf(User); + expect(petCreated.owner.id).toBeDefined(); + expect(petCreated.owner.name).toBeDefined(); + }); + + test("Should create two entities with different attributes", async () => { + const petCreated1 = await factory.create(); + const petCreated2 = await factory.create(); + + expect(petCreated1).not.toStrictEqual(petCreated2); + }); + }); + + describe(PetFactory.prototype.createMany, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create many new entities", async () => { + const count = 2; + const entitiesCreated = await factory.createMany(count); + + expect(entitiesCreated).toHaveLength(count); + + for (const entity of entitiesCreated) { + expect(entity.id).toBeDefined(); + expect(entity.owner).toBeInstanceOf(User); + expect(entity.owner.id).toBeDefined(); + } + }); + }); +}); diff --git a/examples/1-to-1-nullable-related/test/UserFactory.test.ts b/examples/1-to-1-nullable-related/test/UserFactory.test.ts index 3694ac6..955f6f4 100644 --- a/examples/1-to-1-nullable-related/test/UserFactory.test.ts +++ b/examples/1-to-1-nullable-related/test/UserFactory.test.ts @@ -1,215 +1,219 @@ -import { LazyInstanceAttribute, SingleSubfactory } from '../../../src' -import { dataSource } from '../dataSource' -import { Pet } from '../entities/Pet.entity' -import { User } from '../entities/User.entity' -import { PetFactory } from '../factories/Pet.factory' -import { UserFactory } from '../factories/User.factory' +import { LazyInstanceAttribute, SingleSubfactory } from "../../../src"; +import { dataSource } from "../dataSource"; +import { Pet } from "../entities/Pet.entity"; +import { User } from "../entities/User.entity"; +import { PetFactory } from "../factories/Pet.factory"; +import { UserFactory } from "../factories/User.factory"; describe(UserFactory, () => { - const factory = new UserFactory() - - describe(UserFactory.prototype.make, () => { - test('Should make a new entity without relation', async () => { - const userMaked = await factory.make() - - expect(userMaked).toBeInstanceOf(User) - expect(userMaked.id).toBeUndefined() - expect(userMaked.name).toBeDefined() - expect(userMaked.lastName).toBeDefined() - - expect(userMaked.pet).toBeUndefined() - }) - - test('Should make a new entity with relation', async () => { - const userMaked = await factory.make({ - pet: new LazyInstanceAttribute((instance) => new SingleSubfactory(PetFactory, { owner: instance })), - }) - - expect(userMaked).toBeInstanceOf(User) - expect(userMaked.id).toBeUndefined() - expect(userMaked.name).toBeDefined() - expect(userMaked.lastName).toBeDefined() - - expect(userMaked.pet).toBeDefined() - expect(userMaked.pet).toBeInstanceOf(Pet) - expect(userMaked.pet?.id).toBeUndefined() - expect(userMaked.pet?.name).toBeDefined() - expect(userMaked.pet?.owner).toEqual(userMaked) - }) - - test('Should make two entities with different attributes', async () => { - const userMaked1 = await factory.make() - const userMaked2 = await factory.make() - - expect(userMaked1).not.toStrictEqual(userMaked2) - }) - }) - - describe(UserFactory.prototype.makeMany, () => { - test('Should make many new entities without relation', async () => { - const count = 2 - const entitiesMaked = await factory.makeMany(count) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeUndefined() - expect(entity.pet).toBeUndefined() - }) - }) - - test('Should make many new entities with relation', async () => { - const count = 2 - const entitiesMaked = await factory.makeMany(count, { - pet: new LazyInstanceAttribute((instance) => new SingleSubfactory(PetFactory, { owner: instance })), - }) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeUndefined() - expect(entity.pet).toBeInstanceOf(Pet) - expect(entity.pet?.id).toBeUndefined() - }) - }) - }) - - describe(UserFactory.prototype.create, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create a new entity without relation', async () => { - const userCreated = await factory.create() - - expect(userCreated).toBeInstanceOf(User) - expect(userCreated.id).toBeDefined() - expect(userCreated.name).toBeDefined() - expect(userCreated.lastName).toBeDefined() - - expect(userCreated.pet).toBeUndefined() - }) - - test('Should create a new entity with relation', async () => { - const userCreated = await factory.create({ - pet: new LazyInstanceAttribute((instance) => new SingleSubfactory(PetFactory, { owner: instance })), - }) - - expect(userCreated).toBeInstanceOf(User) - expect(userCreated.id).toBeDefined() - expect(userCreated.name).toBeDefined() - expect(userCreated.lastName).toBeDefined() - - expect(userCreated.pet).toBeDefined() - expect(userCreated.pet).toBeInstanceOf(Pet) - expect(userCreated.pet?.id).toBeDefined() - expect(userCreated.pet?.owner).toEqual(userCreated) - }) - - test('Should create one entity without relation', async () => { - await factory.create() - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(1) - expect(totalPets).toBe(0) - }) - - test('Should create one entity of each type with relation', async () => { - await factory.create({ - pet: new LazyInstanceAttribute((instance) => new SingleSubfactory(PetFactory, { owner: instance })), - }) - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(1) - expect(totalPets).toBe(1) - }) - - test('Should create two entities with different attributes', async () => { - const userCreated1 = await factory.create() - const userCreated2 = await factory.create() - - expect(userCreated1).not.toStrictEqual(userCreated2) - }) - }) - - describe(UserFactory.prototype.createMany, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create many new entities without relation', async () => { - const count = 2 - const entitiesCreated = await factory.createMany(count) - - expect(entitiesCreated).toHaveLength(count) - entitiesCreated.forEach((entity) => { - expect(entity.id).toBeDefined() - expect(entity.pet).toBeUndefined() - }) - }) - - test('Should create many new entities with relation', async () => { - const count = 2 - const entitiesCreated = await factory.createMany(count, { - pet: new LazyInstanceAttribute((instance) => new SingleSubfactory(PetFactory, { owner: instance })), - }) - - expect(entitiesCreated).toHaveLength(count) - entitiesCreated.forEach((entity) => { - expect(entity.id).toBeDefined() - expect(entity.pet).toBeInstanceOf(Pet) - expect(entity.pet?.id).toBeDefined() - }) - }) - - test('Should create many entities without relation', async () => { - const count = 2 - await factory.createMany(2) - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(count) - expect(totalPets).toBe(0) - }) - - test('Should create many entities of each type with relations', async () => { - const count = 2 - await factory.createMany(2, { - pet: new LazyInstanceAttribute((instance) => new SingleSubfactory(PetFactory, { owner: instance })), - }) - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(count) - expect(totalPets).toBe(count) - }) - }) -}) + const factory = new UserFactory(); + + describe(UserFactory.prototype.make, () => { + test("Should make a new entity without relation", async () => { + const userMaked = await factory.make(); + + expect(userMaked).toBeInstanceOf(User); + expect(userMaked.id).toBeUndefined(); + expect(userMaked.name).toBeDefined(); + expect(userMaked.lastName).toBeDefined(); + + expect(userMaked.pet).toBeUndefined(); + }); + + test("Should make a new entity with relation", async () => { + const userMaked = await factory.make({ + pet: new LazyInstanceAttribute((instance) => new SingleSubfactory(PetFactory, { owner: instance })), + }); + + expect(userMaked).toBeInstanceOf(User); + expect(userMaked.id).toBeUndefined(); + expect(userMaked.name).toBeDefined(); + expect(userMaked.lastName).toBeDefined(); + + expect(userMaked.pet).toBeDefined(); + expect(userMaked.pet).toBeInstanceOf(Pet); + expect(userMaked.pet?.id).toBeUndefined(); + expect(userMaked.pet?.name).toBeDefined(); + expect(userMaked.pet?.owner).toEqual(userMaked); + }); + + test("Should make two entities with different attributes", async () => { + const userMaked1 = await factory.make(); + const userMaked2 = await factory.make(); + + expect(userMaked1).not.toStrictEqual(userMaked2); + }); + }); + + describe(UserFactory.prototype.makeMany, () => { + test("Should make many new entities without relation", async () => { + const count = 2; + const entitiesMaked = await factory.makeMany(count); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeUndefined(); + expect(entity.pet).toBeUndefined(); + } + }); + + test("Should make many new entities with relation", async () => { + const count = 2; + const entitiesMaked = await factory.makeMany(count, { + pet: new LazyInstanceAttribute((instance) => new SingleSubfactory(PetFactory, { owner: instance })), + }); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeUndefined(); + expect(entity.pet).toBeInstanceOf(Pet); + expect(entity.pet?.id).toBeUndefined(); + } + }); + }); + + describe(UserFactory.prototype.create, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create a new entity without relation", async () => { + const userCreated = await factory.create(); + + expect(userCreated).toBeInstanceOf(User); + expect(userCreated.id).toBeDefined(); + expect(userCreated.name).toBeDefined(); + expect(userCreated.lastName).toBeDefined(); + + expect(userCreated.pet).toBeUndefined(); + }); + + test("Should create a new entity with relation", async () => { + const userCreated = await factory.create({ + pet: new LazyInstanceAttribute((instance) => new SingleSubfactory(PetFactory, { owner: instance })), + }); + + expect(userCreated).toBeInstanceOf(User); + expect(userCreated.id).toBeDefined(); + expect(userCreated.name).toBeDefined(); + expect(userCreated.lastName).toBeDefined(); + + expect(userCreated.pet).toBeDefined(); + expect(userCreated.pet).toBeInstanceOf(Pet); + expect(userCreated.pet?.id).toBeDefined(); + expect(userCreated.pet?.owner).toEqual(userCreated); + }); + + test("Should create one entity without relation", async () => { + await factory.create(); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(1); + expect(totalPets).toBe(0); + }); + + test("Should create one entity of each type with relation", async () => { + await factory.create({ + pet: new LazyInstanceAttribute((instance) => new SingleSubfactory(PetFactory, { owner: instance })), + }); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(1); + expect(totalPets).toBe(1); + }); + + test("Should create two entities with different attributes", async () => { + const userCreated1 = await factory.create(); + const userCreated2 = await factory.create(); + + expect(userCreated1).not.toStrictEqual(userCreated2); + }); + }); + + describe(UserFactory.prototype.createMany, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create many new entities without relation", async () => { + const count = 2; + const entitiesCreated = await factory.createMany(count); + + expect(entitiesCreated).toHaveLength(count); + + for (const entity of entitiesCreated) { + expect(entity.id).toBeDefined(); + expect(entity.pet).toBeUndefined(); + } + }); + + test("Should create many new entities with relation", async () => { + const count = 2; + const entitiesCreated = await factory.createMany(count, { + pet: new LazyInstanceAttribute((instance) => new SingleSubfactory(PetFactory, { owner: instance })), + }); + + expect(entitiesCreated).toHaveLength(count); + + for (const entity of entitiesCreated) { + expect(entity.id).toBeDefined(); + expect(entity.pet).toBeInstanceOf(Pet); + expect(entity.pet?.id).toBeDefined(); + } + }); + + test("Should create many entities without relation", async () => { + const count = 2; + await factory.createMany(2); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(count); + expect(totalPets).toBe(0); + }); + + test("Should create many entities of each type with relations", async () => { + const count = 2; + await factory.createMany(2, { + pet: new LazyInstanceAttribute((instance) => new SingleSubfactory(PetFactory, { owner: instance })), + }); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(count); + expect(totalPets).toBe(count); + }); + }); +}); diff --git a/examples/1-to-1-related/dataSource.ts b/examples/1-to-1-related/dataSource.ts index 814a18c..20429aa 100644 --- a/examples/1-to-1-related/dataSource.ts +++ b/examples/1-to-1-related/dataSource.ts @@ -1,7 +1,7 @@ -import { DataSource } from 'typeorm' +import { DataSource } from "typeorm"; export const dataSource = new DataSource({ - type: 'sqlite', - database: ':memory:', - entities: [`${__dirname}/**/*.entity.ts`], -}) + type: "sqlite", + database: ":memory:", + entities: [`${__dirname}/**/*.entity.ts`], +}); diff --git a/examples/1-to-1-related/entities/Pet.entity.ts b/examples/1-to-1-related/entities/Pet.entity.ts index 40937fd..1c56a92 100644 --- a/examples/1-to-1-related/entities/Pet.entity.ts +++ b/examples/1-to-1-related/entities/Pet.entity.ts @@ -1,15 +1,19 @@ -import { Entity, PrimaryGeneratedColumn, Column, JoinColumn, OneToOne } from 'typeorm' -import { User } from './User.entity' +import { Entity, PrimaryGeneratedColumn, Column, JoinColumn, OneToOne } from "typeorm"; +import { User } from "./User.entity"; @Entity() export class Pet { - @PrimaryGeneratedColumn('increment') - id!: string + @PrimaryGeneratedColumn("increment") + id!: string; - @Column() - name!: string + @Column() + name!: string; - @OneToOne(() => User, (user) => user.pet, { nullable: false }) - @JoinColumn({ name: 'owner_id' }) - owner!: User + @OneToOne( + () => User, + (user) => user.pet, + { nullable: false }, + ) + @JoinColumn({ name: "owner_id" }) + owner!: User; } diff --git a/examples/1-to-1-related/entities/User.entity.ts b/examples/1-to-1-related/entities/User.entity.ts index 0d58bf2..63b63b9 100644 --- a/examples/1-to-1-related/entities/User.entity.ts +++ b/examples/1-to-1-related/entities/User.entity.ts @@ -1,23 +1,27 @@ -import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn, OneToOne } from 'typeorm' -import { Pet } from './Pet.entity' +import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn, OneToOne } from "typeorm"; +import { Pet } from "./Pet.entity"; @Entity() export class User { - @PrimaryGeneratedColumn('increment') - id!: number + @PrimaryGeneratedColumn("increment") + id!: number; - @CreateDateColumn({ name: 'created_at' }) - createdAt!: Date + @CreateDateColumn({ name: "created_at" }) + createdAt!: Date; - @UpdateDateColumn({ name: 'updated_at' }) - updatedAt!: Date + @UpdateDateColumn({ name: "updated_at" }) + updatedAt!: Date; - @Column() - name!: string + @Column() + name!: string; - @Column({ name: 'last_name' }) - lastName!: string + @Column({ name: "last_name" }) + lastName!: string; - @OneToOne(() => Pet, (pet) => pet.owner, { nullable: false }) - pet!: Pet + @OneToOne( + () => Pet, + (pet) => pet.owner, + { nullable: false }, + ) + pet!: Pet; } diff --git a/examples/1-to-1-related/factories/Pet.factory.ts b/examples/1-to-1-related/factories/Pet.factory.ts index 7f19f11..4908d5b 100644 --- a/examples/1-to-1-related/factories/Pet.factory.ts +++ b/examples/1-to-1-related/factories/Pet.factory.ts @@ -1,17 +1,17 @@ -import { faker } from '@faker-js/faker' -import { EagerInstanceAttribute, FactorizedAttrs, Factory, SingleSubfactory } from '../../../src' -import { dataSource } from '../dataSource' -import { Pet } from '../entities/Pet.entity' -import { UserFactory } from './User.factory' +import { faker } from "@faker-js/faker"; +import { EagerInstanceAttribute, type FactorizedAttrs, Factory, SingleSubfactory } from "../../../src"; +import { dataSource } from "../dataSource"; +import { Pet } from "../entities/Pet.entity"; +import { UserFactory } from "./User.factory"; export class PetFactory extends Factory { - protected entity = Pet - protected dataSource = dataSource + protected entity = Pet; + protected dataSource = dataSource; - protected attrs(): FactorizedAttrs { - return { - name: faker.animal.insect(), - owner: new EagerInstanceAttribute((instance) => new SingleSubfactory(UserFactory, { pet: instance })), - } - } + protected attrs(): FactorizedAttrs { + return { + name: faker.animal.insect(), + owner: new EagerInstanceAttribute((instance) => new SingleSubfactory(UserFactory, { pet: instance })), + }; + } } diff --git a/examples/1-to-1-related/factories/User.factory.ts b/examples/1-to-1-related/factories/User.factory.ts index 71f24c7..238eeb9 100644 --- a/examples/1-to-1-related/factories/User.factory.ts +++ b/examples/1-to-1-related/factories/User.factory.ts @@ -1,18 +1,18 @@ -import { faker } from '@faker-js/faker' -import { FactorizedAttrs, Factory, LazyInstanceAttribute, SingleSubfactory } from '../../../src' -import { dataSource } from '../dataSource' -import { User } from '../entities/User.entity' -import { PetFactory } from './Pet.factory' +import { faker } from "@faker-js/faker"; +import { type FactorizedAttrs, Factory, LazyInstanceAttribute, SingleSubfactory } from "../../../src"; +import { dataSource } from "../dataSource"; +import { User } from "../entities/User.entity"; +import { PetFactory } from "./Pet.factory"; export class UserFactory extends Factory { - protected entity = User - protected dataSource = dataSource + protected entity = User; + protected dataSource = dataSource; - protected attrs(): FactorizedAttrs { - return { - name: faker.person.firstName(), - lastName: faker.person.lastName(), - pet: new LazyInstanceAttribute((instance) => new SingleSubfactory(PetFactory, { owner: instance })), - } - } + protected attrs(): FactorizedAttrs { + return { + name: faker.person.firstName(), + lastName: faker.person.lastName(), + pet: new LazyInstanceAttribute((instance) => new SingleSubfactory(PetFactory, { owner: instance })), + }; + } } diff --git a/examples/1-to-1-related/test/PetFactory.test.ts b/examples/1-to-1-related/test/PetFactory.test.ts index dc1df47..889addd 100644 --- a/examples/1-to-1-related/test/PetFactory.test.ts +++ b/examples/1-to-1-related/test/PetFactory.test.ts @@ -1,102 +1,104 @@ -import { dataSource } from '../dataSource' -import { Pet } from '../entities/Pet.entity' -import { User } from '../entities/User.entity' -import { PetFactory } from '../factories/Pet.factory' +import { dataSource } from "../dataSource"; +import { Pet } from "../entities/Pet.entity"; +import { User } from "../entities/User.entity"; +import { PetFactory } from "../factories/Pet.factory"; describe(PetFactory, () => { - const factory = new PetFactory() - - describe(PetFactory.prototype.make, () => { - test('Should make a new entity', async () => { - const petMaked = await factory.make() - - expect(petMaked).toBeInstanceOf(Pet) - expect(petMaked.id).toBeUndefined() - expect(petMaked.name).toBeDefined() - - expect(petMaked.owner).toBeInstanceOf(User) - expect(petMaked.owner.id).toBeUndefined() - expect(petMaked.owner.name).toBeDefined() - }) - - test('Should make two entities with different attributes', async () => { - const petMaked1 = await factory.make() - const petMaked2 = await factory.make() - - expect(petMaked1).not.toStrictEqual(petMaked2) - }) - }) - - describe(PetFactory.prototype.makeMany, () => { - test('Should make many new entities', async () => { - const count = 2 - const entitiesMaked = await factory.makeMany(count) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeUndefined() - expect(entity.owner).toBeInstanceOf(User) - expect(entity.owner.id).toBeUndefined() - }) - }) - }) - - describe(PetFactory.prototype.create, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create a new entity', async () => { - const petCreated = await factory.create() - - expect(petCreated).toBeInstanceOf(Pet) - expect(petCreated.id).toBeDefined() - expect(petCreated.name).toBeDefined() - - expect(petCreated.owner).toBeInstanceOf(User) - expect(petCreated.owner.id).toBeDefined() - expect(petCreated.owner.name).toBeDefined() - }) - - test('Should create two entities with different attributes', async () => { - const petCreated1 = await factory.create() - const petCreated2 = await factory.create() - - expect(petCreated1).not.toStrictEqual(petCreated2) - }) - }) - - describe(PetFactory.prototype.createMany, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create many new entities', async () => { - const count = 2 - const entitiesCreated = await factory.createMany(count) - - expect(entitiesCreated).toHaveLength(count) - entitiesCreated.forEach((entity) => { - expect(entity.id).toBeDefined() - expect(entity.owner).toBeInstanceOf(User) - expect(entity.owner.id).toBeDefined() - }) - }) - }) -}) + const factory = new PetFactory(); + + describe(PetFactory.prototype.make, () => { + test("Should make a new entity", async () => { + const petMaked = await factory.make(); + + expect(petMaked).toBeInstanceOf(Pet); + expect(petMaked.id).toBeUndefined(); + expect(petMaked.name).toBeDefined(); + + expect(petMaked.owner).toBeInstanceOf(User); + expect(petMaked.owner.id).toBeUndefined(); + expect(petMaked.owner.name).toBeDefined(); + }); + + test("Should make two entities with different attributes", async () => { + const petMaked1 = await factory.make(); + const petMaked2 = await factory.make(); + + expect(petMaked1).not.toStrictEqual(petMaked2); + }); + }); + + describe(PetFactory.prototype.makeMany, () => { + test("Should make many new entities", async () => { + const count = 2; + const entitiesMaked = await factory.makeMany(count); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeUndefined(); + expect(entity.owner).toBeInstanceOf(User); + expect(entity.owner.id).toBeUndefined(); + } + }); + }); + + describe(PetFactory.prototype.create, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create a new entity", async () => { + const petCreated = await factory.create(); + + expect(petCreated).toBeInstanceOf(Pet); + expect(petCreated.id).toBeDefined(); + expect(petCreated.name).toBeDefined(); + + expect(petCreated.owner).toBeInstanceOf(User); + expect(petCreated.owner.id).toBeDefined(); + expect(petCreated.owner.name).toBeDefined(); + }); + + test("Should create two entities with different attributes", async () => { + const petCreated1 = await factory.create(); + const petCreated2 = await factory.create(); + + expect(petCreated1).not.toStrictEqual(petCreated2); + }); + }); + + describe(PetFactory.prototype.createMany, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create many new entities", async () => { + const count = 2; + const entitiesCreated = await factory.createMany(count); + + expect(entitiesCreated).toHaveLength(count); + + for (const entity of entitiesCreated) { + expect(entity.id).toBeDefined(); + expect(entity.owner).toBeInstanceOf(User); + expect(entity.owner.id).toBeDefined(); + } + }); + }); +}); diff --git a/examples/1-to-1-related/test/UserFactory.test.ts b/examples/1-to-1-related/test/UserFactory.test.ts index 8ff4f0c..0440418 100644 --- a/examples/1-to-1-related/test/UserFactory.test.ts +++ b/examples/1-to-1-related/test/UserFactory.test.ts @@ -1,131 +1,133 @@ -import { dataSource } from '../dataSource' -import { Pet } from '../entities/Pet.entity' -import { User } from '../entities/User.entity' -import { UserFactory } from '../factories/User.factory' +import { dataSource } from "../dataSource"; +import { Pet } from "../entities/Pet.entity"; +import { User } from "../entities/User.entity"; +import { UserFactory } from "../factories/User.factory"; describe(UserFactory, () => { - const factory = new UserFactory() - - describe(UserFactory.prototype.make, () => { - test('Should make a new entity', async () => { - const userMaked = await factory.make() - - expect(userMaked).toBeInstanceOf(User) - expect(userMaked.id).toBeUndefined() - expect(userMaked.name).toBeDefined() - expect(userMaked.lastName).toBeDefined() - - expect(userMaked.pet).toBeInstanceOf(Pet) - expect(userMaked.pet.id).toBeUndefined() - expect(userMaked.pet.name).toBeDefined() - expect(userMaked.pet.owner).toEqual(userMaked) - }) - - test('Should make two entities with different attributes', async () => { - const userMaked1 = await factory.make() - const userMaked2 = await factory.make() - - expect(userMaked1).not.toStrictEqual(userMaked2) - }) - }) - - describe(UserFactory.prototype.makeMany, () => { - test('Should make many new entities', async () => { - const count = 2 - const entitiesMaked = await factory.makeMany(count) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeUndefined() - expect(entity.pet).toBeInstanceOf(Pet) - expect(entity.pet.id).toBeUndefined() - }) - }) - }) - - describe(UserFactory.prototype.create, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create a new entity', async () => { - const userCreated = await factory.create() - - expect(userCreated).toBeInstanceOf(User) - expect(userCreated.id).toBeDefined() - expect(userCreated.name).toBeDefined() - expect(userCreated.lastName).toBeDefined() - - expect(userCreated.pet).toBeInstanceOf(Pet) - expect(userCreated.pet.id).toBeDefined() - expect(userCreated.pet.name).toBeDefined() - expect(userCreated.pet.owner).toEqual(userCreated) - }) - - test('Should create one entity of each type', async () => { - await factory.create() - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(1) - expect(totalPets).toBe(1) - }) - - test('Should create two entities with different attributes', async () => { - const userCreated1 = await factory.create() - const userCreated2 = await factory.create() - - expect(userCreated1).not.toStrictEqual(userCreated2) - }) - }) - - describe(UserFactory.prototype.createMany, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create many new entities', async () => { - const count = 2 - const entitiesCreated = await factory.createMany(count) - - expect(entitiesCreated).toHaveLength(count) - entitiesCreated.forEach((entity) => { - expect(entity.id).toBeDefined() - expect(entity.pet).toBeInstanceOf(Pet) - expect(entity.pet.id).toBeDefined() - }) - }) - - test('Should create many entities of each type', async () => { - const count = 2 - await factory.createMany(2) - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(count) - expect(totalPets).toBe(count) - }) - }) -}) + const factory = new UserFactory(); + + describe(UserFactory.prototype.make, () => { + test("Should make a new entity", async () => { + const userMaked = await factory.make(); + + expect(userMaked).toBeInstanceOf(User); + expect(userMaked.id).toBeUndefined(); + expect(userMaked.name).toBeDefined(); + expect(userMaked.lastName).toBeDefined(); + + expect(userMaked.pet).toBeInstanceOf(Pet); + expect(userMaked.pet.id).toBeUndefined(); + expect(userMaked.pet.name).toBeDefined(); + expect(userMaked.pet.owner).toEqual(userMaked); + }); + + test("Should make two entities with different attributes", async () => { + const userMaked1 = await factory.make(); + const userMaked2 = await factory.make(); + + expect(userMaked1).not.toStrictEqual(userMaked2); + }); + }); + + describe(UserFactory.prototype.makeMany, () => { + test("Should make many new entities", async () => { + const count = 2; + const entitiesMaked = await factory.makeMany(count); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeUndefined(); + expect(entity.pet).toBeInstanceOf(Pet); + expect(entity.pet.id).toBeUndefined(); + } + }); + }); + + describe(UserFactory.prototype.create, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create a new entity", async () => { + const userCreated = await factory.create(); + + expect(userCreated).toBeInstanceOf(User); + expect(userCreated.id).toBeDefined(); + expect(userCreated.name).toBeDefined(); + expect(userCreated.lastName).toBeDefined(); + + expect(userCreated.pet).toBeInstanceOf(Pet); + expect(userCreated.pet.id).toBeDefined(); + expect(userCreated.pet.name).toBeDefined(); + expect(userCreated.pet.owner).toEqual(userCreated); + }); + + test("Should create one entity of each type", async () => { + await factory.create(); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(1); + expect(totalPets).toBe(1); + }); + + test("Should create two entities with different attributes", async () => { + const userCreated1 = await factory.create(); + const userCreated2 = await factory.create(); + + expect(userCreated1).not.toStrictEqual(userCreated2); + }); + }); + + describe(UserFactory.prototype.createMany, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create many new entities", async () => { + const count = 2; + const entitiesCreated = await factory.createMany(count); + + expect(entitiesCreated).toHaveLength(count); + + for (const entity of entitiesCreated) { + expect(entity.id).toBeDefined(); + expect(entity.pet).toBeInstanceOf(Pet); + expect(entity.pet.id).toBeDefined(); + } + }); + + test("Should create many entities of each type", async () => { + const count = 2; + await factory.createMany(2); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(count); + expect(totalPets).toBe(count); + }); + }); +}); diff --git a/examples/1-to-N-related/dataSource.ts b/examples/1-to-N-related/dataSource.ts index 814a18c..20429aa 100644 --- a/examples/1-to-N-related/dataSource.ts +++ b/examples/1-to-N-related/dataSource.ts @@ -1,7 +1,7 @@ -import { DataSource } from 'typeorm' +import { DataSource } from "typeorm"; export const dataSource = new DataSource({ - type: 'sqlite', - database: ':memory:', - entities: [`${__dirname}/**/*.entity.ts`], -}) + type: "sqlite", + database: ":memory:", + entities: [`${__dirname}/**/*.entity.ts`], +}); diff --git a/examples/1-to-N-related/entities/Pet.entity.ts b/examples/1-to-N-related/entities/Pet.entity.ts index 28fbd16..2449cb8 100644 --- a/examples/1-to-N-related/entities/Pet.entity.ts +++ b/examples/1-to-N-related/entities/Pet.entity.ts @@ -1,15 +1,19 @@ -import { Entity, PrimaryGeneratedColumn, Column, JoinColumn, ManyToOne } from 'typeorm' -import { User } from './User.entity' +import { Entity, PrimaryGeneratedColumn, Column, JoinColumn, ManyToOne } from "typeorm"; +import { User } from "./User.entity"; @Entity() export class Pet { - @PrimaryGeneratedColumn('increment') - id!: string + @PrimaryGeneratedColumn("increment") + id!: string; - @Column() - name!: string + @Column() + name!: string; - @ManyToOne(() => User, (user) => user.pets, { nullable: false }) - @JoinColumn({ name: 'owner_id' }) - owner!: User + @ManyToOne( + () => User, + (user) => user.pets, + { nullable: false }, + ) + @JoinColumn({ name: "owner_id" }) + owner!: User; } diff --git a/examples/1-to-N-related/entities/User.entity.ts b/examples/1-to-N-related/entities/User.entity.ts index 12c79c5..be02edc 100644 --- a/examples/1-to-N-related/entities/User.entity.ts +++ b/examples/1-to-N-related/entities/User.entity.ts @@ -1,23 +1,27 @@ -import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn, OneToMany } from 'typeorm' -import { Pet } from './Pet.entity' +import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn, OneToMany } from "typeorm"; +import { Pet } from "./Pet.entity"; @Entity() export class User { - @PrimaryGeneratedColumn('increment') - id!: number + @PrimaryGeneratedColumn("increment") + id!: number; - @CreateDateColumn({ name: 'created_at' }) - createdAt!: Date + @CreateDateColumn({ name: "created_at" }) + createdAt!: Date; - @UpdateDateColumn({ name: 'updated_at' }) - updatedAt!: Date + @UpdateDateColumn({ name: "updated_at" }) + updatedAt!: Date; - @Column() - name!: string + @Column() + name!: string; - @Column({ name: 'last_name' }) - lastName!: string + @Column({ name: "last_name" }) + lastName!: string; - @OneToMany(() => Pet, (pet) => pet.owner, { nullable: false }) - pets!: Pet[] + @OneToMany( + () => Pet, + (pet) => pet.owner, + { nullable: false }, + ) + pets!: Pet[]; } diff --git a/examples/1-to-N-related/factories/Pet.factory.ts b/examples/1-to-N-related/factories/Pet.factory.ts index 54f2fe0..3f7d19e 100644 --- a/examples/1-to-N-related/factories/Pet.factory.ts +++ b/examples/1-to-N-related/factories/Pet.factory.ts @@ -1,17 +1,17 @@ -import { faker } from '@faker-js/faker' -import { EagerInstanceAttribute, FactorizedAttrs, Factory, SingleSubfactory } from '../../../src' -import { dataSource } from '../dataSource' -import { Pet } from '../entities/Pet.entity' -import { UserFactory } from './User.factory' +import { faker } from "@faker-js/faker"; +import { EagerInstanceAttribute, type FactorizedAttrs, Factory, SingleSubfactory } from "../../../src"; +import { dataSource } from "../dataSource"; +import { Pet } from "../entities/Pet.entity"; +import { UserFactory } from "./User.factory"; export class PetFactory extends Factory { - protected entity = Pet - protected dataSource = dataSource + protected entity = Pet; + protected dataSource = dataSource; - protected attrs(): FactorizedAttrs { - return { - name: faker.animal.insect(), - owner: new EagerInstanceAttribute((instance) => new SingleSubfactory(UserFactory, { pets: [instance] })), - } - } + protected attrs(): FactorizedAttrs { + return { + name: faker.animal.insect(), + owner: new EagerInstanceAttribute((instance) => new SingleSubfactory(UserFactory, { pets: [instance] })), + }; + } } diff --git a/examples/1-to-N-related/factories/User.factory.ts b/examples/1-to-N-related/factories/User.factory.ts index 5879f2f..cc56222 100644 --- a/examples/1-to-N-related/factories/User.factory.ts +++ b/examples/1-to-N-related/factories/User.factory.ts @@ -1,17 +1,17 @@ -import { faker } from '@faker-js/faker' -import { FactorizedAttrs, Factory } from '../../../src' -import { dataSource } from '../dataSource' -import { User } from '../entities/User.entity' +import { faker } from "@faker-js/faker"; +import { type FactorizedAttrs, Factory } from "../../../src"; +import { dataSource } from "../dataSource"; +import { User } from "../entities/User.entity"; export class UserFactory extends Factory { - protected entity = User - protected dataSource = dataSource + protected entity = User; + protected dataSource = dataSource; - protected attrs(): FactorizedAttrs { - return { - name: faker.person.firstName(), - lastName: faker.person.lastName(), - pets: [], - } - } + protected attrs(): FactorizedAttrs { + return { + name: faker.person.firstName(), + lastName: faker.person.lastName(), + pets: [], + }; + } } diff --git a/examples/1-to-N-related/test/PetFactory.test.ts b/examples/1-to-N-related/test/PetFactory.test.ts index dc1df47..889addd 100644 --- a/examples/1-to-N-related/test/PetFactory.test.ts +++ b/examples/1-to-N-related/test/PetFactory.test.ts @@ -1,102 +1,104 @@ -import { dataSource } from '../dataSource' -import { Pet } from '../entities/Pet.entity' -import { User } from '../entities/User.entity' -import { PetFactory } from '../factories/Pet.factory' +import { dataSource } from "../dataSource"; +import { Pet } from "../entities/Pet.entity"; +import { User } from "../entities/User.entity"; +import { PetFactory } from "../factories/Pet.factory"; describe(PetFactory, () => { - const factory = new PetFactory() - - describe(PetFactory.prototype.make, () => { - test('Should make a new entity', async () => { - const petMaked = await factory.make() - - expect(petMaked).toBeInstanceOf(Pet) - expect(petMaked.id).toBeUndefined() - expect(petMaked.name).toBeDefined() - - expect(petMaked.owner).toBeInstanceOf(User) - expect(petMaked.owner.id).toBeUndefined() - expect(petMaked.owner.name).toBeDefined() - }) - - test('Should make two entities with different attributes', async () => { - const petMaked1 = await factory.make() - const petMaked2 = await factory.make() - - expect(petMaked1).not.toStrictEqual(petMaked2) - }) - }) - - describe(PetFactory.prototype.makeMany, () => { - test('Should make many new entities', async () => { - const count = 2 - const entitiesMaked = await factory.makeMany(count) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeUndefined() - expect(entity.owner).toBeInstanceOf(User) - expect(entity.owner.id).toBeUndefined() - }) - }) - }) - - describe(PetFactory.prototype.create, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create a new entity', async () => { - const petCreated = await factory.create() - - expect(petCreated).toBeInstanceOf(Pet) - expect(petCreated.id).toBeDefined() - expect(petCreated.name).toBeDefined() - - expect(petCreated.owner).toBeInstanceOf(User) - expect(petCreated.owner.id).toBeDefined() - expect(petCreated.owner.name).toBeDefined() - }) - - test('Should create two entities with different attributes', async () => { - const petCreated1 = await factory.create() - const petCreated2 = await factory.create() - - expect(petCreated1).not.toStrictEqual(petCreated2) - }) - }) - - describe(PetFactory.prototype.createMany, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create many new entities', async () => { - const count = 2 - const entitiesCreated = await factory.createMany(count) - - expect(entitiesCreated).toHaveLength(count) - entitiesCreated.forEach((entity) => { - expect(entity.id).toBeDefined() - expect(entity.owner).toBeInstanceOf(User) - expect(entity.owner.id).toBeDefined() - }) - }) - }) -}) + const factory = new PetFactory(); + + describe(PetFactory.prototype.make, () => { + test("Should make a new entity", async () => { + const petMaked = await factory.make(); + + expect(petMaked).toBeInstanceOf(Pet); + expect(petMaked.id).toBeUndefined(); + expect(petMaked.name).toBeDefined(); + + expect(petMaked.owner).toBeInstanceOf(User); + expect(petMaked.owner.id).toBeUndefined(); + expect(petMaked.owner.name).toBeDefined(); + }); + + test("Should make two entities with different attributes", async () => { + const petMaked1 = await factory.make(); + const petMaked2 = await factory.make(); + + expect(petMaked1).not.toStrictEqual(petMaked2); + }); + }); + + describe(PetFactory.prototype.makeMany, () => { + test("Should make many new entities", async () => { + const count = 2; + const entitiesMaked = await factory.makeMany(count); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeUndefined(); + expect(entity.owner).toBeInstanceOf(User); + expect(entity.owner.id).toBeUndefined(); + } + }); + }); + + describe(PetFactory.prototype.create, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create a new entity", async () => { + const petCreated = await factory.create(); + + expect(petCreated).toBeInstanceOf(Pet); + expect(petCreated.id).toBeDefined(); + expect(petCreated.name).toBeDefined(); + + expect(petCreated.owner).toBeInstanceOf(User); + expect(petCreated.owner.id).toBeDefined(); + expect(petCreated.owner.name).toBeDefined(); + }); + + test("Should create two entities with different attributes", async () => { + const petCreated1 = await factory.create(); + const petCreated2 = await factory.create(); + + expect(petCreated1).not.toStrictEqual(petCreated2); + }); + }); + + describe(PetFactory.prototype.createMany, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create many new entities", async () => { + const count = 2; + const entitiesCreated = await factory.createMany(count); + + expect(entitiesCreated).toHaveLength(count); + + for (const entity of entitiesCreated) { + expect(entity.id).toBeDefined(); + expect(entity.owner).toBeInstanceOf(User); + expect(entity.owner.id).toBeDefined(); + } + }); + }); +}); diff --git a/examples/1-to-N-related/test/UserFactory.test.ts b/examples/1-to-N-related/test/UserFactory.test.ts index 446a1b0..b5f0b07 100644 --- a/examples/1-to-N-related/test/UserFactory.test.ts +++ b/examples/1-to-N-related/test/UserFactory.test.ts @@ -1,226 +1,232 @@ -import { CollectionSubfactory, LazyInstanceAttribute } from '../../../src' -import { dataSource } from '../dataSource' -import { Pet } from '../entities/Pet.entity' -import { User } from '../entities/User.entity' -import { PetFactory } from '../factories/Pet.factory' -import { UserFactory } from '../factories/User.factory' +import { CollectionSubfactory, LazyInstanceAttribute } from "../../../src"; +import { dataSource } from "../dataSource"; +import { Pet } from "../entities/Pet.entity"; +import { User } from "../entities/User.entity"; +import { PetFactory } from "../factories/Pet.factory"; +import { UserFactory } from "../factories/User.factory"; describe(UserFactory, () => { - const factory = new UserFactory() - - describe(UserFactory.prototype.make, () => { - test('Should make a new entity', async () => { - const userMaked = await factory.make() - - expect(userMaked).toBeInstanceOf(User) - expect(userMaked.id).toBeUndefined() - expect(userMaked.name).toBeDefined() - expect(userMaked.lastName).toBeDefined() - - expect(userMaked.pets).toBeInstanceOf(Array) - expect(userMaked.pets).toHaveLength(0) - }) - - test('Should make a new entity with relation', async () => { - const userMaked = await factory.make({ - pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owner: instance })), - }) - - expect(userMaked).toBeInstanceOf(User) - expect(userMaked.id).toBeUndefined() - expect(userMaked.name).toBeDefined() - expect(userMaked.lastName).toBeDefined() - - expect(userMaked.pets).toBeInstanceOf(Array) - expect(userMaked.pets).toHaveLength(1) - userMaked.pets.forEach((pet) => { - expect(pet).toBeInstanceOf(Pet) - expect(pet.id).toBeUndefined() - expect(pet.owner).toBeDefined() - expect(pet.owner).toEqual(userMaked) - }) - }) - - test('Should make two entities with different attributes', async () => { - const userMaked1 = await factory.make() - const userMaked2 = await factory.make() - - expect(userMaked1).not.toStrictEqual(userMaked2) - }) - }) - - describe(UserFactory.prototype.makeMany, () => { - test('Should make many new entities', async () => { - const count = 2 - const entitiesMaked = await factory.makeMany(count) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeUndefined() - expect(entity.pets).toBeInstanceOf(Array) - expect(entity.pets).toHaveLength(0) - }) - }) - - test('Should make many new entities with relations', async () => { - const count = 2 - const entitiesMaked = await factory.makeMany(count, { - pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owner: instance })), - }) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeUndefined() - expect(entity.pets).toBeInstanceOf(Array) - expect(entity.pets).toHaveLength(1) - }) - }) - }) - - describe(UserFactory.prototype.create, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create a new entity', async () => { - const userCreated = await factory.create() - - expect(userCreated).toBeInstanceOf(User) - expect(userCreated.id).toBeDefined() - expect(userCreated.name).toBeDefined() - expect(userCreated.lastName).toBeDefined() - - expect(userCreated.pets).toBeInstanceOf(Array) - expect(userCreated.pets).toHaveLength(0) - }) - - test('Should create a new entity with relation', async () => { - const userCreated = await factory.create({ - pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owner: instance })), - }) - - expect(userCreated).toBeInstanceOf(User) - expect(userCreated.id).toBeDefined() - expect(userCreated.name).toBeDefined() - expect(userCreated.lastName).toBeDefined() - - expect(userCreated.pets).toBeInstanceOf(Array) - expect(userCreated.pets).toHaveLength(1) - userCreated.pets.forEach((pet) => { - expect(pet).toBeInstanceOf(Pet) - expect(pet.id).toBeDefined() - expect(pet.owner).toBeDefined() - expect(pet.owner).toEqual(userCreated) - }) - }) - - test('Should create one entity', async () => { - await factory.create() - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(1) - expect(totalPets).toBe(0) - }) - - test('Should create one entity of each type', async () => { - await factory.create({ - pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owner: instance })), - }) - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(1) - expect(totalPets).toBe(1) - }) - - test('Should create two entities with different attributes', async () => { - const userCreated1 = await factory.create() - const userCreated2 = await factory.create() - - expect(userCreated1).not.toStrictEqual(userCreated2) - }) - }) - - describe(UserFactory.prototype.createMany, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create many new entities', async () => { - const count = 2 - const entitiesMaked = await factory.createMany(count) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeDefined() - expect(entity.pets).toBeInstanceOf(Array) - expect(entity.pets).toHaveLength(0) - }) - }) - - test('Should create many new entities with relations', async () => { - const count = 2 - const entitiesMaked = await factory.createMany(count, { - pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owner: instance })), - }) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeDefined() - expect(entity.pets).toBeInstanceOf(Array) - expect(entity.pets).toHaveLength(1) - }) - }) - - test('Should create many entities without relation', async () => { - const count = 2 - await factory.createMany(2) - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(count) - expect(totalPets).toBe(0) - }) - - test('Should create many entities of each type with relations', async () => { - const count = 2 - await factory.createMany(2, { - pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owner: instance })), - }) - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(count) - expect(totalPets).toBe(count) - }) - }) -}) + const factory = new UserFactory(); + + describe(UserFactory.prototype.make, () => { + test("Should make a new entity", async () => { + const userMaked = await factory.make(); + + expect(userMaked).toBeInstanceOf(User); + expect(userMaked.id).toBeUndefined(); + expect(userMaked.name).toBeDefined(); + expect(userMaked.lastName).toBeDefined(); + + expect(userMaked.pets).toBeInstanceOf(Array); + expect(userMaked.pets).toHaveLength(0); + }); + + test("Should make a new entity with relation", async () => { + const userMaked = await factory.make({ + pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owner: instance })), + }); + + expect(userMaked).toBeInstanceOf(User); + expect(userMaked.id).toBeUndefined(); + expect(userMaked.name).toBeDefined(); + expect(userMaked.lastName).toBeDefined(); + + expect(userMaked.pets).toBeInstanceOf(Array); + expect(userMaked.pets).toHaveLength(1); + + for (const pet of userMaked.pets) { + expect(pet).toBeInstanceOf(Pet); + expect(pet.id).toBeUndefined(); + expect(pet.owner).toBeDefined(); + expect(pet.owner).toEqual(userMaked); + } + }); + + test("Should make two entities with different attributes", async () => { + const userMaked1 = await factory.make(); + const userMaked2 = await factory.make(); + + expect(userMaked1).not.toStrictEqual(userMaked2); + }); + }); + + describe(UserFactory.prototype.makeMany, () => { + test("Should make many new entities", async () => { + const count = 2; + const entitiesMaked = await factory.makeMany(count); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeUndefined(); + expect(entity.pets).toBeInstanceOf(Array); + expect(entity.pets).toHaveLength(0); + } + }); + + test("Should make many new entities with relations", async () => { + const count = 2; + const entitiesMaked = await factory.makeMany(count, { + pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owner: instance })), + }); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeUndefined(); + expect(entity.pets).toBeInstanceOf(Array); + expect(entity.pets).toHaveLength(1); + } + }); + }); + + describe(UserFactory.prototype.create, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create a new entity", async () => { + const userCreated = await factory.create(); + + expect(userCreated).toBeInstanceOf(User); + expect(userCreated.id).toBeDefined(); + expect(userCreated.name).toBeDefined(); + expect(userCreated.lastName).toBeDefined(); + + expect(userCreated.pets).toBeInstanceOf(Array); + expect(userCreated.pets).toHaveLength(0); + }); + + test("Should create a new entity with relation", async () => { + const userCreated = await factory.create({ + pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owner: instance })), + }); + + expect(userCreated).toBeInstanceOf(User); + expect(userCreated.id).toBeDefined(); + expect(userCreated.name).toBeDefined(); + expect(userCreated.lastName).toBeDefined(); + + expect(userCreated.pets).toBeInstanceOf(Array); + expect(userCreated.pets).toHaveLength(1); + + for (const pet of userCreated.pets) { + expect(pet).toBeInstanceOf(Pet); + expect(pet.id).toBeDefined(); + expect(pet.owner).toBeDefined(); + expect(pet.owner).toEqual(userCreated); + } + }); + + test("Should create one entity", async () => { + await factory.create(); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(1); + expect(totalPets).toBe(0); + }); + + test("Should create one entity of each type", async () => { + await factory.create({ + pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owner: instance })), + }); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(1); + expect(totalPets).toBe(1); + }); + + test("Should create two entities with different attributes", async () => { + const userCreated1 = await factory.create(); + const userCreated2 = await factory.create(); + + expect(userCreated1).not.toStrictEqual(userCreated2); + }); + }); + + describe(UserFactory.prototype.createMany, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create many new entities", async () => { + const count = 2; + const entitiesMaked = await factory.createMany(count); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeDefined(); + expect(entity.pets).toBeInstanceOf(Array); + expect(entity.pets).toHaveLength(0); + } + }); + + test("Should create many new entities with relations", async () => { + const count = 2; + const entitiesMaked = await factory.createMany(count, { + pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owner: instance })), + }); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeDefined(); + expect(entity.pets).toBeInstanceOf(Array); + expect(entity.pets).toHaveLength(1); + } + }); + + test("Should create many entities without relation", async () => { + const count = 2; + await factory.createMany(2); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(count); + expect(totalPets).toBe(0); + }); + + test("Should create many entities of each type with relations", async () => { + const count = 2; + await factory.createMany(2, { + pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owner: instance })), + }); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(count); + expect(totalPets).toBe(count); + }); + }); +}); diff --git a/examples/N-to-M-related/dataSource.ts b/examples/N-to-M-related/dataSource.ts index 814a18c..20429aa 100644 --- a/examples/N-to-M-related/dataSource.ts +++ b/examples/N-to-M-related/dataSource.ts @@ -1,7 +1,7 @@ -import { DataSource } from 'typeorm' +import { DataSource } from "typeorm"; export const dataSource = new DataSource({ - type: 'sqlite', - database: ':memory:', - entities: [`${__dirname}/**/*.entity.ts`], -}) + type: "sqlite", + database: ":memory:", + entities: [`${__dirname}/**/*.entity.ts`], +}); diff --git a/examples/N-to-M-related/entities/Pet.entity.ts b/examples/N-to-M-related/entities/Pet.entity.ts index d7bb65b..7fc8395 100644 --- a/examples/N-to-M-related/entities/Pet.entity.ts +++ b/examples/N-to-M-related/entities/Pet.entity.ts @@ -1,14 +1,17 @@ -import { Entity, PrimaryGeneratedColumn, Column, ManyToMany } from 'typeorm' -import { User } from './User.entity' +import { Entity, PrimaryGeneratedColumn, Column, ManyToMany } from "typeorm"; +import { User } from "./User.entity"; @Entity() export class Pet { - @PrimaryGeneratedColumn('increment') - id!: string + @PrimaryGeneratedColumn("increment") + id!: string; - @Column() - name!: string + @Column() + name!: string; - @ManyToMany(() => User, (user) => user.pets) - owners!: User[] + @ManyToMany( + () => User, + (user) => user.pets, + ) + owners!: User[]; } diff --git a/examples/N-to-M-related/entities/User.entity.ts b/examples/N-to-M-related/entities/User.entity.ts index d7f444a..7f14e33 100644 --- a/examples/N-to-M-related/entities/User.entity.ts +++ b/examples/N-to-M-related/entities/User.entity.ts @@ -1,32 +1,35 @@ import { - Entity, - Column, - PrimaryGeneratedColumn, - CreateDateColumn, - UpdateDateColumn, - ManyToMany, - JoinTable, -} from 'typeorm' -import { Pet } from './Pet.entity' + Entity, + Column, + PrimaryGeneratedColumn, + CreateDateColumn, + UpdateDateColumn, + ManyToMany, + JoinTable, +} from "typeorm"; +import { Pet } from "./Pet.entity"; @Entity() export class User { - @PrimaryGeneratedColumn('increment') - id!: number + @PrimaryGeneratedColumn("increment") + id!: number; - @CreateDateColumn({ name: 'created_at' }) - createdAt!: Date + @CreateDateColumn({ name: "created_at" }) + createdAt!: Date; - @UpdateDateColumn({ name: 'updated_at' }) - updatedAt!: Date + @UpdateDateColumn({ name: "updated_at" }) + updatedAt!: Date; - @Column() - name!: string + @Column() + name!: string; - @Column({ name: 'last_name' }) - lastName!: string + @Column({ name: "last_name" }) + lastName!: string; - @ManyToMany(() => Pet, (pet) => pet.owners) - @JoinTable() - pets!: Pet[] + @ManyToMany( + () => Pet, + (pet) => pet.owners, + ) + @JoinTable() + pets!: Pet[]; } diff --git a/examples/N-to-M-related/factories/Pet.factory.ts b/examples/N-to-M-related/factories/Pet.factory.ts index 2adc678..2229787 100644 --- a/examples/N-to-M-related/factories/Pet.factory.ts +++ b/examples/N-to-M-related/factories/Pet.factory.ts @@ -1,16 +1,16 @@ -import { faker } from '@faker-js/faker' -import { FactorizedAttrs, Factory } from '../../../src' -import { dataSource } from '../dataSource' -import { Pet } from '../entities/Pet.entity' +import { faker } from "@faker-js/faker"; +import { type FactorizedAttrs, Factory } from "../../../src"; +import { dataSource } from "../dataSource"; +import { Pet } from "../entities/Pet.entity"; export class PetFactory extends Factory { - protected entity = Pet - protected dataSource = dataSource + protected entity = Pet; + protected dataSource = dataSource; - protected attrs(): FactorizedAttrs { - return { - name: faker.animal.insect(), - owners: [], - } - } + protected attrs(): FactorizedAttrs { + return { + name: faker.animal.insect(), + owners: [], + }; + } } diff --git a/examples/N-to-M-related/factories/User.factory.ts b/examples/N-to-M-related/factories/User.factory.ts index 5879f2f..cc56222 100644 --- a/examples/N-to-M-related/factories/User.factory.ts +++ b/examples/N-to-M-related/factories/User.factory.ts @@ -1,17 +1,17 @@ -import { faker } from '@faker-js/faker' -import { FactorizedAttrs, Factory } from '../../../src' -import { dataSource } from '../dataSource' -import { User } from '../entities/User.entity' +import { faker } from "@faker-js/faker"; +import { type FactorizedAttrs, Factory } from "../../../src"; +import { dataSource } from "../dataSource"; +import { User } from "../entities/User.entity"; export class UserFactory extends Factory { - protected entity = User - protected dataSource = dataSource + protected entity = User; + protected dataSource = dataSource; - protected attrs(): FactorizedAttrs { - return { - name: faker.person.firstName(), - lastName: faker.person.lastName(), - pets: [], - } - } + protected attrs(): FactorizedAttrs { + return { + name: faker.person.firstName(), + lastName: faker.person.lastName(), + pets: [], + }; + } } diff --git a/examples/N-to-M-related/test/PetFactory.test.ts b/examples/N-to-M-related/test/PetFactory.test.ts index 65d5b18..f0d80b4 100644 --- a/examples/N-to-M-related/test/PetFactory.test.ts +++ b/examples/N-to-M-related/test/PetFactory.test.ts @@ -1,250 +1,256 @@ -import { CollectionSubfactory, EagerInstanceAttribute } from '../../../src' -import { dataSource } from '../dataSource' -import { Pet } from '../entities/Pet.entity' -import { User } from '../entities/User.entity' -import { PetFactory } from '../factories/Pet.factory' -import { UserFactory } from '../factories/User.factory' +import { CollectionSubfactory, EagerInstanceAttribute } from "../../../src"; +import { dataSource } from "../dataSource"; +import { Pet } from "../entities/Pet.entity"; +import { User } from "../entities/User.entity"; +import { PetFactory } from "../factories/Pet.factory"; +import { UserFactory } from "../factories/User.factory"; describe(PetFactory, () => { - const factory = new PetFactory() - - describe(PetFactory.prototype.make, () => { - test('Should make a new entity', async () => { - const petMaked = await factory.make() - - expect(petMaked).toBeInstanceOf(Pet) - expect(petMaked.id).toBeUndefined() - expect(petMaked.name).toBeDefined() - - expect(petMaked.owners).toBeInstanceOf(Array) - expect(petMaked.owners).toHaveLength(0) - }) - - test('Should make a new entity with relation', async () => { - const petMaked = await factory.make({ - owners: new EagerInstanceAttribute( - (instance) => new CollectionSubfactory(UserFactory, 1, { pets: [instance] }), - ), - }) - - expect(petMaked).toBeInstanceOf(Pet) - expect(petMaked.id).toBeUndefined() - expect(petMaked.name).toBeDefined() - - expect(petMaked.owners).toBeInstanceOf(Array) - expect(petMaked.owners).toHaveLength(1) - petMaked.owners.forEach((owner) => { - expect(owner).toBeInstanceOf(User) - expect(owner.id).toBeUndefined() - expect(owner.pets).toBeInstanceOf(Array) - expect(owner.pets).toHaveLength(1) - }) - }) - - test('Should make two entities with different attributes', async () => { - const petMaked1 = await factory.make() - const petMaked2 = await factory.make() - - expect(petMaked1).not.toStrictEqual(petMaked2) - }) - }) - - describe(PetFactory.prototype.makeMany, () => { - test('Should make many new entities', async () => { - const count = 2 - const entitiesMaked = await factory.makeMany(count) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeUndefined() - expect(entity.owners).toBeInstanceOf(Array) - expect(entity.owners).toHaveLength(0) - }) - }) - - test('Should make many new entities with relations', async () => { - const count = 2 - const entitiesMaked = await factory.makeMany(count, { - owners: new EagerInstanceAttribute( - (instance) => new CollectionSubfactory(UserFactory, 1, { pets: [instance] }), - ), - }) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeUndefined() - expect(entity.owners).toBeInstanceOf(Array) - expect(entity.owners).toHaveLength(1) - }) - }) - }) - - describe(PetFactory.prototype.create, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create a new entity', async () => { - const petCreated = await factory.create() - - expect(petCreated).toBeInstanceOf(Pet) - expect(petCreated.id).toBeDefined() - expect(petCreated.name).toBeDefined() - - expect(petCreated.owners).toBeInstanceOf(Array) - expect(petCreated.owners).toHaveLength(0) - }) - - test('Should create a new entity with relation', async () => { - const petCreated = await factory.create({ - owners: new EagerInstanceAttribute( - (instance) => new CollectionSubfactory(UserFactory, 1, { pets: [instance] }), - ), - }) - - expect(petCreated).toBeInstanceOf(Pet) - expect(petCreated.id).toBeDefined() - expect(petCreated.name).toBeDefined() - - expect(petCreated.owners).toBeInstanceOf(Array) - expect(petCreated.owners).toHaveLength(1) - petCreated.owners.forEach((owner) => { - expect(owner).toBeInstanceOf(User) - expect(owner.id).toBeDefined() - expect(owner.pets).toBeInstanceOf(Array) - expect(owner.pets).toHaveLength(1) - }) - }) - - test('Should create one entity', async () => { - await factory.create() - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(0) - expect(totalPets).toBe(1) - }) - - test('Should create one entity of each type', async () => { - await factory.create({ - owners: new EagerInstanceAttribute( - (instance) => new CollectionSubfactory(UserFactory, 1, { pets: [instance] }), - ), - }) - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(1) - expect(totalPets).toBe(1) - }) - - test('Should create two entities with different attributes', async () => { - const petCreated1 = await factory.create() - const petCreated2 = await factory.create() - - expect(petCreated1).not.toStrictEqual(petCreated2) - }) - }) - - describe(PetFactory.prototype.createMany, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create many new entities', async () => { - const count = 2 - const entitiesMaked = await factory.createMany(count) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeDefined() - expect(entity.owners).toBeInstanceOf(Array) - expect(entity.owners).toHaveLength(0) - }) - }) - - test('Should create many new entities with relations', async () => { - const count = 2 - const entitiesMaked = await factory.createMany(count, { - owners: new EagerInstanceAttribute( - (instance) => new CollectionSubfactory(UserFactory, 1, { pets: [instance] }), - ), - }) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeDefined() - expect(entity.owners).toBeInstanceOf(Array) - expect(entity.owners).toHaveLength(1) - }) - }) - - test('Should create many entities without relation', async () => { - const count = 2 - await factory.createMany(2) - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(0) - expect(totalPets).toBe(count) - }) - - test('Should create many entities of each type with relations', async () => { - const count = 2 - await factory.createMany(2, { - owners: new EagerInstanceAttribute( - (instance) => new CollectionSubfactory(UserFactory, 1, { pets: [instance] }), - ), - }) - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(count) - expect(totalPets).toBe(count) - }) - - test('Should create many entities related with many other entities', async () => { - const count = 2 - const petsCreated = await factory.createMany(2) - await new UserFactory().createMany(2, { - pets: petsCreated, - }) - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(count) - expect(totalPets).toBe(count) - }) - }) -}) + const factory = new PetFactory(); + + describe(PetFactory.prototype.make, () => { + test("Should make a new entity", async () => { + const petMaked = await factory.make(); + + expect(petMaked).toBeInstanceOf(Pet); + expect(petMaked.id).toBeUndefined(); + expect(petMaked.name).toBeDefined(); + + expect(petMaked.owners).toBeInstanceOf(Array); + expect(petMaked.owners).toHaveLength(0); + }); + + test("Should make a new entity with relation", async () => { + const petMaked = await factory.make({ + owners: new EagerInstanceAttribute( + (instance) => new CollectionSubfactory(UserFactory, 1, { pets: [instance] }), + ), + }); + + expect(petMaked).toBeInstanceOf(Pet); + expect(petMaked.id).toBeUndefined(); + expect(petMaked.name).toBeDefined(); + + expect(petMaked.owners).toBeInstanceOf(Array); + expect(petMaked.owners).toHaveLength(1); + + for (const owner of petMaked.owners) { + expect(owner).toBeInstanceOf(User); + expect(owner.id).toBeUndefined(); + expect(owner.pets).toBeInstanceOf(Array); + expect(owner.pets).toHaveLength(1); + } + }); + + test("Should make two entities with different attributes", async () => { + const petMaked1 = await factory.make(); + const petMaked2 = await factory.make(); + + expect(petMaked1).not.toStrictEqual(petMaked2); + }); + }); + + describe(PetFactory.prototype.makeMany, () => { + test("Should make many new entities", async () => { + const count = 2; + const entitiesMaked = await factory.makeMany(count); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeUndefined(); + expect(entity.owners).toBeInstanceOf(Array); + expect(entity.owners).toHaveLength(0); + } + }); + + test("Should make many new entities with relations", async () => { + const count = 2; + const entitiesMaked = await factory.makeMany(count, { + owners: new EagerInstanceAttribute( + (instance) => new CollectionSubfactory(UserFactory, 1, { pets: [instance] }), + ), + }); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeUndefined(); + expect(entity.owners).toBeInstanceOf(Array); + expect(entity.owners).toHaveLength(1); + } + }); + }); + + describe(PetFactory.prototype.create, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create a new entity", async () => { + const petCreated = await factory.create(); + + expect(petCreated).toBeInstanceOf(Pet); + expect(petCreated.id).toBeDefined(); + expect(petCreated.name).toBeDefined(); + + expect(petCreated.owners).toBeInstanceOf(Array); + expect(petCreated.owners).toHaveLength(0); + }); + + test("Should create a new entity with relation", async () => { + const petCreated = await factory.create({ + owners: new EagerInstanceAttribute( + (instance) => new CollectionSubfactory(UserFactory, 1, { pets: [instance] }), + ), + }); + + expect(petCreated).toBeInstanceOf(Pet); + expect(petCreated.id).toBeDefined(); + expect(petCreated.name).toBeDefined(); + + expect(petCreated.owners).toBeInstanceOf(Array); + expect(petCreated.owners).toHaveLength(1); + + for (const owner of petCreated.owners) { + expect(owner).toBeInstanceOf(User); + expect(owner.id).toBeDefined(); + expect(owner.pets).toBeInstanceOf(Array); + expect(owner.pets).toHaveLength(1); + } + }); + + test("Should create one entity", async () => { + await factory.create(); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(0); + expect(totalPets).toBe(1); + }); + + test("Should create one entity of each type", async () => { + await factory.create({ + owners: new EagerInstanceAttribute( + (instance) => new CollectionSubfactory(UserFactory, 1, { pets: [instance] }), + ), + }); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(1); + expect(totalPets).toBe(1); + }); + + test("Should create two entities with different attributes", async () => { + const petCreated1 = await factory.create(); + const petCreated2 = await factory.create(); + + expect(petCreated1).not.toStrictEqual(petCreated2); + }); + }); + + describe(PetFactory.prototype.createMany, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create many new entities", async () => { + const count = 2; + const entitiesMaked = await factory.createMany(count); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeDefined(); + expect(entity.owners).toBeInstanceOf(Array); + expect(entity.owners).toHaveLength(0); + } + }); + + test("Should create many new entities with relations", async () => { + const count = 2; + const entitiesMaked = await factory.createMany(count, { + owners: new EagerInstanceAttribute( + (instance) => new CollectionSubfactory(UserFactory, 1, { pets: [instance] }), + ), + }); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeDefined(); + expect(entity.owners).toBeInstanceOf(Array); + expect(entity.owners).toHaveLength(1); + } + }); + + test("Should create many entities without relation", async () => { + const count = 2; + await factory.createMany(2); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(0); + expect(totalPets).toBe(count); + }); + + test("Should create many entities of each type with relations", async () => { + const count = 2; + await factory.createMany(2, { + owners: new EagerInstanceAttribute( + (instance) => new CollectionSubfactory(UserFactory, 1, { pets: [instance] }), + ), + }); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(count); + expect(totalPets).toBe(count); + }); + + test("Should create many entities related with many other entities", async () => { + const count = 2; + const petsCreated = await factory.createMany(2); + await new UserFactory().createMany(2, { + pets: petsCreated, + }); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(count); + expect(totalPets).toBe(count); + }); + }); +}); diff --git a/examples/N-to-M-related/test/UserFactory.test.ts b/examples/N-to-M-related/test/UserFactory.test.ts index 6c23105..99d53fa 100644 --- a/examples/N-to-M-related/test/UserFactory.test.ts +++ b/examples/N-to-M-related/test/UserFactory.test.ts @@ -1,242 +1,248 @@ -import { CollectionSubfactory, LazyInstanceAttribute } from '../../../src' -import { dataSource } from '../dataSource' -import { Pet } from '../entities/Pet.entity' -import { User } from '../entities/User.entity' -import { PetFactory } from '../factories/Pet.factory' -import { UserFactory } from '../factories/User.factory' +import { CollectionSubfactory, LazyInstanceAttribute } from "../../../src"; +import { dataSource } from "../dataSource"; +import { Pet } from "../entities/Pet.entity"; +import { User } from "../entities/User.entity"; +import { PetFactory } from "../factories/Pet.factory"; +import { UserFactory } from "../factories/User.factory"; describe(UserFactory, () => { - const factory = new UserFactory() - - describe(UserFactory.prototype.make, () => { - test('Should make a new entity', async () => { - const userMaked = await factory.make() - - expect(userMaked).toBeInstanceOf(User) - expect(userMaked.id).toBeUndefined() - expect(userMaked.name).toBeDefined() - expect(userMaked.lastName).toBeDefined() - - expect(userMaked.pets).toBeInstanceOf(Array) - expect(userMaked.pets).toHaveLength(0) - }) - - test('Should make a new entity with relation', async () => { - const userMaked = await factory.make({ - pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owners: [instance] })), - }) - - expect(userMaked).toBeInstanceOf(User) - expect(userMaked.id).toBeUndefined() - expect(userMaked.name).toBeDefined() - expect(userMaked.lastName).toBeDefined() - - expect(userMaked.pets).toBeInstanceOf(Array) - expect(userMaked.pets).toHaveLength(1) - userMaked.pets.forEach((pet) => { - expect(pet).toBeInstanceOf(Pet) - expect(pet.id).toBeUndefined() - expect(pet.owners).toBeInstanceOf(Array) - expect(pet.owners).toHaveLength(1) - }) - }) - - test('Should make two entities with different attributes', async () => { - const userMaked1 = await factory.make() - const userMaked2 = await factory.make() - - expect(userMaked1).not.toStrictEqual(userMaked2) - }) - }) - - describe(UserFactory.prototype.makeMany, () => { - test('Should make many new entities', async () => { - const count = 2 - const entitiesMaked = await factory.makeMany(count) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeUndefined() - expect(entity.pets).toBeInstanceOf(Array) - expect(entity.pets).toHaveLength(0) - }) - }) - - test('Should make many new entities with relations', async () => { - const count = 2 - const entitiesMaked = await factory.makeMany(count, { - pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owners: [instance] })), - }) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeUndefined() - expect(entity.pets).toBeInstanceOf(Array) - expect(entity.pets).toHaveLength(1) - }) - }) - }) - - describe(UserFactory.prototype.create, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create a new entity', async () => { - const userCreated = await factory.create() - - expect(userCreated).toBeInstanceOf(User) - expect(userCreated.id).toBeDefined() - expect(userCreated.name).toBeDefined() - expect(userCreated.lastName).toBeDefined() - - expect(userCreated.pets).toBeInstanceOf(Array) - expect(userCreated.pets).toHaveLength(0) - }) - - test('Should create a new entity with relation', async () => { - const userCreated = await factory.create({ - pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owners: [instance] })), - }) - - expect(userCreated).toBeInstanceOf(User) - expect(userCreated.id).toBeDefined() - expect(userCreated.name).toBeDefined() - expect(userCreated.lastName).toBeDefined() - - expect(userCreated.pets).toBeInstanceOf(Array) - expect(userCreated.pets).toHaveLength(1) - userCreated.pets.forEach((pet) => { - expect(pet).toBeInstanceOf(Pet) - expect(pet.id).toBeDefined() - expect(pet.owners).toBeInstanceOf(Array) - expect(pet.owners).toHaveLength(1) - }) - }) - - test('Should create one entity', async () => { - await factory.create() - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(1) - expect(totalPets).toBe(0) - }) - - test('Should create one entity of each type', async () => { - await factory.create({ - pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owners: [instance] })), - }) - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(1) - expect(totalPets).toBe(1) - }) - - test('Should create two entities with different attributes', async () => { - const userCreated1 = await factory.create() - const userCreated2 = await factory.create() - - expect(userCreated1).not.toStrictEqual(userCreated2) - }) - }) - - describe(UserFactory.prototype.createMany, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create many new entities', async () => { - const count = 2 - const entitiesMaked = await factory.createMany(count) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeDefined() - expect(entity.pets).toBeInstanceOf(Array) - expect(entity.pets).toHaveLength(0) - }) - }) - - test('Should create many new entities with relations', async () => { - const count = 2 - const entitiesMaked = await factory.createMany(count, { - pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owners: [instance] })), - }) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeDefined() - expect(entity.pets).toBeInstanceOf(Array) - expect(entity.pets).toHaveLength(1) - }) - }) - - test('Should create many entities without relation', async () => { - const count = 2 - await factory.createMany(2) - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(count) - expect(totalPets).toBe(0) - }) - - test('Should create many entities of each type with relations', async () => { - const count = 2 - await factory.createMany(2, { - pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owners: [instance] })), - }) - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(count) - expect(totalPets).toBe(count) - }) - - test('Should create many entities related with many other entities', async () => { - const count = 2 - const usersCreated = await factory.createMany(2) - await new PetFactory().createMany(2, { - owners: usersCreated, - }) - - const [totalUsers, totalPets] = await Promise.all([ - dataSource.createEntityManager().count(User), - dataSource.createEntityManager().count(Pet), - ]) - - expect(totalUsers).toBe(count) - expect(totalPets).toBe(count) - }) - }) -}) + const factory = new UserFactory(); + + describe(UserFactory.prototype.make, () => { + test("Should make a new entity", async () => { + const userMaked = await factory.make(); + + expect(userMaked).toBeInstanceOf(User); + expect(userMaked.id).toBeUndefined(); + expect(userMaked.name).toBeDefined(); + expect(userMaked.lastName).toBeDefined(); + + expect(userMaked.pets).toBeInstanceOf(Array); + expect(userMaked.pets).toHaveLength(0); + }); + + test("Should make a new entity with relation", async () => { + const userMaked = await factory.make({ + pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owners: [instance] })), + }); + + expect(userMaked).toBeInstanceOf(User); + expect(userMaked.id).toBeUndefined(); + expect(userMaked.name).toBeDefined(); + expect(userMaked.lastName).toBeDefined(); + + expect(userMaked.pets).toBeInstanceOf(Array); + expect(userMaked.pets).toHaveLength(1); + + for (const pet of userMaked.pets) { + expect(pet).toBeInstanceOf(Pet); + expect(pet.id).toBeUndefined(); + expect(pet.owners).toBeInstanceOf(Array); + expect(pet.owners).toHaveLength(1); + } + }); + + test("Should make two entities with different attributes", async () => { + const userMaked1 = await factory.make(); + const userMaked2 = await factory.make(); + + expect(userMaked1).not.toStrictEqual(userMaked2); + }); + }); + + describe(UserFactory.prototype.makeMany, () => { + test("Should make many new entities", async () => { + const count = 2; + const entitiesMaked = await factory.makeMany(count); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeUndefined(); + expect(entity.pets).toBeInstanceOf(Array); + expect(entity.pets).toHaveLength(0); + } + }); + + test("Should make many new entities with relations", async () => { + const count = 2; + const entitiesMaked = await factory.makeMany(count, { + pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owners: [instance] })), + }); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeUndefined(); + expect(entity.pets).toBeInstanceOf(Array); + expect(entity.pets).toHaveLength(1); + } + }); + }); + + describe(UserFactory.prototype.create, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create a new entity", async () => { + const userCreated = await factory.create(); + + expect(userCreated).toBeInstanceOf(User); + expect(userCreated.id).toBeDefined(); + expect(userCreated.name).toBeDefined(); + expect(userCreated.lastName).toBeDefined(); + + expect(userCreated.pets).toBeInstanceOf(Array); + expect(userCreated.pets).toHaveLength(0); + }); + + test("Should create a new entity with relation", async () => { + const userCreated = await factory.create({ + pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owners: [instance] })), + }); + + expect(userCreated).toBeInstanceOf(User); + expect(userCreated.id).toBeDefined(); + expect(userCreated.name).toBeDefined(); + expect(userCreated.lastName).toBeDefined(); + + expect(userCreated.pets).toBeInstanceOf(Array); + expect(userCreated.pets).toHaveLength(1); + + for (const pet of userCreated.pets) { + expect(pet).toBeInstanceOf(Pet); + expect(pet.id).toBeDefined(); + expect(pet.owners).toBeInstanceOf(Array); + expect(pet.owners).toHaveLength(1); + } + }); + + test("Should create one entity", async () => { + await factory.create(); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(1); + expect(totalPets).toBe(0); + }); + + test("Should create one entity of each type", async () => { + await factory.create({ + pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owners: [instance] })), + }); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(1); + expect(totalPets).toBe(1); + }); + + test("Should create two entities with different attributes", async () => { + const userCreated1 = await factory.create(); + const userCreated2 = await factory.create(); + + expect(userCreated1).not.toStrictEqual(userCreated2); + }); + }); + + describe(UserFactory.prototype.createMany, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create many new entities", async () => { + const count = 2; + const entitiesMaked = await factory.createMany(count); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeDefined(); + expect(entity.pets).toBeInstanceOf(Array); + expect(entity.pets).toHaveLength(0); + } + }); + + test("Should create many new entities with relations", async () => { + const count = 2; + const entitiesMaked = await factory.createMany(count, { + pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owners: [instance] })), + }); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeDefined(); + expect(entity.pets).toBeInstanceOf(Array); + expect(entity.pets).toHaveLength(1); + } + }); + + test("Should create many entities without relation", async () => { + const count = 2; + await factory.createMany(2); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(count); + expect(totalPets).toBe(0); + }); + + test("Should create many entities of each type with relations", async () => { + const count = 2; + await factory.createMany(2, { + pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owners: [instance] })), + }); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(count); + expect(totalPets).toBe(count); + }); + + test("Should create many entities related with many other entities", async () => { + const count = 2; + const usersCreated = await factory.createMany(2); + await new PetFactory().createMany(2, { + owners: usersCreated, + }); + + const [totalUsers, totalPets] = await Promise.all([ + dataSource.createEntityManager().count(User), + dataSource.createEntityManager().count(Pet), + ]); + + expect(totalUsers).toBe(count); + expect(totalPets).toBe(count); + }); + }); +}); diff --git a/examples/single-entity/dataSource.ts b/examples/single-entity/dataSource.ts index 814a18c..20429aa 100644 --- a/examples/single-entity/dataSource.ts +++ b/examples/single-entity/dataSource.ts @@ -1,7 +1,7 @@ -import { DataSource } from 'typeorm' +import { DataSource } from "typeorm"; export const dataSource = new DataSource({ - type: 'sqlite', - database: ':memory:', - entities: [`${__dirname}/**/*.entity.ts`], -}) + type: "sqlite", + database: ":memory:", + entities: [`${__dirname}/**/*.entity.ts`], +}); diff --git a/examples/single-entity/entities/User.entity.ts b/examples/single-entity/entities/User.entity.ts index 82fd8df..d51e220 100644 --- a/examples/single-entity/entities/User.entity.ts +++ b/examples/single-entity/entities/User.entity.ts @@ -1,19 +1,19 @@ -import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn } from 'typeorm' +import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn } from "typeorm"; @Entity() export class User { - @PrimaryGeneratedColumn('increment') - id!: number + @PrimaryGeneratedColumn("increment") + id!: number; - @CreateDateColumn({ name: 'created_at' }) - createdAt!: Date + @CreateDateColumn({ name: "created_at" }) + createdAt!: Date; - @UpdateDateColumn({ name: 'updated_at' }) - updatedAt!: Date + @UpdateDateColumn({ name: "updated_at" }) + updatedAt!: Date; - @Column() - name!: string + @Column() + name!: string; - @Column({ name: 'last_name' }) - lastName!: string + @Column({ name: "last_name" }) + lastName!: string; } diff --git a/examples/single-entity/factories/User.factory.ts b/examples/single-entity/factories/User.factory.ts index 632cf90..cab8a10 100644 --- a/examples/single-entity/factories/User.factory.ts +++ b/examples/single-entity/factories/User.factory.ts @@ -1,16 +1,16 @@ -import { faker } from '@faker-js/faker' -import { FactorizedAttrs, Factory } from '../../../src' -import { dataSource } from '../dataSource' -import { User } from '../entities/User.entity' +import { faker } from "@faker-js/faker"; +import { type FactorizedAttrs, Factory } from "../../../src"; +import { dataSource } from "../dataSource"; +import { User } from "../entities/User.entity"; export class UserFactory extends Factory { - protected entity = User - protected dataSource = dataSource + protected entity = User; + protected dataSource = dataSource; - protected attrs(): FactorizedAttrs { - return { - name: faker.person.firstName(), - lastName: faker.person.lastName(), - } - } + protected attrs(): FactorizedAttrs { + return { + name: faker.person.firstName(), + lastName: faker.person.lastName(), + }; + } } diff --git a/examples/single-entity/test/UserFactory.test.ts b/examples/single-entity/test/UserFactory.test.ts index 0dfc2d6..ae42abe 100644 --- a/examples/single-entity/test/UserFactory.test.ts +++ b/examples/single-entity/test/UserFactory.test.ts @@ -1,91 +1,93 @@ -import { dataSource } from '../dataSource' -import { User } from '../entities/User.entity' -import { UserFactory } from '../factories/User.factory' +import { dataSource } from "../dataSource"; +import { User } from "../entities/User.entity"; +import { UserFactory } from "../factories/User.factory"; describe(UserFactory, () => { - const factory = new UserFactory() - - describe(UserFactory.prototype.make, () => { - test('Should make a new entity', async () => { - const userMaked = await factory.make() - - expect(userMaked).toBeInstanceOf(User) - expect(userMaked.id).toBeUndefined() - expect(userMaked.name).toBeDefined() - expect(userMaked.lastName).toBeDefined() - }) - - test('Should make two entities with different attributes', async () => { - const userMaked1 = await factory.make() - const userMaked2 = await factory.make() - - expect(userMaked1).not.toStrictEqual(userMaked2) - }) - }) - - describe(UserFactory.prototype.makeMany, () => { - test('Should make many new entities', async () => { - const count = 2 - const entitiesMaked = await factory.makeMany(count) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeUndefined() - }) - }) - }) - - describe(UserFactory.prototype.create, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create a new entity', async () => { - const userCreated = await factory.create() - - expect(userCreated).toBeInstanceOf(User) - expect(userCreated.id).toBeDefined() - expect(userCreated.name).toBeDefined() - expect(userCreated.lastName).toBeDefined() - }) - - test('Should create two entities with different attributes', async () => { - const userCreated1 = await factory.create() - const userCreated2 = await factory.create() - - expect(userCreated1).not.toStrictEqual(userCreated2) - }) - }) - - describe(UserFactory.prototype.createMany, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create many new entities', async () => { - const count = 2 - const entitiesCreated = await factory.createMany(count) - - expect(entitiesCreated).toHaveLength(count) - entitiesCreated.forEach((entity) => { - expect(entity.id).toBeDefined() - }) - }) - }) -}) + const factory = new UserFactory(); + + describe(UserFactory.prototype.make, () => { + test("Should make a new entity", async () => { + const userMaked = await factory.make(); + + expect(userMaked).toBeInstanceOf(User); + expect(userMaked.id).toBeUndefined(); + expect(userMaked.name).toBeDefined(); + expect(userMaked.lastName).toBeDefined(); + }); + + test("Should make two entities with different attributes", async () => { + const userMaked1 = await factory.make(); + const userMaked2 = await factory.make(); + + expect(userMaked1).not.toStrictEqual(userMaked2); + }); + }); + + describe(UserFactory.prototype.makeMany, () => { + test("Should make many new entities", async () => { + const count = 2; + const entitiesMaked = await factory.makeMany(count); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeUndefined(); + } + }); + }); + + describe(UserFactory.prototype.create, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create a new entity", async () => { + const userCreated = await factory.create(); + + expect(userCreated).toBeInstanceOf(User); + expect(userCreated.id).toBeDefined(); + expect(userCreated.name).toBeDefined(); + expect(userCreated.lastName).toBeDefined(); + }); + + test("Should create two entities with different attributes", async () => { + const userCreated1 = await factory.create(); + const userCreated2 = await factory.create(); + + expect(userCreated1).not.toStrictEqual(userCreated2); + }); + }); + + describe(UserFactory.prototype.createMany, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create many new entities", async () => { + const count = 2; + const entitiesCreated = await factory.createMany(count); + + expect(entitiesCreated).toHaveLength(count); + + for (const entity of entitiesCreated) { + expect(entity.id).toBeDefined(); + } + }); + }); +}); diff --git a/jest.config.ts b/jest.config.ts index 1fee53f..9b027db 100644 --- a/jest.config.ts +++ b/jest.config.ts @@ -1,5 +1,5 @@ export default { - collectCoverageFrom: ['src/**/!(*.d).ts'], - preset: 'ts-jest', - testEnvironment: 'node', -} + collectCoverageFrom: ["src/**/!(*.d).ts"], + preset: "ts-jest", + testEnvironment: "node", +}; diff --git a/package.json b/package.json index 09d8d94..9f99f0c 100644 --- a/package.json +++ b/package.json @@ -1,64 +1,53 @@ { - "author": "Jorge Bodega (https://github.com/jorgebodega)", - "dependencies": { - "tslib": "2.6.3" - }, - "description": "🌱 A delightful way to use factories in your code.", - "devDependencies": { - "@faker-js/faker": "8.4.1", - "@tsconfig/node18-strictest": "1.0.0", - "@types/jest": "29.5.12", - "@types/node": "20.14.7", - "@typescript-eslint/eslint-plugin": "7.13.1", - "@typescript-eslint/parser": "7.13.1", - "eslint": "8.57.0", - "eslint-config-prettier": "9.1.0", - "eslint-import-resolver-typescript": "3.6.1", - "eslint-plugin-import": "2.29.1", - "jest": "29.7.0", - "prettier": "3.3.2", - "rimraf": "5.0.7", - "sqlite3": "5.1.7", - "ts-jest": "29.1.5", - "ts-node": "10.9.2", - "typeorm": "0.3.20", - "typescript": "5.5.2" - }, - "engines": { - "node": ">=18 <19 || >=20" - }, - "keywords": [ - "typeorm", - "factory", - "entity", - "orm" - ], - "license": "MIT", - "main": "dist/index.js", - "name": "@jorgebodega/typeorm-factory", - "packageManager": "pnpm@9.4.0", - "peerDependencies": { - "typeorm": "^0.3.0" - }, - "repository": { - "type": "git", - "url": "https://github.com/jorgebodega/typeorm-factory.git" - }, - "scripts": { - "build": "tsc --project ./tsconfig.build.json", - "checks": "pnpm format:ci && pnpm lint:ci && pnpm typecheck", - "format:ci": "prettier --check \"{src,test}/**/*.ts\"", - "format": "prettier --write \"{src,test}/**/*.ts\"", - "lint:ci": "pnpm lint", - "lint:fix": "pnpm lint --fix", - "lint": "eslint \"{src,test}/**/*.ts\"", - "prebuild": "rimraf dist", - "test:ci": "jest --silent", - "test:cov": "jest --coverage --silent", - "test:watch": "jest --watch", - "test": "jest", - "typecheck": "tsc --noEmit" - }, - "types": "dist/index.d.ts", - "version": "2.0.0" + "author": "Jorge Bodega (https://github.com/jorgebodega)", + "dependencies": { + "tslib": "2.6.3" + }, + "description": "🌱 A delightful way to use factories in your code.", + "devDependencies": { + "@biomejs/biome": "^1.8.2", + "@faker-js/faker": "8.4.1", + "@tsconfig/node18-strictest": "1.0.0", + "@types/jest": "29.5.12", + "@types/node": "20.14.7", + "jest": "29.7.0", + "rimraf": "5.0.7", + "sqlite3": "5.1.7", + "ts-jest": "29.1.5", + "ts-node": "10.9.2", + "typeorm": "0.3.20", + "typescript": "5.5.2" + }, + "engines": { + "node": ">=18 <19 || >=20" + }, + "keywords": ["typeorm", "factory", "entity", "orm"], + "license": "MIT", + "main": "dist/index.js", + "name": "@jorgebodega/typeorm-factory", + "packageManager": "pnpm@9.4.0", + "peerDependencies": { + "typeorm": "^0.3.0" + }, + "repository": { + "type": "git", + "url": "https://github.com/jorgebodega/typeorm-factory.git" + }, + "scripts": { + "build": "tsc --project ./tsconfig.build.json", + "checks": "pnpm format:ci && pnpm lint:ci && pnpm typecheck", + "format": "biome format --write", + "format:ci": "biome format", + "lint": "biome lint", + "lint:fix": "biome lint --fix", + "lint:ci": "biome lint", + "prebuild": "rimraf dist", + "test:ci": "jest --silent", + "test:cov": "jest --coverage --silent", + "test:watch": "jest --watch", + "test": "jest", + "typecheck": "tsc --noEmit" + }, + "types": "dist/index.d.ts", + "version": "2.0.0" } diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 718f990..aa58c05 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -12,6 +12,9 @@ importers: specifier: 2.6.3 version: 2.6.3 devDependencies: + '@biomejs/biome': + specifier: ^1.8.2 + version: 1.8.2 '@faker-js/faker': specifier: 8.4.1 version: 8.4.1 @@ -24,30 +27,9 @@ importers: '@types/node': specifier: 20.14.7 version: 20.14.7 - '@typescript-eslint/eslint-plugin': - specifier: 7.13.1 - version: 7.13.1(@typescript-eslint/parser@7.13.1(eslint@8.57.0)(typescript@5.5.2))(eslint@8.57.0)(typescript@5.5.2) - '@typescript-eslint/parser': - specifier: 7.13.1 - version: 7.13.1(eslint@8.57.0)(typescript@5.5.2) - eslint: - specifier: 8.57.0 - version: 8.57.0 - eslint-config-prettier: - specifier: 9.1.0 - version: 9.1.0(eslint@8.57.0) - eslint-import-resolver-typescript: - specifier: 3.6.1 - version: 3.6.1(@typescript-eslint/parser@7.13.1(eslint@8.57.0)(typescript@5.5.2))(eslint-plugin-import@2.29.1)(eslint@8.57.0) - eslint-plugin-import: - specifier: 2.29.1 - version: 2.29.1(@typescript-eslint/parser@7.13.1(eslint@8.57.0)(typescript@5.5.2))(eslint-import-resolver-typescript@3.6.1)(eslint@8.57.0) jest: specifier: 29.7.0 version: 29.7.0(@types/node@20.14.7)(ts-node@10.9.2(@types/node@20.14.7)(typescript@5.5.2)) - prettier: - specifier: 3.3.2 - version: 3.3.2 rimraf: specifier: 5.0.7 version: 5.0.7 @@ -69,10 +51,6 @@ importers: packages: - '@aashutoshrathi/word-wrap@1.2.6': - resolution: {integrity: sha512-1Yjs2SvM8TflER/OD3cOjhWWOZb58A2t7wpE2S9XfBYTiIl+XFhQG2bjy4Pu1I+EAlCNUzRDYDdFwFYUKvXcIA==} - engines: {node: '>=0.10.0'} - '@ampproject/remapping@2.2.0': resolution: {integrity: sha512-qRmjj8nj9qmLTQXXmaR1cck3UXSRMPrbsLJAasZpF+t3riI71BXed5ebIOYwQntykeZuhjsdweEc9BxH5Jc26w==} engines: {node: '>=6.0.0'} @@ -240,31 +218,62 @@ packages: '@bcoe/v8-coverage@0.2.3': resolution: {integrity: sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==} - '@cspotcode/source-map-support@0.8.1': - resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==} - engines: {node: '>=12'} - - '@eslint-community/eslint-utils@4.4.0': - resolution: {integrity: sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - peerDependencies: - eslint: ^6.0.0 || ^7.0.0 || >=8.0.0 + '@biomejs/biome@1.8.2': + resolution: {integrity: sha512-XafCzLgs0xbH0bCjYKxQ63ig2V86fZQMq1jiy5pyLToWk9aHxA8GAUxyBtklPHtPYZPGEPOYglQHj4jyfUp+Iw==} + engines: {node: '>=14.21.3'} + hasBin: true - '@eslint-community/regexpp@4.10.1': - resolution: {integrity: sha512-Zm2NGpWELsQAD1xsJzGQpYfvICSsFkEpU0jxBjfdC6uNEWXcHnfs9hScFWtXVDVl+rBQJGrl4g1vcKIejpH9dA==} - engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0} + '@biomejs/cli-darwin-arm64@1.8.2': + resolution: {integrity: sha512-l9msLsTcSIAPqMsPIhodQmb50sEfaXPLQ0YW4cdj6INmd8iaOh/V9NceQb2366vACTJgcWDQ2RzlvURek1T68g==} + engines: {node: '>=14.21.3'} + cpu: [arm64] + os: [darwin] - '@eslint-community/regexpp@4.6.2': - resolution: {integrity: sha512-pPTNuaAG3QMH+buKyBIGJs3g/S5y0caxw0ygM3YyE6yJFySwiGGSzA+mM3KJ8QQvzeLh3blwgSonkFjgQdxzMw==} - engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0} + '@biomejs/cli-darwin-x64@1.8.2': + resolution: {integrity: sha512-Fc4y/FuIxRSiB3TJ+y27vFDE/HJt4QgBuymktsIKEcBZvnKfsRjxvzVDunccRn4xbKgepnp+fn6BoS+ZIg/I3Q==} + engines: {node: '>=14.21.3'} + cpu: [x64] + os: [darwin] - '@eslint/eslintrc@2.1.4': - resolution: {integrity: sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + '@biomejs/cli-linux-arm64-musl@1.8.2': + resolution: {integrity: sha512-WpT41QJJvkZa1eZq0WmD513zkC6AYaMI39HJKmKeiUeX2NZirG+bxv1YRDhqkns1NbBqo3+qrJqBkPmOW+xAVA==} + engines: {node: '>=14.21.3'} + cpu: [arm64] + os: [linux] + + '@biomejs/cli-linux-arm64@1.8.2': + resolution: {integrity: sha512-Q99qwP0qibkZxm2kfnt37OxeIlliDYf5ogi3zX9ij2DULzc+KtPA9Uj0wCljcJofOBsBYaHc7597Q+Bf/251ww==} + engines: {node: '>=14.21.3'} + cpu: [arm64] + os: [linux] + + '@biomejs/cli-linux-x64-musl@1.8.2': + resolution: {integrity: sha512-rk1Wj4d3LIlAlIAS1m2jlyfOjkNbuY1lfwKvWIAeZC51yDMzwhRD7cReE5PE+jqLDtq60PX38hDPeKd7nA1S6A==} + engines: {node: '>=14.21.3'} + cpu: [x64] + os: [linux] + + '@biomejs/cli-linux-x64@1.8.2': + resolution: {integrity: sha512-bjhhUVFchFid2gOjrvBe4fg8BShcpyFQTHuB/QQnfGxs1ddrGP30yq3fHfc6S6MoCcz9Tjd3Zzq1EfWfyy5iHA==} + engines: {node: '>=14.21.3'} + cpu: [x64] + os: [linux] + + '@biomejs/cli-win32-arm64@1.8.2': + resolution: {integrity: sha512-EUbqmCmNWT5xhnxHrCAEBzJB1AnLqxTYoRjlxiCMzGvsy5jQzhCanJ8CT9kNsApW3pfPWBWkoTa7qrwWmwnEGA==} + engines: {node: '>=14.21.3'} + cpu: [arm64] + os: [win32] + + '@biomejs/cli-win32-x64@1.8.2': + resolution: {integrity: sha512-n9H5oRUCk1uNezMgyJh9+hZdtfD8PXLLeq8DUzTycIhl0I1BulIoZ/uxWgRVDFDwAR1JHu1AykISCRFNGnc4iA==} + engines: {node: '>=14.21.3'} + cpu: [x64] + os: [win32] - '@eslint/js@8.57.0': - resolution: {integrity: sha512-Ys+3g2TaW7gADOJzPt83SJtCDhMjndcDMFVQ/Tj9iA1BfJzFKD9mAUXT3OenpuPHbI6P/myECxRJrofUsDx/5g==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + '@cspotcode/source-map-support@0.8.1': + resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==} + engines: {node: '>=12'} '@faker-js/faker@8.4.1': resolution: {integrity: sha512-XQ3cU+Q8Uqmrbf2e0cIC/QN43sTBSC8KF12u29Mb47tWrt2hAgBXSgpZMj4Ao8Uk0iJcU99QsOCaIL8934obCg==} @@ -273,19 +282,6 @@ packages: '@gar/promisify@1.1.3': resolution: {integrity: sha512-k2Ty1JcVojjJFwrg/ThKi2ujJ7XNLYaFGNB/bWT9wGR+oSMJHMa5w+CUq6p/pVrKeNNgA7pCqEcjSnHVoqJQFw==} - '@humanwhocodes/config-array@0.11.14': - resolution: {integrity: sha512-3T8LkOmg45BV5FICb15QQMsyUSWrQ8AygVfC7ZG32zOalnqrilm018ZVCw0eapXux8FtA33q8PSRSstjee3jSg==} - engines: {node: '>=10.10.0'} - deprecated: Use @eslint/config-array instead - - '@humanwhocodes/module-importer@1.0.1': - resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==} - engines: {node: '>=12.22'} - - '@humanwhocodes/object-schema@2.0.2': - resolution: {integrity: sha512-6EwiSjwWYP7pTckG6I5eyFANjPhmPjUX9JRLUSfNPC7FX7zK9gyZAfUEaECL6ALTpGX5AjnBq3C9XmVWPitNpw==} - deprecated: Use @eslint/object-schema instead - '@isaacs/cliui@8.0.2': resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==} engines: {node: '>=12'} @@ -389,18 +385,6 @@ packages: '@jridgewell/trace-mapping@0.3.9': resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==} - '@nodelib/fs.scandir@2.1.5': - resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==} - engines: {node: '>= 8'} - - '@nodelib/fs.stat@2.0.5': - resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==} - engines: {node: '>= 8'} - - '@nodelib/fs.walk@1.2.8': - resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==} - engines: {node: '>= 8'} - '@npmcli/fs@1.1.1': resolution: {integrity: sha512-8KG5RD0GVP4ydEzRn/I4BNDuxDtqVbOdm8675T49OIG/NGhaK0pjPX7ZcDlvKYbA+ulvVK3ztfcF4uBdOxuJbQ==} @@ -472,9 +456,6 @@ packages: '@types/jest@29.5.12': resolution: {integrity: sha512-eDC8bTvT/QhYdxJAulQikueigY5AsdBRH2yDKW3yveW7svY3+DzN84/2NUgkw10RTiJbWqZrTtoGVdYlvFJdLw==} - '@types/json5@0.0.29': - resolution: {integrity: sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==} - '@types/node@20.14.7': resolution: {integrity: sha512-uTr2m2IbJJucF3KUxgnGOZvYbN0QgkGyWxG6973HCpMYFy2KfcgYuIwkJQMQkt1VbBMlvWRbpshFTLxnxCZjKQ==} @@ -487,75 +468,9 @@ packages: '@types/yargs@17.0.10': resolution: {integrity: sha512-gmEaFwpj/7f/ROdtIlci1R1VYU1J4j95m8T+Tj3iBgiBFKg1foE/PSl93bBd5T9LDXNPo8UlNN6W0qwD8O5OaA==} - '@typescript-eslint/eslint-plugin@7.13.1': - resolution: {integrity: sha512-kZqi+WZQaZfPKnsflLJQCz6Ze9FFSMfXrrIOcyargekQxG37ES7DJNpJUE9Q/X5n3yTIP/WPutVNzgknQ7biLg==} - engines: {node: ^18.18.0 || >=20.0.0} - peerDependencies: - '@typescript-eslint/parser': ^7.0.0 - eslint: ^8.56.0 - typescript: '*' - peerDependenciesMeta: - typescript: - optional: true - - '@typescript-eslint/parser@7.13.1': - resolution: {integrity: sha512-1ELDPlnLvDQ5ybTSrMhRTFDfOQEOXNM+eP+3HT/Yq7ruWpciQw+Avi73pdEbA4SooCawEWo3dtYbF68gN7Ed1A==} - engines: {node: ^18.18.0 || >=20.0.0} - peerDependencies: - eslint: ^8.56.0 - typescript: '*' - peerDependenciesMeta: - typescript: - optional: true - - '@typescript-eslint/scope-manager@7.13.1': - resolution: {integrity: sha512-adbXNVEs6GmbzaCpymHQ0MB6E4TqoiVbC0iqG3uijR8ZYfpAXMGttouQzF4Oat3P2GxDVIrg7bMI/P65LiQZdg==} - engines: {node: ^18.18.0 || >=20.0.0} - - '@typescript-eslint/type-utils@7.13.1': - resolution: {integrity: sha512-aWDbLu1s9bmgPGXSzNCxELu+0+HQOapV/y+60gPXafR8e2g1Bifxzevaa+4L2ytCWm+CHqpELq4CSoN9ELiwCg==} - engines: {node: ^18.18.0 || >=20.0.0} - peerDependencies: - eslint: ^8.56.0 - typescript: '*' - peerDependenciesMeta: - typescript: - optional: true - - '@typescript-eslint/types@7.13.1': - resolution: {integrity: sha512-7K7HMcSQIAND6RBL4kDl24sG/xKM13cA85dc7JnmQXw2cBDngg7c19B++JzvJHRG3zG36n9j1i451GBzRuHchw==} - engines: {node: ^18.18.0 || >=20.0.0} - - '@typescript-eslint/typescript-estree@7.13.1': - resolution: {integrity: sha512-uxNr51CMV7npU1BxZzYjoVz9iyjckBduFBP0S5sLlh1tXYzHzgZ3BR9SVsNed+LmwKrmnqN3Kdl5t7eZ5TS1Yw==} - engines: {node: ^18.18.0 || >=20.0.0} - peerDependencies: - typescript: '*' - peerDependenciesMeta: - typescript: - optional: true - - '@typescript-eslint/utils@7.13.1': - resolution: {integrity: sha512-h5MzFBD5a/Gh/fvNdp9pTfqJAbuQC4sCN2WzuXme71lqFJsZtLbjxfSk4r3p02WIArOF9N94pdsLiGutpDbrXQ==} - engines: {node: ^18.18.0 || >=20.0.0} - peerDependencies: - eslint: ^8.56.0 - - '@typescript-eslint/visitor-keys@7.13.1': - resolution: {integrity: sha512-k/Bfne7lrP7hcb7m9zSsgcBmo+8eicqqfNAJ7uUY+jkTFpKeH2FSkWpFRtimBxgkyvqfu9jTPRbYOvud6isdXA==} - engines: {node: ^18.18.0 || >=20.0.0} - - '@ungap/structured-clone@1.2.0': - resolution: {integrity: sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==} - abbrev@1.1.1: resolution: {integrity: sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==} - acorn-jsx@5.3.2: - resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==} - peerDependencies: - acorn: ^6.0.0 || ^7.0.0 || ^8.0.0 - acorn-walk@8.2.0: resolution: {integrity: sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==} engines: {node: '>=0.4.0'} @@ -577,9 +492,6 @@ packages: resolution: {integrity: sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==} engines: {node: '>=8'} - ajv@6.12.6: - resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==} - ansi-escapes@4.3.2: resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==} engines: {node: '>=8'} @@ -633,40 +545,6 @@ packages: argparse@1.0.10: resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==} - argparse@2.0.1: - resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} - - array-buffer-byte-length@1.0.0: - resolution: {integrity: sha512-LPuwb2P+NrQw3XhxGc36+XSvuBPopovXYTR9Ew++Du9Yb/bx5AzBfrIsBoj0EZUifjQU+sHL21sseZ3jerWO/A==} - - array-includes@3.1.7: - resolution: {integrity: sha512-dlcsNBIiWhPkHdOEEKnehA+RNUWDc4UqFtnIXU4uuYDPtA4LDkr7qip2p0VvFAEXNDr0yWZ9PJyIRiGjRLQzwQ==} - engines: {node: '>= 0.4'} - - array-union@2.1.0: - resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==} - engines: {node: '>=8'} - - array.prototype.findlastindex@1.2.3: - resolution: {integrity: sha512-LzLoiOMAxvy+Gd3BAq3B7VeIgPdo+Q8hthvKtXybMvRV0jrXfJM/t8mw7nNlpEcVlVUnCnM2KSX4XU5HmpodOA==} - engines: {node: '>= 0.4'} - - array.prototype.flat@1.3.2: - resolution: {integrity: sha512-djYB+Zx2vLewY8RWlNCUdHjDXs2XOgm602S9E7P/UpHgfeHL00cRiIF+IN/G/aUJ7kGPb6yO/ErDI5V2s8iycA==} - engines: {node: '>= 0.4'} - - array.prototype.flatmap@1.3.2: - resolution: {integrity: sha512-Ewyx0c9PmpcsByhSW4r+9zDU7sGjFc86qf/kKtuSCRdhfbk0SNLLkaT5qvcHnRGgc5NP/ly/y+qkXkqONX54CQ==} - engines: {node: '>= 0.4'} - - arraybuffer.prototype.slice@1.0.1: - resolution: {integrity: sha512-09x0ZWFEjj4WD8PDbykUwo3t9arLn8NIzmmYEJFpYekOAQjpkGSyrQhNoRTcwwcFRu+ycWF78QZ63oWTqSjBcw==} - engines: {node: '>= 0.4'} - - available-typed-arrays@1.0.5: - resolution: {integrity: sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==} - engines: {node: '>= 0.4'} - babel-jest@29.7.0: resolution: {integrity: sha512-BrvGY3xZSwEcCzKvKsCi2GgHqDqsYkOP4/by5xCgIwGXQxIEh+8ew3gmrE1y7XRR6LHZIj6yLYnUi/mm2KXKBg==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} @@ -739,9 +617,6 @@ packages: resolution: {integrity: sha512-VVdYzXEn+cnbXpFgWs5hTT7OScegHVmLhJIR8Ufqk3iFD6A6j5iSX1KuBTfNEv4tdJWE2PzA6IVFtcLC7fN9wQ==} engines: {node: '>= 10'} - call-bind@1.0.2: - resolution: {integrity: sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==} - callsites@3.1.0: resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} engines: {node: '>=6'} @@ -849,14 +724,6 @@ packages: dayjs@1.11.10: resolution: {integrity: sha512-vjAczensTgRcqDERK0SR2XMwsF/tSvnvlv6VcF2GIhg6Sx4yOIt/irsr1RDJsKiIyBzJDpCoXiWWq28MqH2cnQ==} - debug@3.2.7: - resolution: {integrity: sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==} - peerDependencies: - supports-color: '*' - peerDependenciesMeta: - supports-color: - optional: true - debug@4.3.4: resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==} engines: {node: '>=6.0'} @@ -882,17 +749,10 @@ packages: resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==} engines: {node: '>=4.0.0'} - deep-is@0.1.4: - resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==} - deepmerge@4.2.2: resolution: {integrity: sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg==} engines: {node: '>=0.10.0'} - define-properties@1.2.0: - resolution: {integrity: sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==} - engines: {node: '>= 0.4'} - delegates@1.0.0: resolution: {integrity: sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==} @@ -916,18 +776,6 @@ packages: resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==} engines: {node: '>=0.3.1'} - dir-glob@3.0.1: - resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==} - engines: {node: '>=8'} - - doctrine@2.1.0: - resolution: {integrity: sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==} - engines: {node: '>=0.10.0'} - - doctrine@3.0.0: - resolution: {integrity: sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==} - engines: {node: '>=6.0.0'} - dotenv@16.0.3: resolution: {integrity: sha512-7GO6HghkA5fYG9TYnNxi14/7K9f5occMlp3zXAuSxn7CKCxt9xbNWG7yF8hTCSUchlfWSe3uLmlPfigevRItzQ==} engines: {node: '>=12'} @@ -954,10 +802,6 @@ packages: end-of-stream@1.4.4: resolution: {integrity: sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==} - enhanced-resolve@5.15.0: - resolution: {integrity: sha512-LXYT42KJ7lpIKECr2mAXIaMldcNCh/7E0KBKOu4KSfkHmP+mZmSs+8V5gBAqisWBy0OO4W5Oyys0GO1Y8KtdKg==} - engines: {node: '>=10.13.0'} - env-paths@2.2.1: resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==} engines: {node: '>=6'} @@ -968,21 +812,6 @@ packages: error-ex@1.3.2: resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==} - es-abstract@1.22.1: - resolution: {integrity: sha512-ioRRcXMO6OFyRpyzV3kE1IIBd4WG5/kltnzdxSCqoP8CMGs/Li+M1uF5o7lOkZVFjDs+NLesthnF66Pg/0q0Lw==} - engines: {node: '>= 0.4'} - - es-set-tostringtag@2.0.1: - resolution: {integrity: sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg==} - engines: {node: '>= 0.4'} - - es-shim-unscopables@1.0.0: - resolution: {integrity: sha512-Jm6GPcCdC30eMLbZ2x8z2WuRwAws3zTBBKuusffYVUrNj/GVSUAZ+xKMaUpfNDR5IbyNA5LJbaecoUVbmUcB1w==} - - es-to-primitive@1.2.1: - resolution: {integrity: sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==} - engines: {node: '>= 0.4'} - escalade@3.1.1: resolution: {integrity: sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==} engines: {node: '>=6'} @@ -995,95 +824,11 @@ packages: resolution: {integrity: sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==} engines: {node: '>=8'} - escape-string-regexp@4.0.0: - resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==} - engines: {node: '>=10'} - - eslint-config-prettier@9.1.0: - resolution: {integrity: sha512-NSWl5BFQWEPi1j4TjVNItzYV7dZXZ+wP6I6ZhrBGpChQhZRUaElihE9uRRkcbRnNb76UMKDF3r+WTmNcGPKsqw==} - hasBin: true - peerDependencies: - eslint: '>=7.0.0' - - eslint-import-resolver-node@0.3.9: - resolution: {integrity: sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==} - - eslint-import-resolver-typescript@3.6.1: - resolution: {integrity: sha512-xgdptdoi5W3niYeuQxKmzVDTATvLYqhpwmykwsh7f6HIOStGWEIL9iqZgQDF9u9OEzrRwR8no5q2VT+bjAujTg==} - engines: {node: ^14.18.0 || >=16.0.0} - peerDependencies: - eslint: '*' - eslint-plugin-import: '*' - - eslint-module-utils@2.8.0: - resolution: {integrity: sha512-aWajIYfsqCKRDgUfjEXNN/JlrzauMuSEy5sbd7WXbtW3EH6A6MpwEh42c7qD+MqQo9QMJ6fWLAeIJynx0g6OAw==} - engines: {node: '>=4'} - peerDependencies: - '@typescript-eslint/parser': '*' - eslint: '*' - eslint-import-resolver-node: '*' - eslint-import-resolver-typescript: '*' - eslint-import-resolver-webpack: '*' - peerDependenciesMeta: - '@typescript-eslint/parser': - optional: true - eslint: - optional: true - eslint-import-resolver-node: - optional: true - eslint-import-resolver-typescript: - optional: true - eslint-import-resolver-webpack: - optional: true - - eslint-plugin-import@2.29.1: - resolution: {integrity: sha512-BbPC0cuExzhiMo4Ff1BTVwHpjjv28C5R+btTOGaCRC7UEz801up0JadwkeSk5Ued6TG34uaczuVuH6qyy5YUxw==} - engines: {node: '>=4'} - peerDependencies: - '@typescript-eslint/parser': '*' - eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 - peerDependenciesMeta: - '@typescript-eslint/parser': - optional: true - - eslint-scope@7.2.2: - resolution: {integrity: sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - - eslint-visitor-keys@3.4.3: - resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - - eslint@8.57.0: - resolution: {integrity: sha512-dZ6+mexnaTIbSBZWgou51U6OmzIhYM2VcNdtiTtI7qPNZm35Akpr0f6vtw3w1Kmn5PYo+tZVfh13WrhpS6oLqQ==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - hasBin: true - - espree@9.6.1: - resolution: {integrity: sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - esprima@4.0.1: resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==} engines: {node: '>=4'} hasBin: true - esquery@1.5.0: - resolution: {integrity: sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==} - engines: {node: '>=0.10'} - - esrecurse@4.3.0: - resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==} - engines: {node: '>=4.0'} - - estraverse@5.3.0: - resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==} - engines: {node: '>=4.0'} - - esutils@2.0.3: - resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==} - engines: {node: '>=0.10.0'} - execa@5.1.1: resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==} engines: {node: '>=10'} @@ -1100,29 +845,12 @@ packages: resolution: {integrity: sha512-2Zks0hf1VLFYI1kbh0I5jP3KHHyCHpkfyHBzsSXRFgl/Bg9mWYfMW8oD+PdMPlEwy5HNsR9JutYy6pMeOh61nw==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - fast-deep-equal@3.1.3: - resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} - - fast-glob@3.3.1: - resolution: {integrity: sha512-kNFPyjhh5cKjrUltxs+wFx+ZkbRaxxmZ+X0ZU31SOsxCEtP9VPgtq2teZw1DebupL5GmDaNQ6yKMMVcM41iqDg==} - engines: {node: '>=8.6.0'} - fast-json-stable-stringify@2.1.0: resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==} - fast-levenshtein@2.0.6: - resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==} - - fastq@1.13.0: - resolution: {integrity: sha512-YpkpUnK8od0o1hmeSc7UUs/eB/vIPWJYjKck2QKIzAf71Vm1AAQ3EbuZB3g2JIy+pg+ERD0vqI79KyZiB2e2Nw==} - fb-watchman@2.0.1: resolution: {integrity: sha512-DkPJKQeY6kKwmuMretBhr7G6Vodr7bFwDYTXIkfG1gjvNpaxBTQV3PbXg6bR1c1UP4jPOX0jHUbbHANL9vRjVg==} - file-entry-cache@6.0.1: - resolution: {integrity: sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==} - engines: {node: ^10.12.0 || >=12.0.0} - file-uri-to-path@1.0.0: resolution: {integrity: sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==} @@ -1134,20 +862,6 @@ packages: resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==} engines: {node: '>=8'} - find-up@5.0.0: - resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==} - engines: {node: '>=10'} - - flat-cache@3.0.4: - resolution: {integrity: sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==} - engines: {node: ^10.12.0 || >=12.0.0} - - flatted@3.2.6: - resolution: {integrity: sha512-0sQoMh9s0BYsm+12Huy/rkKxVu4R1+r96YX5cG44rHV0pQ6iC3Q+mkoMFaGWObMFYQxCVT+ssG1ksneA2MI9KQ==} - - for-each@0.3.3: - resolution: {integrity: sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==} - foreground-child@3.1.1: resolution: {integrity: sha512-TMKDUnIte6bfb5nWv7V/caI169OHgvwjb7V4WkeUvbQQdjr5rWKqHFiKWb/fcOwB+CzBT+qbWjvj+DVwRskpIg==} engines: {node: '>=14'} @@ -1170,13 +884,6 @@ packages: function-bind@1.1.2: resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} - function.prototype.name@1.1.5: - resolution: {integrity: sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA==} - engines: {node: '>= 0.4'} - - functions-have-names@1.2.3: - resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==} - gauge@4.0.4: resolution: {integrity: sha512-f9m+BEN5jkg6a0fZjleidjN51VE1X+mPFQ2DJ0uv1V39oCLCbsGe6yjbBnp7eK7z/+GAon99a3nHuqbuuthyPg==} engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0} @@ -1190,9 +897,6 @@ packages: resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==} engines: {node: 6.* || 8.* || >= 10.*} - get-intrinsic@1.2.1: - resolution: {integrity: sha512-2DcsyfABl+gVHEfCOaTrWgyt+tb6MSEGmKq+kI5HwLbIYgjgmMcV8KQ41uaKz1xxUcn9tJtgFbQUEVcEbd0FYw==} - get-package-type@0.1.0: resolution: {integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==} engines: {node: '>=8.0.0'} @@ -1201,24 +905,9 @@ packages: resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==} engines: {node: '>=10'} - get-symbol-description@1.0.0: - resolution: {integrity: sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==} - engines: {node: '>= 0.4'} - - get-tsconfig@4.7.2: - resolution: {integrity: sha512-wuMsz4leaj5hbGgg4IvDU0bqJagpftG5l5cXIAvo8uZrqn0NJqwtfupTN00VnkQJPcIRrxYrm1Ue24btpCha2A==} - github-from-package@0.0.0: resolution: {integrity: sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==} - glob-parent@5.1.2: - resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==} - engines: {node: '>= 6'} - - glob-parent@6.0.2: - resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==} - engines: {node: '>=10.13.0'} - glob@10.3.10: resolution: {integrity: sha512-fa46+tv1Ak0UPK1TOy/pZrIybNNt4HCv7SDzwyfiOZkvZLEbjsZkJBPtDHVshZjbecAoAGSC20MjLDG/qr679g==} engines: {node: '>=16 || 14 >=14.17'} @@ -1232,30 +921,9 @@ packages: resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==} engines: {node: '>=4'} - globals@13.19.0: - resolution: {integrity: sha512-dkQ957uSRWHw7CFXLUtUHQI3g3aWApYhfNR2O6jn/907riyTYKVBmxYVROkBcY614FSSeSJh7Xm7SrUWCxvJMQ==} - engines: {node: '>=8'} - - globalthis@1.0.3: - resolution: {integrity: sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==} - engines: {node: '>= 0.4'} - - globby@11.1.0: - resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==} - engines: {node: '>=10'} - - gopd@1.0.1: - resolution: {integrity: sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==} - graceful-fs@4.2.10: resolution: {integrity: sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==} - graphemer@1.4.0: - resolution: {integrity: sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==} - - has-bigints@1.0.2: - resolution: {integrity: sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==} - has-flag@3.0.0: resolution: {integrity: sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==} engines: {node: '>=4'} @@ -1264,28 +932,9 @@ packages: resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} engines: {node: '>=8'} - has-property-descriptors@1.0.0: - resolution: {integrity: sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==} - - has-proto@1.0.1: - resolution: {integrity: sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==} - engines: {node: '>= 0.4'} - - has-symbols@1.0.3: - resolution: {integrity: sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==} - engines: {node: '>= 0.4'} - - has-tostringtag@1.0.0: - resolution: {integrity: sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==} - engines: {node: '>= 0.4'} - has-unicode@2.0.1: resolution: {integrity: sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==} - has@1.0.3: - resolution: {integrity: sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==} - engines: {node: '>= 0.4.0'} - hasown@2.0.0: resolution: {integrity: sha512-vUptKVTpIJhcczKBbgnS+RtcuYMB8+oNzPK2/Hp3hanz8JmpATdmmgLgSaadVREkDm+e2giHwY3ZRkyjSIDDFA==} engines: {node: '>= 0.4'} @@ -1321,18 +970,6 @@ packages: ieee754@1.2.1: resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==} - ignore@5.2.4: - resolution: {integrity: sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==} - engines: {node: '>= 4'} - - ignore@5.3.1: - resolution: {integrity: sha512-5Fytz/IraMjqpwfd34ke28PTVMjZjJG2MPn5t7OE4eUCUNf8BAa7b5WUS9/Qvr6mwOQS7Mk6vdsMno5he+T8Xw==} - engines: {node: '>= 4'} - - import-fresh@3.3.0: - resolution: {integrity: sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==} - engines: {node: '>=6'} - import-local@3.1.0: resolution: {integrity: sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg==} engines: {node: '>=8'} @@ -1359,41 +996,15 @@ packages: ini@1.3.8: resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==} - internal-slot@1.0.5: - resolution: {integrity: sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ==} - engines: {node: '>= 0.4'} - ip@2.0.0: resolution: {integrity: sha512-WKa+XuLG1A1R0UWhl2+1XQSi+fZWMsYKffMZTTYsiZaUD8k2yDAj5atimTUD2TZkyCkNEeYE5NhFZmupOGtjYQ==} - is-array-buffer@3.0.2: - resolution: {integrity: sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==} - is-arrayish@0.2.1: resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==} - is-bigint@1.0.4: - resolution: {integrity: sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==} - - is-boolean-object@1.1.2: - resolution: {integrity: sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==} - engines: {node: '>= 0.4'} - - is-callable@1.2.7: - resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==} - engines: {node: '>= 0.4'} - is-core-module@2.13.1: resolution: {integrity: sha512-hHrIjvZsftOsvKSn2TRYl63zvxsgE0K+0mYMoH6gD4omR5IWB2KynivBQczo3+wF1cCkjzvptnI9Q0sPU66ilw==} - is-date-object@1.0.5: - resolution: {integrity: sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==} - engines: {node: '>= 0.4'} - - is-extglob@2.1.1: - resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} - engines: {node: '>=0.10.0'} - is-fullwidth-code-point@3.0.0: resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==} engines: {node: '>=8'} @@ -1402,58 +1013,17 @@ packages: resolution: {integrity: sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==} engines: {node: '>=6'} - is-glob@4.0.3: - resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} - engines: {node: '>=0.10.0'} - is-lambda@1.0.1: resolution: {integrity: sha512-z7CMFGNrENq5iFB9Bqo64Xk6Y9sg+epq1myIcdHaGnbMTYOxvzsEtdYqQUylB7LxfkvgrrjP32T6Ywciio9UIQ==} - is-negative-zero@2.0.2: - resolution: {integrity: sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==} - engines: {node: '>= 0.4'} - - is-number-object@1.0.7: - resolution: {integrity: sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==} - engines: {node: '>= 0.4'} - is-number@7.0.0: resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==} engines: {node: '>=0.12.0'} - is-path-inside@3.0.3: - resolution: {integrity: sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==} - engines: {node: '>=8'} - - is-regex@1.1.4: - resolution: {integrity: sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==} - engines: {node: '>= 0.4'} - - is-shared-array-buffer@1.0.2: - resolution: {integrity: sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==} - is-stream@2.0.1: resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==} engines: {node: '>=8'} - is-string@1.0.7: - resolution: {integrity: sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==} - engines: {node: '>= 0.4'} - - is-symbol@1.0.4: - resolution: {integrity: sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==} - engines: {node: '>= 0.4'} - - is-typed-array@1.1.10: - resolution: {integrity: sha512-PJqgEHiWZvMpaFZ3uTc8kHPM4+4ADTlDniuQL7cU/UDA0Ql7F70yGfHph3cLNe+c9toaigv+DFzTJKhc2CtO6A==} - engines: {node: '>= 0.4'} - - is-weakref@1.0.2: - resolution: {integrity: sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==} - - isarray@2.0.5: - resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==} - isexe@2.0.0: resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} @@ -1621,10 +1191,6 @@ packages: resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==} hasBin: true - js-yaml@4.1.0: - resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==} - hasBin: true - jsesc@2.5.2: resolution: {integrity: sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==} engines: {node: '>=4'} @@ -1633,16 +1199,6 @@ packages: json-parse-even-better-errors@2.3.1: resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==} - json-schema-traverse@0.4.1: - resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==} - - json-stable-stringify-without-jsonify@1.0.1: - resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==} - - json5@1.0.2: - resolution: {integrity: sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==} - hasBin: true - json5@2.2.3: resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==} engines: {node: '>=6'} @@ -1656,10 +1212,6 @@ packages: resolution: {integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==} engines: {node: '>=6'} - levn@0.4.1: - resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==} - engines: {node: '>= 0.8.0'} - lines-and-columns@1.2.4: resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==} @@ -1667,16 +1219,9 @@ packages: resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==} engines: {node: '>=8'} - locate-path@6.0.0: - resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==} - engines: {node: '>=10'} - lodash.memoize@4.1.2: resolution: {integrity: sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==} - lodash.merge@4.6.2: - resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==} - lru-cache@6.0.0: resolution: {integrity: sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==} engines: {node: '>=10'} @@ -1702,10 +1247,6 @@ packages: merge-stream@2.0.0: resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==} - merge2@1.4.1: - resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==} - engines: {node: '>= 8'} - micromatch@4.0.5: resolution: {integrity: sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==} engines: {node: '>=8.6'} @@ -1725,10 +1266,6 @@ packages: resolution: {integrity: sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==} engines: {node: '>=16 || 14 >=14.17'} - minimatch@9.0.4: - resolution: {integrity: sha512-KqWh+VchfxcMNRAJjj2tnsSJdNbHsVgnkBhTNrW7AjVo6OvLtxw8zfT9oLw1JSohlFzJ8jCoTgaoXvJ+kHt6fw==} - engines: {node: '>=16 || 14 >=14.17'} - minimist@1.2.6: resolution: {integrity: sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==} @@ -1833,28 +1370,6 @@ packages: resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==} engines: {node: '>=0.10.0'} - object-inspect@1.12.3: - resolution: {integrity: sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==} - - object-keys@1.1.1: - resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==} - engines: {node: '>= 0.4'} - - object.assign@4.1.4: - resolution: {integrity: sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==} - engines: {node: '>= 0.4'} - - object.fromentries@2.0.7: - resolution: {integrity: sha512-UPbPHML6sL8PI/mOqPwsH4G6iyXcCGzLin8KvEPenOZN5lpCNBZZQ+V62vdjB1mQHrmqGQt5/OJzemUA+KJmEA==} - engines: {node: '>= 0.4'} - - object.groupby@1.0.1: - resolution: {integrity: sha512-HqaQtqLnp/8Bn4GL16cj+CUYbnpe1bh0TtEaWvybszDG4tgxCJuRpV8VGuvNaI1fAnI4lUJzDG55MXcOH4JZcQ==} - - object.values@1.1.7: - resolution: {integrity: sha512-aU6xnDFYT3x17e/f0IiiwlGPTy2jzMySGfUB4fq6z7CV8l85CWHDk5ErhyhpfDHhrOMwGFhSQkhMGHaIotA6Ng==} - engines: {node: '>= 0.4'} - once@1.4.0: resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==} @@ -1862,10 +1377,6 @@ packages: resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==} engines: {node: '>=6'} - optionator@0.9.3: - resolution: {integrity: sha512-JjCoypp+jKn1ttEFExxhetCKeJt9zhAgAve5FXHixTvFDW/5aEktX9bufBKLRRMdU7bNtpLfcGu94B3cdEJgjg==} - engines: {node: '>= 0.8.0'} - p-limit@2.3.0: resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==} engines: {node: '>=6'} @@ -1878,10 +1389,6 @@ packages: resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==} engines: {node: '>=8'} - p-locate@5.0.0: - resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==} - engines: {node: '>=10'} - p-map@4.0.0: resolution: {integrity: sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==} engines: {node: '>=10'} @@ -1890,10 +1397,6 @@ packages: resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==} engines: {node: '>=6'} - parent-module@1.0.1: - resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==} - engines: {node: '>=6'} - parse-json@5.2.0: resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==} engines: {node: '>=8'} @@ -1926,10 +1429,6 @@ packages: resolution: {integrity: sha512-MkhCqzzBEpPvxxQ71Md0b1Kk51W01lrYvlMzSUaIzNsODdd7mqhiimSZlr+VegAz5Z6Vzt9Xg2ttE//XBhH3EQ==} engines: {node: '>=16 || 14 >=14.17'} - path-type@4.0.0: - resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==} - engines: {node: '>=8'} - picocolors@1.0.0: resolution: {integrity: sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==} @@ -1950,15 +1449,6 @@ packages: engines: {node: '>=10'} hasBin: true - prelude-ls@1.2.1: - resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==} - engines: {node: '>= 0.8.0'} - - prettier@3.3.2: - resolution: {integrity: sha512-rAVeHYMcv8ATV5d508CFdn+8/pHPpXeIid1DdrPwXnaAdH7cqjVbpJaT5eq4yRAFU/lsbwYwSF/n5iNrdJHPQA==} - engines: {node: '>=14'} - hasBin: true - pretty-format@29.7.0: resolution: {integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} @@ -1982,16 +1472,9 @@ packages: pump@3.0.0: resolution: {integrity: sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==} - punycode@2.1.1: - resolution: {integrity: sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==} - engines: {node: '>=6'} - pure-rand@6.0.1: resolution: {integrity: sha512-t+x1zEHDjBwkDGY5v5ApnZ/utcd4XYDiJsaQQoptTXgUXX95sDg1elCdJghzicm7n2mbCBJ3uYWr6M22SO19rg==} - queue-microtask@1.2.3: - resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==} - rc@1.2.8: resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==} hasBin: true @@ -2007,10 +1490,6 @@ packages: resolution: {integrity: sha512-i5lLI6iw9AU3Uu4szRNPPEkomnkjRTaVt9hy/bn5g/oSzekBSMeLZblcjP74AW0vBabqERLLIrz+gR8QYR54Tw==} deprecated: This version has a critical bug in fallback handling. Please upgrade to reflect-metadata@0.2.2 or newer. - regexp.prototype.flags@1.5.0: - resolution: {integrity: sha512-0SutC3pNudRKgquxGoRGIz946MZVHqbNfPjBdxeOhBrdgDKlRoXmYLQN9xRbrR09ZXWeGAdPuif7egofn6v5LA==} - engines: {node: '>= 0.4'} - require-directory@2.1.1: resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==} engines: {node: '>=0.10.0'} @@ -2019,17 +1498,10 @@ packages: resolution: {integrity: sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==} engines: {node: '>=8'} - resolve-from@4.0.0: - resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==} - engines: {node: '>=4'} - resolve-from@5.0.0: resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==} engines: {node: '>=8'} - resolve-pkg-maps@1.0.0: - resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==} - resolve.exports@2.0.0: resolution: {integrity: sha512-6K/gDlqgQscOlg9fSRpWstA8sYe8rbELsSTNpx+3kTrsVCzvSl0zIvRErM7fdl9ERWDsKnrLnwB+Ne89918XOg==} engines: {node: '>=10'} @@ -2042,10 +1514,6 @@ packages: resolution: {integrity: sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==} engines: {node: '>= 4'} - reusify@1.0.4: - resolution: {integrity: sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==} - engines: {iojs: '>=1.0.0', node: '>=0.10.0'} - rimraf@3.0.2: resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==} deprecated: Rimraf versions prior to v4 are no longer supported @@ -2056,22 +1524,12 @@ packages: engines: {node: '>=14.18'} hasBin: true - run-parallel@1.2.0: - resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==} - - safe-array-concat@1.0.0: - resolution: {integrity: sha512-9dVEFruWIsnie89yym+xWTAYASdpw3CJV7Li/6zBewGf9z2i1j31rP6jnY0pHEO4QZh6N0K11bFjWmdR8UGdPQ==} - engines: {node: '>=0.4'} - safe-buffer@5.1.2: resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==} safe-buffer@5.2.1: resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==} - safe-regex-test@1.0.0: - resolution: {integrity: sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==} - safer-buffer@2.1.2: resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==} @@ -2104,9 +1562,6 @@ packages: resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==} engines: {node: '>=8'} - side-channel@1.0.4: - resolution: {integrity: sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==} - signal-exit@3.0.7: resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==} @@ -2172,16 +1627,6 @@ packages: resolution: {integrity: sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==} engines: {node: '>=12'} - string.prototype.trim@1.2.7: - resolution: {integrity: sha512-p6TmeT1T3411M8Cgg9wBTMRtY2q9+PNy9EV1i2lIXUN/btt763oIfxwN3RR8VU6wHX8j/1CFy0L+YuThm6bgOg==} - engines: {node: '>= 0.4'} - - string.prototype.trimend@1.0.6: - resolution: {integrity: sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==} - - string.prototype.trimstart@1.0.6: - resolution: {integrity: sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==} - string_decoder@1.3.0: resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==} @@ -2193,10 +1638,6 @@ packages: resolution: {integrity: sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==} engines: {node: '>=12'} - strip-bom@3.0.0: - resolution: {integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==} - engines: {node: '>=4'} - strip-bom@4.0.0: resolution: {integrity: sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==} engines: {node: '>=8'} @@ -2229,10 +1670,6 @@ packages: resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==} engines: {node: '>= 0.4'} - tapable@2.2.1: - resolution: {integrity: sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==} - engines: {node: '>=6'} - tar-fs@2.1.1: resolution: {integrity: sha512-V0r2Y9scmbDRLCNex/+hYzvp/zyYjvFbHPNgVTKfQvVrb6guiE/fxP+XblDNR011utopbkex2nM4dHNV6GDsng==} @@ -2248,9 +1685,6 @@ packages: resolution: {integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==} engines: {node: '>=8'} - text-table@0.2.0: - resolution: {integrity: sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==} - thenify-all@1.6.0: resolution: {integrity: sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==} engines: {node: '>=0.8'} @@ -2269,12 +1703,6 @@ packages: resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==} engines: {node: '>=8.0'} - ts-api-utils@1.3.0: - resolution: {integrity: sha512-UQMIo7pb8WRomKR1/+MFVLTroIvDVtMX3K6OUir8ynLyzB8Jeriont2bTAtmNPa1ekAgN7YPDyf6V+ygrdU+eQ==} - engines: {node: '>=16'} - peerDependencies: - typescript: '>=4.2.0' - ts-jest@29.1.5: resolution: {integrity: sha512-UuClSYxM7byvvYfyWdFI+/2UxMmwNyJb0NPkZPQE2hew3RurV7l7zURgOHAd/1I1ZdPpe3GUsXNXAcN8TFKSIg==} engines: {node: ^14.15.0 || ^16.10.0 || ^18.0.0 || >=20.0.0} @@ -2313,46 +1741,20 @@ packages: '@swc/wasm': optional: true - tsconfig-paths@3.15.0: - resolution: {integrity: sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg==} - tslib@2.6.3: resolution: {integrity: sha512-xNvxJEOUiWPGhUuUdQgAJPKOOJfGnIyKySOc09XkKsgdUV/3E2zvwZYdejjmRgPCgcym1juLH3226yA7sEFJKQ==} tunnel-agent@0.6.0: resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==} - type-check@0.4.0: - resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==} - engines: {node: '>= 0.8.0'} - type-detect@4.0.8: resolution: {integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==} engines: {node: '>=4'} - type-fest@0.20.2: - resolution: {integrity: sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==} - engines: {node: '>=10'} - type-fest@0.21.3: resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==} engines: {node: '>=10'} - typed-array-buffer@1.0.0: - resolution: {integrity: sha512-Y8KTSIglk9OZEr8zywiIHG/kmQ7KWyjseXs1CbSo8vC42w7hg2HgYTxSWwP0+is7bWDc1H+Fo026CpHFwm8tkw==} - engines: {node: '>= 0.4'} - - typed-array-byte-length@1.0.0: - resolution: {integrity: sha512-Or/+kvLxNpeQ9DtSydonMxCx+9ZXOswtwJn17SNLvhptaXYDJvkFFP5zbfU/uLmvnBJlI4yrnXRxpdWH/M5tNA==} - engines: {node: '>= 0.4'} - - typed-array-byte-offset@1.0.0: - resolution: {integrity: sha512-RD97prjEt9EL8YgAgpOkf3O4IF9lhJFr9g0htQkm0rchFp/Vx7LW5Q8fSXXub7BXAODyUQohRMyOc3faCPd0hg==} - engines: {node: '>= 0.4'} - - typed-array-length@1.0.4: - resolution: {integrity: sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==} - typeorm@0.3.20: resolution: {integrity: sha512-sJ0T08dV5eoZroaq9uPKBoNcGslHBR4E4y+EBHs//SiGbblGe7IeduP/IH4ddCcj0qp3PHwDwGnuvqEAnKlq/Q==} engines: {node: '>=16.13.0'} @@ -2416,9 +1818,6 @@ packages: engines: {node: '>=14.17'} hasBin: true - unbox-primitive@1.0.2: - resolution: {integrity: sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==} - undici-types@5.26.5: resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==} @@ -2434,9 +1833,6 @@ packages: peerDependencies: browserslist: '>= 4.21.0' - uri-js@4.4.1: - resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==} - util-deprecate@1.0.2: resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==} @@ -2454,13 +1850,6 @@ packages: walker@1.0.8: resolution: {integrity: sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==} - which-boxed-primitive@1.0.2: - resolution: {integrity: sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==} - - which-typed-array@1.1.11: - resolution: {integrity: sha512-qe9UWWpkeG5yzZ0tNYxDmd7vo58HDBc39mZ0xWWpolAGADdFOzkfamWLDxkOWcvHQKVmdTyQdLD4NOfjLWTKew==} - engines: {node: '>= 0.4'} - which@2.0.2: resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==} engines: {node: '>= 8'} @@ -2517,8 +1906,6 @@ packages: snapshots: - '@aashutoshrathi/word-wrap@1.2.6': {} - '@ampproject/remapping@2.2.0': dependencies: '@jridgewell/gen-mapping': 0.1.1 @@ -2722,51 +2109,49 @@ snapshots: '@bcoe/v8-coverage@0.2.3': {} - '@cspotcode/source-map-support@0.8.1': - dependencies: - '@jridgewell/trace-mapping': 0.3.9 + '@biomejs/biome@1.8.2': + optionalDependencies: + '@biomejs/cli-darwin-arm64': 1.8.2 + '@biomejs/cli-darwin-x64': 1.8.2 + '@biomejs/cli-linux-arm64': 1.8.2 + '@biomejs/cli-linux-arm64-musl': 1.8.2 + '@biomejs/cli-linux-x64': 1.8.2 + '@biomejs/cli-linux-x64-musl': 1.8.2 + '@biomejs/cli-win32-arm64': 1.8.2 + '@biomejs/cli-win32-x64': 1.8.2 + + '@biomejs/cli-darwin-arm64@1.8.2': + optional: true - '@eslint-community/eslint-utils@4.4.0(eslint@8.57.0)': - dependencies: - eslint: 8.57.0 - eslint-visitor-keys: 3.4.3 + '@biomejs/cli-darwin-x64@1.8.2': + optional: true - '@eslint-community/regexpp@4.10.1': {} + '@biomejs/cli-linux-arm64-musl@1.8.2': + optional: true - '@eslint-community/regexpp@4.6.2': {} + '@biomejs/cli-linux-arm64@1.8.2': + optional: true - '@eslint/eslintrc@2.1.4': - dependencies: - ajv: 6.12.6 - debug: 4.3.4 - espree: 9.6.1 - globals: 13.19.0 - ignore: 5.2.4 - import-fresh: 3.3.0 - js-yaml: 4.1.0 - minimatch: 3.1.2 - strip-json-comments: 3.1.1 - transitivePeerDependencies: - - supports-color + '@biomejs/cli-linux-x64-musl@1.8.2': + optional: true - '@eslint/js@8.57.0': {} + '@biomejs/cli-linux-x64@1.8.2': + optional: true - '@faker-js/faker@8.4.1': {} + '@biomejs/cli-win32-arm64@1.8.2': + optional: true - '@gar/promisify@1.1.3': + '@biomejs/cli-win32-x64@1.8.2': optional: true - '@humanwhocodes/config-array@0.11.14': + '@cspotcode/source-map-support@0.8.1': dependencies: - '@humanwhocodes/object-schema': 2.0.2 - debug: 4.3.4 - minimatch: 3.1.2 - transitivePeerDependencies: - - supports-color + '@jridgewell/trace-mapping': 0.3.9 - '@humanwhocodes/module-importer@1.0.1': {} + '@faker-js/faker@8.4.1': {} - '@humanwhocodes/object-schema@2.0.2': {} + '@gar/promisify@1.1.3': + optional: true '@isaacs/cliui@8.0.2': dependencies: @@ -2976,18 +2361,6 @@ snapshots: '@jridgewell/resolve-uri': 3.1.0 '@jridgewell/sourcemap-codec': 1.4.14 - '@nodelib/fs.scandir@2.1.5': - dependencies: - '@nodelib/fs.stat': 2.0.5 - run-parallel: 1.2.0 - - '@nodelib/fs.stat@2.0.5': {} - - '@nodelib/fs.walk@1.2.8': - dependencies: - '@nodelib/fs.scandir': 2.1.5 - fastq: 1.13.0 - '@npmcli/fs@1.1.1': dependencies: '@gar/promisify': 1.1.3 @@ -3068,8 +2441,6 @@ snapshots: expect: 29.7.0 pretty-format: 29.7.0 - '@types/json5@0.0.29': {} - '@types/node@20.14.7': dependencies: undici-types: 5.26.5 @@ -3082,96 +2453,9 @@ snapshots: dependencies: '@types/yargs-parser': 21.0.0 - '@typescript-eslint/eslint-plugin@7.13.1(@typescript-eslint/parser@7.13.1(eslint@8.57.0)(typescript@5.5.2))(eslint@8.57.0)(typescript@5.5.2)': - dependencies: - '@eslint-community/regexpp': 4.10.1 - '@typescript-eslint/parser': 7.13.1(eslint@8.57.0)(typescript@5.5.2) - '@typescript-eslint/scope-manager': 7.13.1 - '@typescript-eslint/type-utils': 7.13.1(eslint@8.57.0)(typescript@5.5.2) - '@typescript-eslint/utils': 7.13.1(eslint@8.57.0)(typescript@5.5.2) - '@typescript-eslint/visitor-keys': 7.13.1 - eslint: 8.57.0 - graphemer: 1.4.0 - ignore: 5.3.1 - natural-compare: 1.4.0 - ts-api-utils: 1.3.0(typescript@5.5.2) - optionalDependencies: - typescript: 5.5.2 - transitivePeerDependencies: - - supports-color - - '@typescript-eslint/parser@7.13.1(eslint@8.57.0)(typescript@5.5.2)': - dependencies: - '@typescript-eslint/scope-manager': 7.13.1 - '@typescript-eslint/types': 7.13.1 - '@typescript-eslint/typescript-estree': 7.13.1(typescript@5.5.2) - '@typescript-eslint/visitor-keys': 7.13.1 - debug: 4.3.4 - eslint: 8.57.0 - optionalDependencies: - typescript: 5.5.2 - transitivePeerDependencies: - - supports-color - - '@typescript-eslint/scope-manager@7.13.1': - dependencies: - '@typescript-eslint/types': 7.13.1 - '@typescript-eslint/visitor-keys': 7.13.1 - - '@typescript-eslint/type-utils@7.13.1(eslint@8.57.0)(typescript@5.5.2)': - dependencies: - '@typescript-eslint/typescript-estree': 7.13.1(typescript@5.5.2) - '@typescript-eslint/utils': 7.13.1(eslint@8.57.0)(typescript@5.5.2) - debug: 4.3.4 - eslint: 8.57.0 - ts-api-utils: 1.3.0(typescript@5.5.2) - optionalDependencies: - typescript: 5.5.2 - transitivePeerDependencies: - - supports-color - - '@typescript-eslint/types@7.13.1': {} - - '@typescript-eslint/typescript-estree@7.13.1(typescript@5.5.2)': - dependencies: - '@typescript-eslint/types': 7.13.1 - '@typescript-eslint/visitor-keys': 7.13.1 - debug: 4.3.4 - globby: 11.1.0 - is-glob: 4.0.3 - minimatch: 9.0.4 - semver: 7.6.2 - ts-api-utils: 1.3.0(typescript@5.5.2) - optionalDependencies: - typescript: 5.5.2 - transitivePeerDependencies: - - supports-color - - '@typescript-eslint/utils@7.13.1(eslint@8.57.0)(typescript@5.5.2)': - dependencies: - '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0) - '@typescript-eslint/scope-manager': 7.13.1 - '@typescript-eslint/types': 7.13.1 - '@typescript-eslint/typescript-estree': 7.13.1(typescript@5.5.2) - eslint: 8.57.0 - transitivePeerDependencies: - - supports-color - - typescript - - '@typescript-eslint/visitor-keys@7.13.1': - dependencies: - '@typescript-eslint/types': 7.13.1 - eslint-visitor-keys: 3.4.3 - - '@ungap/structured-clone@1.2.0': {} - abbrev@1.1.1: optional: true - acorn-jsx@5.3.2(acorn@8.10.0): - dependencies: - acorn: 8.10.0 - acorn-walk@8.2.0: {} acorn@8.10.0: {} @@ -3198,13 +2482,6 @@ snapshots: indent-string: 4.0.0 optional: true - ajv@6.12.6: - dependencies: - fast-deep-equal: 3.1.3 - fast-json-stable-stringify: 2.1.0 - json-schema-traverse: 0.4.1 - uri-js: 4.4.1 - ansi-escapes@4.3.2: dependencies: type-fest: 0.21.3 @@ -3249,56 +2526,6 @@ snapshots: dependencies: sprintf-js: 1.0.3 - argparse@2.0.1: {} - - array-buffer-byte-length@1.0.0: - dependencies: - call-bind: 1.0.2 - is-array-buffer: 3.0.2 - - array-includes@3.1.7: - dependencies: - call-bind: 1.0.2 - define-properties: 1.2.0 - es-abstract: 1.22.1 - get-intrinsic: 1.2.1 - is-string: 1.0.7 - - array-union@2.1.0: {} - - array.prototype.findlastindex@1.2.3: - dependencies: - call-bind: 1.0.2 - define-properties: 1.2.0 - es-abstract: 1.22.1 - es-shim-unscopables: 1.0.0 - get-intrinsic: 1.2.1 - - array.prototype.flat@1.3.2: - dependencies: - call-bind: 1.0.2 - define-properties: 1.2.0 - es-abstract: 1.22.1 - es-shim-unscopables: 1.0.0 - - array.prototype.flatmap@1.3.2: - dependencies: - call-bind: 1.0.2 - define-properties: 1.2.0 - es-abstract: 1.22.1 - es-shim-unscopables: 1.0.0 - - arraybuffer.prototype.slice@1.0.1: - dependencies: - array-buffer-byte-length: 1.0.0 - call-bind: 1.0.2 - define-properties: 1.2.0 - get-intrinsic: 1.2.1 - is-array-buffer: 3.0.2 - is-shared-array-buffer: 1.0.2 - - available-typed-arrays@1.0.5: {} - babel-jest@29.7.0(@babel/core@7.18.9): dependencies: '@babel/core': 7.18.9 @@ -3429,11 +2656,6 @@ snapshots: - bluebird optional: true - call-bind@1.0.2: - dependencies: - function-bind: 1.1.2 - get-intrinsic: 1.2.1 - callsites@3.1.0: {} camelcase@5.3.1: {} @@ -3542,10 +2764,6 @@ snapshots: dayjs@1.11.10: {} - debug@3.2.7: - dependencies: - ms: 2.1.2 - debug@4.3.4: dependencies: ms: 2.1.2 @@ -3558,15 +2776,8 @@ snapshots: deep-extend@0.6.0: {} - deep-is@0.1.4: {} - deepmerge@4.2.2: {} - define-properties@1.2.0: - dependencies: - has-property-descriptors: 1.0.0 - object-keys: 1.1.1 - delegates@1.0.0: optional: true @@ -3581,18 +2792,6 @@ snapshots: diff@4.0.2: {} - dir-glob@3.0.1: - dependencies: - path-type: 4.0.0 - - doctrine@2.1.0: - dependencies: - esutils: 2.0.3 - - doctrine@3.0.0: - dependencies: - esutils: 2.0.3 - dotenv@16.0.3: {} eastasianwidth@0.2.0: {} @@ -3614,11 +2813,6 @@ snapshots: dependencies: once: 1.4.0 - enhanced-resolve@5.15.0: - dependencies: - graceful-fs: 4.2.10 - tapable: 2.2.1 - env-paths@2.2.1: optional: true @@ -3629,209 +2823,14 @@ snapshots: dependencies: is-arrayish: 0.2.1 - es-abstract@1.22.1: - dependencies: - array-buffer-byte-length: 1.0.0 - arraybuffer.prototype.slice: 1.0.1 - available-typed-arrays: 1.0.5 - call-bind: 1.0.2 - es-set-tostringtag: 2.0.1 - es-to-primitive: 1.2.1 - function.prototype.name: 1.1.5 - get-intrinsic: 1.2.1 - get-symbol-description: 1.0.0 - globalthis: 1.0.3 - gopd: 1.0.1 - has: 1.0.3 - has-property-descriptors: 1.0.0 - has-proto: 1.0.1 - has-symbols: 1.0.3 - internal-slot: 1.0.5 - is-array-buffer: 3.0.2 - is-callable: 1.2.7 - is-negative-zero: 2.0.2 - is-regex: 1.1.4 - is-shared-array-buffer: 1.0.2 - is-string: 1.0.7 - is-typed-array: 1.1.10 - is-weakref: 1.0.2 - object-inspect: 1.12.3 - object-keys: 1.1.1 - object.assign: 4.1.4 - regexp.prototype.flags: 1.5.0 - safe-array-concat: 1.0.0 - safe-regex-test: 1.0.0 - string.prototype.trim: 1.2.7 - string.prototype.trimend: 1.0.6 - string.prototype.trimstart: 1.0.6 - typed-array-buffer: 1.0.0 - typed-array-byte-length: 1.0.0 - typed-array-byte-offset: 1.0.0 - typed-array-length: 1.0.4 - unbox-primitive: 1.0.2 - which-typed-array: 1.1.11 - - es-set-tostringtag@2.0.1: - dependencies: - get-intrinsic: 1.2.1 - has: 1.0.3 - has-tostringtag: 1.0.0 - - es-shim-unscopables@1.0.0: - dependencies: - has: 1.0.3 - - es-to-primitive@1.2.1: - dependencies: - is-callable: 1.2.7 - is-date-object: 1.0.5 - is-symbol: 1.0.4 - escalade@3.1.1: {} escape-string-regexp@1.0.5: {} escape-string-regexp@2.0.0: {} - escape-string-regexp@4.0.0: {} - - eslint-config-prettier@9.1.0(eslint@8.57.0): - dependencies: - eslint: 8.57.0 - - eslint-import-resolver-node@0.3.9: - dependencies: - debug: 3.2.7 - is-core-module: 2.13.1 - resolve: 1.22.8 - transitivePeerDependencies: - - supports-color - - eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@7.13.1(eslint@8.57.0)(typescript@5.5.2))(eslint-plugin-import@2.29.1)(eslint@8.57.0): - dependencies: - debug: 4.3.4 - enhanced-resolve: 5.15.0 - eslint: 8.57.0 - eslint-module-utils: 2.8.0(@typescript-eslint/parser@7.13.1(eslint@8.57.0)(typescript@5.5.2))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@7.13.1(eslint@8.57.0)(typescript@5.5.2))(eslint-plugin-import@2.29.1)(eslint@8.57.0))(eslint@8.57.0) - eslint-plugin-import: 2.29.1(@typescript-eslint/parser@7.13.1(eslint@8.57.0)(typescript@5.5.2))(eslint-import-resolver-typescript@3.6.1)(eslint@8.57.0) - fast-glob: 3.3.1 - get-tsconfig: 4.7.2 - is-core-module: 2.13.1 - is-glob: 4.0.3 - transitivePeerDependencies: - - '@typescript-eslint/parser' - - eslint-import-resolver-node - - eslint-import-resolver-webpack - - supports-color - - eslint-module-utils@2.8.0(@typescript-eslint/parser@7.13.1(eslint@8.57.0)(typescript@5.5.2))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@7.13.1(eslint@8.57.0)(typescript@5.5.2))(eslint-plugin-import@2.29.1)(eslint@8.57.0))(eslint@8.57.0): - dependencies: - debug: 3.2.7 - optionalDependencies: - '@typescript-eslint/parser': 7.13.1(eslint@8.57.0)(typescript@5.5.2) - eslint: 8.57.0 - eslint-import-resolver-node: 0.3.9 - eslint-import-resolver-typescript: 3.6.1(@typescript-eslint/parser@7.13.1(eslint@8.57.0)(typescript@5.5.2))(eslint-plugin-import@2.29.1)(eslint@8.57.0) - transitivePeerDependencies: - - supports-color - - eslint-plugin-import@2.29.1(@typescript-eslint/parser@7.13.1(eslint@8.57.0)(typescript@5.5.2))(eslint-import-resolver-typescript@3.6.1)(eslint@8.57.0): - dependencies: - array-includes: 3.1.7 - array.prototype.findlastindex: 1.2.3 - array.prototype.flat: 1.3.2 - array.prototype.flatmap: 1.3.2 - debug: 3.2.7 - doctrine: 2.1.0 - eslint: 8.57.0 - eslint-import-resolver-node: 0.3.9 - eslint-module-utils: 2.8.0(@typescript-eslint/parser@7.13.1(eslint@8.57.0)(typescript@5.5.2))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@7.13.1(eslint@8.57.0)(typescript@5.5.2))(eslint-plugin-import@2.29.1)(eslint@8.57.0))(eslint@8.57.0) - hasown: 2.0.0 - is-core-module: 2.13.1 - is-glob: 4.0.3 - minimatch: 3.1.2 - object.fromentries: 2.0.7 - object.groupby: 1.0.1 - object.values: 1.1.7 - semver: 6.3.1 - tsconfig-paths: 3.15.0 - optionalDependencies: - '@typescript-eslint/parser': 7.13.1(eslint@8.57.0)(typescript@5.5.2) - transitivePeerDependencies: - - eslint-import-resolver-typescript - - eslint-import-resolver-webpack - - supports-color - - eslint-scope@7.2.2: - dependencies: - esrecurse: 4.3.0 - estraverse: 5.3.0 - - eslint-visitor-keys@3.4.3: {} - - eslint@8.57.0: - dependencies: - '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0) - '@eslint-community/regexpp': 4.6.2 - '@eslint/eslintrc': 2.1.4 - '@eslint/js': 8.57.0 - '@humanwhocodes/config-array': 0.11.14 - '@humanwhocodes/module-importer': 1.0.1 - '@nodelib/fs.walk': 1.2.8 - '@ungap/structured-clone': 1.2.0 - ajv: 6.12.6 - chalk: 4.1.2 - cross-spawn: 7.0.3 - debug: 4.3.4 - doctrine: 3.0.0 - escape-string-regexp: 4.0.0 - eslint-scope: 7.2.2 - eslint-visitor-keys: 3.4.3 - espree: 9.6.1 - esquery: 1.5.0 - esutils: 2.0.3 - fast-deep-equal: 3.1.3 - file-entry-cache: 6.0.1 - find-up: 5.0.0 - glob-parent: 6.0.2 - globals: 13.19.0 - graphemer: 1.4.0 - ignore: 5.2.4 - imurmurhash: 0.1.4 - is-glob: 4.0.3 - is-path-inside: 3.0.3 - js-yaml: 4.1.0 - json-stable-stringify-without-jsonify: 1.0.1 - levn: 0.4.1 - lodash.merge: 4.6.2 - minimatch: 3.1.2 - natural-compare: 1.4.0 - optionator: 0.9.3 - strip-ansi: 6.0.1 - text-table: 0.2.0 - transitivePeerDependencies: - - supports-color - - espree@9.6.1: - dependencies: - acorn: 8.10.0 - acorn-jsx: 5.3.2(acorn@8.10.0) - eslint-visitor-keys: 3.4.3 - esprima@4.0.1: {} - esquery@1.5.0: - dependencies: - estraverse: 5.3.0 - - esrecurse@4.3.0: - dependencies: - estraverse: 5.3.0 - - estraverse@5.3.0: {} - - esutils@2.0.3: {} - execa@5.1.1: dependencies: cross-spawn: 7.0.3 @@ -3856,32 +2855,12 @@ snapshots: jest-message-util: 29.7.0 jest-util: 29.7.0 - fast-deep-equal@3.1.3: {} - - fast-glob@3.3.1: - dependencies: - '@nodelib/fs.stat': 2.0.5 - '@nodelib/fs.walk': 1.2.8 - glob-parent: 5.1.2 - merge2: 1.4.1 - micromatch: 4.0.5 - fast-json-stable-stringify@2.1.0: {} - fast-levenshtein@2.0.6: {} - - fastq@1.13.0: - dependencies: - reusify: 1.0.4 - fb-watchman@2.0.1: dependencies: bser: 2.1.1 - file-entry-cache@6.0.1: - dependencies: - flat-cache: 3.0.4 - file-uri-to-path@1.0.0: {} fill-range@7.0.1: @@ -3893,22 +2872,6 @@ snapshots: locate-path: 5.0.0 path-exists: 4.0.0 - find-up@5.0.0: - dependencies: - locate-path: 6.0.0 - path-exists: 4.0.0 - - flat-cache@3.0.4: - dependencies: - flatted: 3.2.6 - rimraf: 3.0.2 - - flatted@3.2.6: {} - - for-each@0.3.3: - dependencies: - is-callable: 1.2.7 - foreground-child@3.1.1: dependencies: cross-spawn: 7.0.3 @@ -3927,15 +2890,6 @@ snapshots: function-bind@1.1.2: {} - function.prototype.name@1.1.5: - dependencies: - call-bind: 1.0.2 - define-properties: 1.2.0 - es-abstract: 1.22.1 - functions-have-names: 1.2.3 - - functions-have-names@1.2.3: {} - gauge@4.0.4: dependencies: aproba: 2.0.0 @@ -3952,36 +2906,12 @@ snapshots: get-caller-file@2.0.5: {} - get-intrinsic@1.2.1: - dependencies: - function-bind: 1.1.2 - has: 1.0.3 - has-proto: 1.0.1 - has-symbols: 1.0.3 - get-package-type@0.1.0: {} get-stream@6.0.1: {} - get-symbol-description@1.0.0: - dependencies: - call-bind: 1.0.2 - get-intrinsic: 1.2.1 - - get-tsconfig@4.7.2: - dependencies: - resolve-pkg-maps: 1.0.0 - github-from-package@0.0.0: {} - glob-parent@5.1.2: - dependencies: - is-glob: 4.0.3 - - glob-parent@6.0.2: - dependencies: - is-glob: 4.0.3 - glob@10.3.10: dependencies: foreground-child: 3.1.1 @@ -4001,56 +2931,15 @@ snapshots: globals@11.12.0: {} - globals@13.19.0: - dependencies: - type-fest: 0.20.2 - - globalthis@1.0.3: - dependencies: - define-properties: 1.2.0 - - globby@11.1.0: - dependencies: - array-union: 2.1.0 - dir-glob: 3.0.1 - fast-glob: 3.3.1 - ignore: 5.3.1 - merge2: 1.4.1 - slash: 3.0.0 - - gopd@1.0.1: - dependencies: - get-intrinsic: 1.2.1 - graceful-fs@4.2.10: {} - graphemer@1.4.0: {} - - has-bigints@1.0.2: {} - has-flag@3.0.0: {} has-flag@4.0.0: {} - has-property-descriptors@1.0.0: - dependencies: - get-intrinsic: 1.2.1 - - has-proto@1.0.1: {} - - has-symbols@1.0.3: {} - - has-tostringtag@1.0.0: - dependencies: - has-symbols: 1.0.3 - has-unicode@2.0.1: optional: true - has@1.0.3: - dependencies: - function-bind: 1.1.2 - hasown@2.0.0: dependencies: function-bind: 1.1.2 @@ -4093,15 +2982,6 @@ snapshots: ieee754@1.2.1: {} - ignore@5.2.4: {} - - ignore@5.3.1: {} - - import-fresh@3.3.0: - dependencies: - parent-module: 1.0.1 - resolve-from: 4.0.0 - import-local@3.1.0: dependencies: pkg-dir: 4.2.0 @@ -4124,98 +3004,26 @@ snapshots: ini@1.3.8: {} - internal-slot@1.0.5: - dependencies: - get-intrinsic: 1.2.1 - has: 1.0.3 - side-channel: 1.0.4 - ip@2.0.0: optional: true - is-array-buffer@3.0.2: - dependencies: - call-bind: 1.0.2 - get-intrinsic: 1.2.1 - is-typed-array: 1.1.10 - is-arrayish@0.2.1: {} - is-bigint@1.0.4: - dependencies: - has-bigints: 1.0.2 - - is-boolean-object@1.1.2: - dependencies: - call-bind: 1.0.2 - has-tostringtag: 1.0.0 - - is-callable@1.2.7: {} - is-core-module@2.13.1: dependencies: hasown: 2.0.0 - is-date-object@1.0.5: - dependencies: - has-tostringtag: 1.0.0 - - is-extglob@2.1.1: {} - is-fullwidth-code-point@3.0.0: {} is-generator-fn@2.1.0: {} - is-glob@4.0.3: - dependencies: - is-extglob: 2.1.1 - is-lambda@1.0.1: optional: true - is-negative-zero@2.0.2: {} - - is-number-object@1.0.7: - dependencies: - has-tostringtag: 1.0.0 - is-number@7.0.0: {} - is-path-inside@3.0.3: {} - - is-regex@1.1.4: - dependencies: - call-bind: 1.0.2 - has-tostringtag: 1.0.0 - - is-shared-array-buffer@1.0.2: - dependencies: - call-bind: 1.0.2 - is-stream@2.0.1: {} - is-string@1.0.7: - dependencies: - has-tostringtag: 1.0.0 - - is-symbol@1.0.4: - dependencies: - has-symbols: 1.0.3 - - is-typed-array@1.1.10: - dependencies: - available-typed-arrays: 1.0.5 - call-bind: 1.0.2 - for-each: 0.3.3 - gopd: 1.0.1 - has-tostringtag: 1.0.0 - - is-weakref@1.0.2: - dependencies: - call-bind: 1.0.2 - - isarray@2.0.5: {} - isexe@2.0.0: {} istanbul-lib-coverage@3.2.0: {} @@ -4581,47 +3389,24 @@ snapshots: argparse: 1.0.10 esprima: 4.0.1 - js-yaml@4.1.0: - dependencies: - argparse: 2.0.1 - jsesc@2.5.2: {} json-parse-even-better-errors@2.3.1: {} - json-schema-traverse@0.4.1: {} - - json-stable-stringify-without-jsonify@1.0.1: {} - - json5@1.0.2: - dependencies: - minimist: 1.2.6 - json5@2.2.3: {} kleur@3.0.3: {} leven@3.1.0: {} - levn@0.4.1: - dependencies: - prelude-ls: 1.2.1 - type-check: 0.4.0 - lines-and-columns@1.2.4: {} locate-path@5.0.0: dependencies: p-locate: 4.1.0 - locate-path@6.0.0: - dependencies: - p-locate: 5.0.0 - lodash.memoize@4.1.2: {} - lodash.merge@4.6.2: {} - lru-cache@6.0.0: dependencies: yallist: 4.0.0 @@ -4664,8 +3449,6 @@ snapshots: merge-stream@2.0.0: {} - merge2@1.4.1: {} - micromatch@4.0.5: dependencies: braces: 3.0.2 @@ -4683,10 +3466,6 @@ snapshots: dependencies: brace-expansion: 2.0.1 - minimatch@9.0.4: - dependencies: - brace-expansion: 2.0.1 - minimist@1.2.6: {} minipass-collect@1.0.2: @@ -4798,36 +3577,6 @@ snapshots: object-assign@4.1.1: {} - object-inspect@1.12.3: {} - - object-keys@1.1.1: {} - - object.assign@4.1.4: - dependencies: - call-bind: 1.0.2 - define-properties: 1.2.0 - has-symbols: 1.0.3 - object-keys: 1.1.1 - - object.fromentries@2.0.7: - dependencies: - call-bind: 1.0.2 - define-properties: 1.2.0 - es-abstract: 1.22.1 - - object.groupby@1.0.1: - dependencies: - call-bind: 1.0.2 - define-properties: 1.2.0 - es-abstract: 1.22.1 - get-intrinsic: 1.2.1 - - object.values@1.1.7: - dependencies: - call-bind: 1.0.2 - define-properties: 1.2.0 - es-abstract: 1.22.1 - once@1.4.0: dependencies: wrappy: 1.0.2 @@ -4836,15 +3585,6 @@ snapshots: dependencies: mimic-fn: 2.1.0 - optionator@0.9.3: - dependencies: - '@aashutoshrathi/word-wrap': 1.2.6 - deep-is: 0.1.4 - fast-levenshtein: 2.0.6 - levn: 0.4.1 - prelude-ls: 1.2.1 - type-check: 0.4.0 - p-limit@2.3.0: dependencies: p-try: 2.2.0 @@ -4857,10 +3597,6 @@ snapshots: dependencies: p-limit: 2.3.0 - p-locate@5.0.0: - dependencies: - p-limit: 3.1.0 - p-map@4.0.0: dependencies: aggregate-error: 3.1.0 @@ -4868,10 +3604,6 @@ snapshots: p-try@2.2.0: {} - parent-module@1.0.1: - dependencies: - callsites: 3.1.0 - parse-json@5.2.0: dependencies: '@babel/code-frame': 7.18.6 @@ -4900,8 +3632,6 @@ snapshots: lru-cache: 9.1.1 minipass: 5.0.0 - path-type@4.0.0: {} - picocolors@1.0.0: {} picomatch@2.3.1: {} @@ -4927,10 +3657,6 @@ snapshots: tar-fs: 2.1.1 tunnel-agent: 0.6.0 - prelude-ls@1.2.1: {} - - prettier@3.3.2: {} - pretty-format@29.7.0: dependencies: '@jest/schemas': 29.6.3 @@ -4956,12 +3682,8 @@ snapshots: end-of-stream: 1.4.4 once: 1.4.0 - punycode@2.1.1: {} - pure-rand@6.0.1: {} - queue-microtask@1.2.3: {} - rc@1.2.8: dependencies: deep-extend: 0.6.0 @@ -4979,24 +3701,14 @@ snapshots: reflect-metadata@0.2.1: {} - regexp.prototype.flags@1.5.0: - dependencies: - call-bind: 1.0.2 - define-properties: 1.2.0 - functions-have-names: 1.2.3 - require-directory@2.1.1: {} resolve-cwd@3.0.0: dependencies: resolve-from: 5.0.0 - resolve-from@4.0.0: {} - resolve-from@5.0.0: {} - resolve-pkg-maps@1.0.0: {} - resolve.exports@2.0.0: {} resolve@1.22.8: @@ -5008,37 +3720,19 @@ snapshots: retry@0.12.0: optional: true - reusify@1.0.4: {} - rimraf@3.0.2: dependencies: glob: 7.2.3 + optional: true rimraf@5.0.7: dependencies: glob: 10.3.10 - run-parallel@1.2.0: - dependencies: - queue-microtask: 1.2.3 - - safe-array-concat@1.0.0: - dependencies: - call-bind: 1.0.2 - get-intrinsic: 1.2.1 - has-symbols: 1.0.3 - isarray: 2.0.5 - safe-buffer@5.1.2: {} safe-buffer@5.2.1: {} - safe-regex-test@1.0.0: - dependencies: - call-bind: 1.0.2 - get-intrinsic: 1.2.1 - is-regex: 1.1.4 - safer-buffer@2.1.2: optional: true @@ -5065,12 +3759,6 @@ snapshots: shebang-regex@3.0.0: {} - side-channel@1.0.4: - dependencies: - call-bind: 1.0.2 - get-intrinsic: 1.2.1 - object-inspect: 1.12.3 - signal-exit@3.0.7: {} signal-exit@4.0.1: {} @@ -5152,24 +3840,6 @@ snapshots: emoji-regex: 9.2.2 strip-ansi: 7.1.0 - string.prototype.trim@1.2.7: - dependencies: - call-bind: 1.0.2 - define-properties: 1.2.0 - es-abstract: 1.22.1 - - string.prototype.trimend@1.0.6: - dependencies: - call-bind: 1.0.2 - define-properties: 1.2.0 - es-abstract: 1.22.1 - - string.prototype.trimstart@1.0.6: - dependencies: - call-bind: 1.0.2 - define-properties: 1.2.0 - es-abstract: 1.22.1 - string_decoder@1.3.0: dependencies: safe-buffer: 5.2.1 @@ -5182,8 +3852,6 @@ snapshots: dependencies: ansi-regex: 6.0.1 - strip-bom@3.0.0: {} - strip-bom@4.0.0: {} strip-final-newline@2.0.0: {} @@ -5206,8 +3874,6 @@ snapshots: supports-preserve-symlinks-flag@1.0.0: {} - tapable@2.2.1: {} - tar-fs@2.1.1: dependencies: chownr: 1.1.4 @@ -5238,8 +3904,6 @@ snapshots: glob: 7.2.3 minimatch: 3.1.2 - text-table@0.2.0: {} - thenify-all@1.6.0: dependencies: thenify: 3.3.1 @@ -5256,10 +3920,6 @@ snapshots: dependencies: is-number: 7.0.0 - ts-api-utils@1.3.0(typescript@5.5.2): - dependencies: - typescript: 5.5.2 - ts-jest@29.1.5(@babel/core@7.18.9)(@jest/transform@29.7.0)(@jest/types@29.6.3)(babel-jest@29.7.0(@babel/core@7.18.9))(jest@29.7.0(@types/node@20.14.7)(ts-node@10.9.2(@types/node@20.14.7)(typescript@5.5.2)))(typescript@5.5.2): dependencies: bs-logger: 0.2.6 @@ -5296,56 +3956,16 @@ snapshots: v8-compile-cache-lib: 3.0.1 yn: 3.1.1 - tsconfig-paths@3.15.0: - dependencies: - '@types/json5': 0.0.29 - json5: 1.0.2 - minimist: 1.2.6 - strip-bom: 3.0.0 - tslib@2.6.3: {} tunnel-agent@0.6.0: dependencies: safe-buffer: 5.2.1 - type-check@0.4.0: - dependencies: - prelude-ls: 1.2.1 - type-detect@4.0.8: {} - type-fest@0.20.2: {} - type-fest@0.21.3: {} - typed-array-buffer@1.0.0: - dependencies: - call-bind: 1.0.2 - get-intrinsic: 1.2.1 - is-typed-array: 1.1.10 - - typed-array-byte-length@1.0.0: - dependencies: - call-bind: 1.0.2 - for-each: 0.3.3 - has-proto: 1.0.1 - is-typed-array: 1.1.10 - - typed-array-byte-offset@1.0.0: - dependencies: - available-typed-arrays: 1.0.5 - call-bind: 1.0.2 - for-each: 0.3.3 - has-proto: 1.0.1 - is-typed-array: 1.1.10 - - typed-array-length@1.0.4: - dependencies: - call-bind: 1.0.2 - for-each: 0.3.3 - is-typed-array: 1.1.10 - typeorm@0.3.20(sqlite3@5.1.7)(ts-node@10.9.2(@types/node@20.14.7)(typescript@5.5.2)): dependencies: '@sqltools/formatter': 1.2.5 @@ -5371,13 +3991,6 @@ snapshots: typescript@5.5.2: {} - unbox-primitive@1.0.2: - dependencies: - call-bind: 1.0.2 - has-bigints: 1.0.2 - has-symbols: 1.0.3 - which-boxed-primitive: 1.0.2 - undici-types@5.26.5: {} unique-filename@1.1.1: @@ -5396,10 +4009,6 @@ snapshots: escalade: 3.1.1 picocolors: 1.0.0 - uri-js@4.4.1: - dependencies: - punycode: 2.1.1 - util-deprecate@1.0.2: {} uuid@9.0.0: {} @@ -5416,22 +4025,6 @@ snapshots: dependencies: makeerror: 1.0.12 - which-boxed-primitive@1.0.2: - dependencies: - is-bigint: 1.0.4 - is-boolean-object: 1.1.2 - is-number-object: 1.0.7 - is-string: 1.0.7 - is-symbol: 1.0.4 - - which-typed-array@1.1.11: - dependencies: - available-typed-arrays: 1.0.5 - call-bind: 1.0.2 - for-each: 0.3.3 - gopd: 1.0.1 - has-tostringtag: 1.0.0 - which@2.0.2: dependencies: isexe: 2.0.0 diff --git a/src/factory.ts b/src/factory.ts index f061a72..b0af41b 100644 --- a/src/factory.ts +++ b/src/factory.ts @@ -1,117 +1,118 @@ -import type { DataSource, SaveOptions } from 'typeorm' -import { EagerInstanceAttribute, LazyInstanceAttribute } from './instanceAttributes' -import { BaseSubfactory } from './subfactories' -import type { Constructable, FactorizedAttrs } from './types' +import type { DataSource, SaveOptions } from "typeorm"; +import { EagerInstanceAttribute, LazyInstanceAttribute } from "./instanceAttributes"; +import { BaseSubfactory } from "./subfactories"; +import type { Constructable, FactorizedAttrs } from "./types"; export abstract class Factory { - protected abstract entity: Constructable - protected abstract dataSource: DataSource - protected abstract attrs(): FactorizedAttrs - - /** - * Make a new entity without persisting it - */ - async make(overrideParams: Partial> = {}): Promise { - const attrs: FactorizedAttrs = { ...this.attrs(), ...overrideParams } - - const entity = await this.makeEntity(attrs, false) - - await this.applyEagerInstanceAttributes(entity, attrs, false) - await this.applyLazyInstanceAttributes(entity, attrs, false) - - return entity - } - - /** - * Make many new entities without persisting it - */ - async makeMany(amount: number, overrideParams: Partial> = {}): Promise { - const list = [] - for (let index = 0; index < amount; index++) { - list[index] = await this.make(overrideParams) - } - return list - } - - /** - * Create a new entity and persist it - */ - async create(overrideParams: Partial> = {}, saveOptions?: SaveOptions): Promise { - const attrs: FactorizedAttrs = { ...this.attrs(), ...overrideParams } - const preloadedAttrs = Object.entries(attrs).filter(([, value]) => !(value instanceof LazyInstanceAttribute)) - - const entity = await this.makeEntity(Object.fromEntries(preloadedAttrs) as FactorizedAttrs, true) - await this.applyEagerInstanceAttributes(entity, attrs, true) - - const em = this.getEntityManager() - const savedEntity = await em.save(entity, saveOptions) - - await this.applyLazyInstanceAttributes(savedEntity, attrs, true) - return em.save(savedEntity, saveOptions) - } - - /** - * Create many new entities and persist them - */ - async createMany( - amount: number, - overrideParams: Partial> = {}, - saveOptions?: SaveOptions, - ): Promise { - const list = [] - for (let index = 0; index < amount; index++) { - list[index] = await this.create(overrideParams, saveOptions) - } - return list - } - - protected getEntityManager() { - return this.dataSource.createEntityManager() - } - - private async makeEntity(attrs: FactorizedAttrs, shouldPersist: boolean) { - const entity = new this.entity() - - await Promise.all( - Object.entries(attrs).map(async ([key, value]) => { - Object.assign(entity, { [key]: await Factory.resolveValue(value, shouldPersist) }) - }), - ) - - return entity - } - - private async applyEagerInstanceAttributes(entity: T, attrs: FactorizedAttrs, shouldPersist: boolean) { - await Promise.all( - Object.entries(attrs).map(async ([key, value]) => { - if (value instanceof EagerInstanceAttribute) { - const newAttrib = value.resolve(entity) - Object.assign(entity, { [key]: await Factory.resolveValue(newAttrib, shouldPersist) }) - } - }), - ) - } - - private async applyLazyInstanceAttributes(entity: T, attrs: FactorizedAttrs, shouldPersist: boolean) { - await Promise.all( - Object.entries(attrs).map(async ([key, value]) => { - if (value instanceof LazyInstanceAttribute) { - const newAttrib = value.resolve(entity) - Object.assign(entity, { [key]: await Factory.resolveValue(newAttrib, shouldPersist) }) - } - }), - ) - } - - private static async resolveValue(value: unknown, shouldPersist: boolean): Promise { - if (value instanceof BaseSubfactory) { - return shouldPersist ? value.create() : value.make() - } else if (value instanceof Array) { - return await Promise.all(value.map((val: unknown) => Factory.resolveValue(val, shouldPersist))) - } else if (value instanceof Function) { - return value() - } else { - return value - } - } + protected abstract entity: Constructable; + protected abstract dataSource: DataSource; + protected abstract attrs(): FactorizedAttrs; + + /** + * Make a new entity without persisting it + */ + async make(overrideParams: Partial> = {}): Promise { + const attrs: FactorizedAttrs = { ...this.attrs(), ...overrideParams }; + + const entity = await this.makeEntity(attrs, false); + + await this.applyEagerInstanceAttributes(entity, attrs, false); + await this.applyLazyInstanceAttributes(entity, attrs, false); + + return entity; + } + + /** + * Make many new entities without persisting it + */ + async makeMany(amount: number, overrideParams: Partial> = {}): Promise { + const list = []; + for (let index = 0; index < amount; index++) { + list[index] = await this.make(overrideParams); + } + return list; + } + + /** + * Create a new entity and persist it + */ + async create(overrideParams: Partial> = {}, saveOptions?: SaveOptions): Promise { + const attrs: FactorizedAttrs = { ...this.attrs(), ...overrideParams }; + const preloadedAttrs = Object.entries(attrs).filter(([, value]) => !(value instanceof LazyInstanceAttribute)); + + const entity = await this.makeEntity(Object.fromEntries(preloadedAttrs) as FactorizedAttrs, true); + await this.applyEagerInstanceAttributes(entity, attrs, true); + + const em = this.getEntityManager(); + const savedEntity = await em.save(entity, saveOptions); + + await this.applyLazyInstanceAttributes(savedEntity, attrs, true); + return em.save(savedEntity, saveOptions); + } + + /** + * Create many new entities and persist them + */ + async createMany( + amount: number, + overrideParams: Partial> = {}, + saveOptions?: SaveOptions, + ): Promise { + const list = []; + for (let index = 0; index < amount; index++) { + list[index] = await this.create(overrideParams, saveOptions); + } + return list; + } + + protected getEntityManager() { + return this.dataSource.createEntityManager(); + } + + private async makeEntity(attrs: FactorizedAttrs, shouldPersist: boolean) { + const entity = new this.entity(); + + await Promise.all( + Object.entries(attrs).map(async ([key, value]) => { + Object.assign(entity, { [key]: await Factory.resolveValue(value, shouldPersist) }); + }), + ); + + return entity; + } + + private async applyEagerInstanceAttributes(entity: T, attrs: FactorizedAttrs, shouldPersist: boolean) { + await Promise.all( + Object.entries(attrs).map(async ([key, value]) => { + if (value instanceof EagerInstanceAttribute) { + const newAttrib = value.resolve(entity); + Object.assign(entity, { [key]: await Factory.resolveValue(newAttrib, shouldPersist) }); + } + }), + ); + } + + private async applyLazyInstanceAttributes(entity: T, attrs: FactorizedAttrs, shouldPersist: boolean) { + await Promise.all( + Object.entries(attrs).map(async ([key, value]) => { + if (value instanceof LazyInstanceAttribute) { + const newAttrib = value.resolve(entity); + Object.assign(entity, { [key]: await Factory.resolveValue(newAttrib, shouldPersist) }); + } + }), + ); + } + + private static async resolveValue(value: unknown, shouldPersist: boolean): Promise { + if (value instanceof BaseSubfactory) { + return shouldPersist ? value.create() : value.make(); + } + if (Array.isArray(value)) { + return await Promise.all(value.map((val: unknown) => Factory.resolveValue(val, shouldPersist))); + } + if (value instanceof Function) { + return value(); + } + return value; + } } diff --git a/src/index.ts b/src/index.ts index 9bef88d..0cf6344 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,4 +1,4 @@ -export * from './factory' -export * from './instanceAttributes' -export * from './subfactories' -export * from './types' +export * from "./factory"; +export * from "./instanceAttributes"; +export * from "./subfactories"; +export * from "./types"; diff --git a/src/instanceAttributes/eagerInstanceAttribute.ts b/src/instanceAttributes/eagerInstanceAttribute.ts index 459c933..5ed9ee8 100644 --- a/src/instanceAttributes/eagerInstanceAttribute.ts +++ b/src/instanceAttributes/eagerInstanceAttribute.ts @@ -1,3 +1,3 @@ -import { InstanceAttribute } from './instanceAttribute' +import { InstanceAttribute } from "./instanceAttribute"; export class EagerInstanceAttribute extends InstanceAttribute {} diff --git a/src/instanceAttributes/index.ts b/src/instanceAttributes/index.ts index 36b9af6..02e178f 100644 --- a/src/instanceAttributes/index.ts +++ b/src/instanceAttributes/index.ts @@ -1,3 +1,3 @@ -export * from './eagerInstanceAttribute' -export * from './instanceAttribute' -export * from './lazyInstanceAttribute' +export * from "./eagerInstanceAttribute"; +export * from "./instanceAttribute"; +export * from "./lazyInstanceAttribute"; diff --git a/src/instanceAttributes/instanceAttribute.ts b/src/instanceAttributes/instanceAttribute.ts index 92c22a1..028d449 100644 --- a/src/instanceAttributes/instanceAttribute.ts +++ b/src/instanceAttributes/instanceAttribute.ts @@ -1,9 +1,9 @@ -import type { InstanceAttributeCallback } from '../types' +import type { InstanceAttributeCallback } from "../types"; export abstract class InstanceAttribute { - constructor(private callback: InstanceAttributeCallback) {} + constructor(private callback: InstanceAttributeCallback) {} - resolve(entity: T) { - return this.callback(entity) - } + resolve(entity: T) { + return this.callback(entity); + } } diff --git a/src/instanceAttributes/lazyInstanceAttribute.ts b/src/instanceAttributes/lazyInstanceAttribute.ts index f70c3f5..b265905 100644 --- a/src/instanceAttributes/lazyInstanceAttribute.ts +++ b/src/instanceAttributes/lazyInstanceAttribute.ts @@ -1,3 +1,3 @@ -import { InstanceAttribute } from './instanceAttribute' +import { InstanceAttribute } from "./instanceAttribute"; export class LazyInstanceAttribute extends InstanceAttribute {} diff --git a/src/subfactories/baseSubfactory.ts b/src/subfactories/baseSubfactory.ts index 9be56ed..e7afd1e 100644 --- a/src/subfactories/baseSubfactory.ts +++ b/src/subfactories/baseSubfactory.ts @@ -1,17 +1,17 @@ -import { Factory } from '../factory' -import type { Constructable, FactorizedAttrs } from '../types' +import { Factory } from "../factory"; +import type { Constructable, FactorizedAttrs } from "../types"; export abstract class BaseSubfactory { - protected factoryInstance: Factory + protected factoryInstance: Factory; - constructor( - factoryOrFactoryInstance: Constructable> | Factory, - protected values?: Partial>, - ) { - this.factoryInstance = - factoryOrFactoryInstance instanceof Factory ? factoryOrFactoryInstance : new factoryOrFactoryInstance() - } + constructor( + factoryOrFactoryInstance: Constructable> | Factory, + protected values?: Partial>, + ) { + this.factoryInstance = + factoryOrFactoryInstance instanceof Factory ? factoryOrFactoryInstance : new factoryOrFactoryInstance(); + } - abstract create(): Promise | Promise - abstract make(): Promise | Promise + abstract create(): Promise | Promise; + abstract make(): Promise | Promise; } diff --git a/src/subfactories/collectionSubfactory.ts b/src/subfactories/collectionSubfactory.ts index ee87ccd..5e432a3 100644 --- a/src/subfactories/collectionSubfactory.ts +++ b/src/subfactories/collectionSubfactory.ts @@ -1,21 +1,21 @@ -import type { Factory } from '../factory' -import type { Constructable, FactorizedAttrs } from '../types' -import { BaseSubfactory } from './baseSubfactory' +import type { Factory } from "../factory"; +import type { Constructable, FactorizedAttrs } from "../types"; +import { BaseSubfactory } from "./baseSubfactory"; export class CollectionSubfactory extends BaseSubfactory { - constructor( - factoryOrFactoryInstance: Constructable> | Factory, - private count: number, - values?: Partial>, - ) { - super(factoryOrFactoryInstance, values) - } + constructor( + factoryOrFactoryInstance: Constructable> | Factory, + private count: number, + values?: Partial>, + ) { + super(factoryOrFactoryInstance, values); + } - create() { - return this.factoryInstance.createMany(this.count, this.values) - } + create() { + return this.factoryInstance.createMany(this.count, this.values); + } - make() { - return this.factoryInstance.makeMany(this.count, this.values) - } + make() { + return this.factoryInstance.makeMany(this.count, this.values); + } } diff --git a/src/subfactories/index.ts b/src/subfactories/index.ts index 4bf928f..5a7c1c4 100644 --- a/src/subfactories/index.ts +++ b/src/subfactories/index.ts @@ -1,3 +1,3 @@ -export * from './baseSubfactory' -export * from './collectionSubfactory' -export * from './singleSubfactory' +export * from "./baseSubfactory"; +export * from "./collectionSubfactory"; +export * from "./singleSubfactory"; diff --git a/src/subfactories/singleSubfactory.ts b/src/subfactories/singleSubfactory.ts index 882ef94..2e3059c 100644 --- a/src/subfactories/singleSubfactory.ts +++ b/src/subfactories/singleSubfactory.ts @@ -1,17 +1,11 @@ -import type { Factory } from '../factory' -import type { Constructable, FactorizedAttrs } from '../types' -import { BaseSubfactory } from './baseSubfactory' +import { BaseSubfactory } from "./baseSubfactory"; export class SingleSubfactory extends BaseSubfactory { - constructor(factoryOrFactoryInstance: Constructable> | Factory, values?: Partial>) { - super(factoryOrFactoryInstance, values) - } + create() { + return this.factoryInstance.create(this.values); + } - create() { - return this.factoryInstance.create(this.values) - } - - make() { - return this.factoryInstance.make(this.values) - } + make() { + return this.factoryInstance.make(this.values); + } } diff --git a/src/types.ts b/src/types.ts index a0d2df3..4fe26ad 100644 --- a/src/types.ts +++ b/src/types.ts @@ -1,20 +1,20 @@ -import type { InstanceAttribute } from './instanceAttributes' -import type { CollectionSubfactory, SingleSubfactory } from './subfactories' +import type { InstanceAttribute } from "./instanceAttributes"; +import type { CollectionSubfactory, SingleSubfactory } from "./subfactories"; export type FactorizedAttrs = { - [K in keyof Partial]: FactorizedAttr | InstanceAttribute> -} + [K in keyof Partial]: FactorizedAttr | InstanceAttribute>; +}; -export type FactorizedAttr = V extends Array ? ArrayFactorizedAttr : SingleFactorizedAttr +export type FactorizedAttr = V extends Array ? ArrayFactorizedAttr : SingleFactorizedAttr; // If the factorized attr is a single value, then it should be the same type or resolve to that value -export type SingleFactorizedAttr = V | (() => V | Promise) | SingleSubfactory> +export type SingleFactorizedAttr = V | (() => V | Promise) | SingleSubfactory>; // If the factorized attr is a list, then it should be a list of SingleFactorizedAttr or a collection subfactory -export type ArrayFactorizedAttr = Array> | CollectionSubfactory> +export type ArrayFactorizedAttr = Array> | CollectionSubfactory>; // The function of an instance attribute must resolve always to a FactorizedAttr -export type InstanceAttributeCallback = (entity: T) => FactorizedAttr +export type InstanceAttributeCallback = (entity: T) => FactorizedAttr; // Helper types -export type Constructable = new () => T -export type IsObject = T extends object ? T : never +export type Constructable = new () => T; +export type IsObject = T extends object ? T : never; diff --git a/test/factory.test.ts b/test/factory.test.ts index a8b42ac..dd4193b 100644 --- a/test/factory.test.ts +++ b/test/factory.test.ts @@ -1,323 +1,328 @@ -import { CollectionSubfactory, EagerInstanceAttribute, Factory, LazyInstanceAttribute, SingleSubfactory } from '../src' -import { Pet } from './fixtures/Pet.entity' -import { PetFactory } from './fixtures/Pet.factory' -import { User } from './fixtures/User.entity' -import { UserFactory } from './fixtures/User.factory' -import { dataSource } from './fixtures/dataSource' +import { CollectionSubfactory, EagerInstanceAttribute, Factory, LazyInstanceAttribute, SingleSubfactory } from "../src"; +import { Pet } from "./fixtures/Pet.entity"; +import { PetFactory } from "./fixtures/Pet.factory"; +import { User } from "./fixtures/User.entity"; +import { UserFactory } from "./fixtures/User.factory"; +import { dataSource } from "./fixtures/dataSource"; describe(Factory, () => { - describe(Factory.prototype.make, () => { - describe(UserFactory, () => { - const factory = new UserFactory() - - test('Should make a new entity', async () => { - const userMaked = await factory.make() - - expect(userMaked).toBeInstanceOf(User) - expect(userMaked.id).toBeUndefined() - expect(userMaked.name).toBeDefined() - expect(userMaked.lastName).toBeDefined() - expect(userMaked.age).toBeDefined() - expect(userMaked.email).toBeDefined() - - expect(userMaked.pets).toBeInstanceOf(Array) - expect(userMaked.pets).toHaveLength(0) - }) - - test('Should make a new entity with attribute overrided', async () => { - const userMaked = await factory.make({ - name: 'john', - }) - - expect(userMaked.name).toBe('john') - }) - - test('Should make a new entity with function as attribute', async () => { - const userMaked = await factory.make({ - name: () => 'john', - }) - - expect(userMaked.name).toBe('john') - }) - - test('Should make a new entity with async function as attribute', async () => { - const userMaked = await factory.make({ - name: async () => 'john', - }) - - expect(userMaked.name).toBe('john') - }) - - test('Should make a new entity with instance attributes', async () => { - const userMaked = await factory.make({ - email: new EagerInstanceAttribute((instance) => - [instance.name.toLowerCase(), instance.lastName.toLowerCase(), '@email.com'].join(''), - ), - }) - - expect(userMaked.email).toMatch(userMaked.name.toLowerCase()) - expect(userMaked.email).toMatch(userMaked.lastName.toLowerCase()) - }) - - test('Should make a new entity with lazy instance attributes', async () => { - const userMaked = await factory.make({ - email: new EagerInstanceAttribute((instance) => - [instance.name.toLowerCase(), instance.lastName.toLowerCase(), '@email.com'].join(''), - ), - }) - - expect(userMaked.email).toMatch(userMaked.name.toLowerCase()) - expect(userMaked.email).toMatch(userMaked.lastName.toLowerCase()) - }) - - test('Should make a new entity with multiple subfactories', async () => { - const userMaked = await factory.make({ - pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owner: instance })), - }) - - expect(userMaked.pets).toBeInstanceOf(Array) - expect(userMaked.pets).toHaveLength(1) - userMaked.pets.forEach((pet) => { - expect(pet.id).toBeUndefined() - expect(pet.owner).toBeInstanceOf(User) - expect(pet.owner.id).toBeUndefined() - }) - }) - - test('Should make a new entity with multiple subfactories in an array', async () => { - const userMaked = await factory.make({ - pets: new LazyInstanceAttribute((instance) => [new SingleSubfactory(PetFactory, { owner: instance })]), - }) - - expect(userMaked.pets).toBeInstanceOf(Array) - expect(userMaked.pets).toHaveLength(1) - userMaked.pets.forEach((pet) => { - expect(pet.id).toBeUndefined() - expect(pet.owner).toBeInstanceOf(User) - expect(pet.owner.id).toBeUndefined() - }) - }) - - test('Should make a new entity with multiple existing subfactories', async () => { - const petFactory = new PetFactory() - - const userMaked = await factory.make({ - pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(petFactory, 1, { owner: instance })), - }) - - expect(userMaked.pets).toBeInstanceOf(Array) - expect(userMaked.pets).toHaveLength(1) - userMaked.pets.forEach((pet) => { - expect(pet.id).toBeUndefined() - expect(pet.owner).toBeInstanceOf(User) - expect(pet.owner.id).toBeUndefined() - }) - }) - - test('Should make two entities with different attributes', async () => { - const userMaked1 = await factory.make() - const userMaked2 = await factory.make() - - expect(userMaked1).not.toStrictEqual(userMaked2) - }) - }) - - describe(PetFactory, () => { - const factory = new PetFactory() - - test('Should make a new entity with single subfactory', async () => { - const petMaked = await factory.make() - - expect(petMaked).toBeInstanceOf(Pet) - expect(petMaked.id).toBeUndefined() - expect(petMaked.name).toBeDefined() - expect(petMaked.owner).toBeDefined() - expect(petMaked.owner).toBeInstanceOf(User) - expect(petMaked.owner.id).toBeUndefined() - }) - - test('Should make a new entity with single existing subfactory', async () => { - const userFactory = new UserFactory() - - const petMaked = await factory.make({ - owner: new LazyInstanceAttribute((instance) => new SingleSubfactory(userFactory, { pets: [instance] })), - }) - - expect(petMaked).toBeInstanceOf(Pet) - expect(petMaked.id).toBeUndefined() - expect(petMaked.name).toBeDefined() - expect(petMaked.owner).toBeDefined() - expect(petMaked.owner).toBeInstanceOf(User) - expect(petMaked.owner.id).toBeUndefined() - }) - }) - }) - - describe(Factory.prototype.makeMany, () => { - test('Should make many new entities', async () => { - const count = 2 - const factory = new UserFactory() - const entitiesMaked = await factory.makeMany(count) - - expect(entitiesMaked).toHaveLength(count) - entitiesMaked.forEach((entity) => { - expect(entity.id).toBeUndefined() - }) - }) - }) - - describe(Factory.prototype.create, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - describe(UserFactory, () => { - const factory = new UserFactory() - - test('Should create a new entity', async () => { - const userCreated = await factory.create() - - expect(userCreated).toBeInstanceOf(User) - expect(userCreated.id).toBeDefined() - expect(userCreated.name).toBeDefined() - expect(userCreated.lastName).toBeDefined() - expect(userCreated.age).toBeDefined() - expect(userCreated.email).toBeDefined() - - expect(userCreated.pets).toBeInstanceOf(Array) - expect(userCreated.pets).toHaveLength(0) - }) - - test('Should create a new entity with attribute overrided', async () => { - const userCreated = await factory.create({ - name: 'john', - }) - - expect(userCreated.name).toBe('john') - }) - - test('Should create a new entity with function as attribute', async () => { - const userCreated = await factory.create({ - name: () => 'john', - }) - - expect(userCreated.name).toBe('john') - }) - - test('Should create a new entity with async function as attribute', async () => { - const userCreated = await factory.create({ - name: async () => 'john', - }) - - expect(userCreated.name).toBe('john') - }) - - test('Should create a new entity with instance attributes', async () => { - const userCreated = await factory.create({ - email: new EagerInstanceAttribute((instance) => - [instance.name.toLowerCase(), instance.lastName.toLowerCase(), '@email.com'].join(''), - ), - }) - - expect(userCreated.email).toMatch(userCreated.name.toLowerCase()) - expect(userCreated.email).toMatch(userCreated.lastName.toLowerCase()) - }) - - test('Should create a new entity with lazy instance attributes', async () => { - const userCreated = await factory.create({ - email: new EagerInstanceAttribute((instance) => - [instance.name.toLowerCase(), instance.lastName.toLowerCase(), '@email.com'].join(''), - ), - }) - - expect(userCreated.email).toMatch(userCreated.name.toLowerCase()) - expect(userCreated.email).toMatch(userCreated.lastName.toLowerCase()) - }) - - test('Should create a new entity with multiple subfactories', async () => { - const userCreated = await factory.create({ - pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owner: instance })), - }) - - expect(userCreated.pets).toBeInstanceOf(Array) - expect(userCreated.pets).toHaveLength(1) - userCreated.pets.forEach((pet) => { - expect(pet.id).toBeDefined() - expect(pet.owner).toBeInstanceOf(User) - expect(pet.owner.id).toBeDefined() - expect(pet.owner.id).toBe(userCreated.id) - }) - }) - - test('Should make a new entity with multiple subfactories in an array', async () => { - const userCreated = await factory.create({ - pets: new LazyInstanceAttribute((instance) => [new SingleSubfactory(PetFactory, { owner: instance })]), - }) - - expect(userCreated.pets).toBeInstanceOf(Array) - expect(userCreated.pets).toHaveLength(1) - userCreated.pets.forEach((pet) => { - expect(pet.id).toBeDefined() - expect(pet.owner).toBeInstanceOf(User) - expect(pet.owner.id).toBeDefined() - expect(pet.owner.id).toBe(userCreated.id) - }) - }) - - test('Should create two entities with different attributes', async () => { - const userCreated1 = await factory.create() - const userCreated2 = await factory.create() - - expect(userCreated1).not.toStrictEqual(userCreated2) - }) - }) - - describe(PetFactory, () => { - const factory = new PetFactory() - - test('Should create a new entity with single subfactory', async () => { - const petCreated = await factory.create() - - expect(petCreated).toBeInstanceOf(Pet) - expect(petCreated.id).toBeDefined() - expect(petCreated.name).toBeDefined() - expect(petCreated.owner).toBeDefined() - expect(petCreated.owner).toBeInstanceOf(User) - expect(petCreated.owner.id).toBeDefined() - }) - }) - }) - - describe(Factory.prototype.createMany, () => { - beforeAll(async () => { - await dataSource.initialize() - }) - - beforeEach(async () => { - await dataSource.synchronize(true) - }) - - afterAll(async () => { - await dataSource.destroy() - }) - - test('Should create many new entities', async () => { - const count = 2 - const factory = new UserFactory() - const entitiesCreated = await factory.createMany(count) - - expect(entitiesCreated).toHaveLength(count) - entitiesCreated.forEach((entity) => { - expect(entity.id).toBeDefined() - }) - }) - }) -}) + describe(Factory.prototype.make, () => { + describe(UserFactory, () => { + const factory = new UserFactory(); + + test("Should make a new entity", async () => { + const userMaked = await factory.make(); + + expect(userMaked).toBeInstanceOf(User); + expect(userMaked.id).toBeUndefined(); + expect(userMaked.name).toBeDefined(); + expect(userMaked.lastName).toBeDefined(); + expect(userMaked.age).toBeDefined(); + expect(userMaked.email).toBeDefined(); + + expect(userMaked.pets).toBeInstanceOf(Array); + expect(userMaked.pets).toHaveLength(0); + }); + + test("Should make a new entity with attribute overrided", async () => { + const userMaked = await factory.make({ + name: "john", + }); + + expect(userMaked.name).toBe("john"); + }); + + test("Should make a new entity with function as attribute", async () => { + const userMaked = await factory.make({ + name: () => "john", + }); + + expect(userMaked.name).toBe("john"); + }); + + test("Should make a new entity with async function as attribute", async () => { + const userMaked = await factory.make({ + name: async () => "john", + }); + + expect(userMaked.name).toBe("john"); + }); + + test("Should make a new entity with instance attributes", async () => { + const userMaked = await factory.make({ + email: new EagerInstanceAttribute((instance) => + [instance.name.toLowerCase(), instance.lastName.toLowerCase(), "@email.com"].join(""), + ), + }); + + expect(userMaked.email).toMatch(userMaked.name.toLowerCase()); + expect(userMaked.email).toMatch(userMaked.lastName.toLowerCase()); + }); + + test("Should make a new entity with lazy instance attributes", async () => { + const userMaked = await factory.make({ + email: new EagerInstanceAttribute((instance) => + [instance.name.toLowerCase(), instance.lastName.toLowerCase(), "@email.com"].join(""), + ), + }); + + expect(userMaked.email).toMatch(userMaked.name.toLowerCase()); + expect(userMaked.email).toMatch(userMaked.lastName.toLowerCase()); + }); + + test("Should make a new entity with multiple subfactories", async () => { + const userMaked = await factory.make({ + pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owner: instance })), + }); + + expect(userMaked.pets).toBeInstanceOf(Array); + expect(userMaked.pets).toHaveLength(1); + + for (const pet of userMaked.pets) { + expect(pet.id).toBeUndefined(); + expect(pet.owner).toBeInstanceOf(User); + expect(pet.owner.id).toBeUndefined(); + } + }); + + test("Should make a new entity with multiple subfactories in an array", async () => { + const userMaked = await factory.make({ + pets: new LazyInstanceAttribute((instance) => [new SingleSubfactory(PetFactory, { owner: instance })]), + }); + + expect(userMaked.pets).toBeInstanceOf(Array); + expect(userMaked.pets).toHaveLength(1); + for (const user of userMaked.pets) { + expect(user.id).toBeUndefined(); + expect(user.owner).toBeInstanceOf(User); + expect(user.owner.id).toBeUndefined(); + } + }); + + test("Should make a new entity with multiple existing subfactories", async () => { + const petFactory = new PetFactory(); + + const userMaked = await factory.make({ + pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(petFactory, 1, { owner: instance })), + }); + + expect(userMaked.pets).toBeInstanceOf(Array); + expect(userMaked.pets).toHaveLength(1); + + for (const pet of userMaked.pets) { + expect(pet.id).toBeUndefined(); + expect(pet.owner).toBeInstanceOf(User); + expect(pet.owner.id).toBeUndefined(); + } + }); + + test("Should make two entities with different attributes", async () => { + const userMaked1 = await factory.make(); + const userMaked2 = await factory.make(); + + expect(userMaked1).not.toStrictEqual(userMaked2); + }); + }); + + describe(PetFactory, () => { + const factory = new PetFactory(); + + test("Should make a new entity with single subfactory", async () => { + const petMaked = await factory.make(); + + expect(petMaked).toBeInstanceOf(Pet); + expect(petMaked.id).toBeUndefined(); + expect(petMaked.name).toBeDefined(); + expect(petMaked.owner).toBeDefined(); + expect(petMaked.owner).toBeInstanceOf(User); + expect(petMaked.owner.id).toBeUndefined(); + }); + + test("Should make a new entity with single existing subfactory", async () => { + const userFactory = new UserFactory(); + + const petMaked = await factory.make({ + owner: new LazyInstanceAttribute((instance) => new SingleSubfactory(userFactory, { pets: [instance] })), + }); + + expect(petMaked).toBeInstanceOf(Pet); + expect(petMaked.id).toBeUndefined(); + expect(petMaked.name).toBeDefined(); + expect(petMaked.owner).toBeDefined(); + expect(petMaked.owner).toBeInstanceOf(User); + expect(petMaked.owner.id).toBeUndefined(); + }); + }); + }); + + describe(Factory.prototype.makeMany, () => { + test("Should make many new entities", async () => { + const count = 2; + const factory = new UserFactory(); + const entitiesMaked = await factory.makeMany(count); + + expect(entitiesMaked).toHaveLength(count); + + for (const entity of entitiesMaked) { + expect(entity.id).toBeUndefined(); + } + }); + }); + + describe(Factory.prototype.create, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + describe(UserFactory, () => { + const factory = new UserFactory(); + + test("Should create a new entity", async () => { + const userCreated = await factory.create(); + + expect(userCreated).toBeInstanceOf(User); + expect(userCreated.id).toBeDefined(); + expect(userCreated.name).toBeDefined(); + expect(userCreated.lastName).toBeDefined(); + expect(userCreated.age).toBeDefined(); + expect(userCreated.email).toBeDefined(); + + expect(userCreated.pets).toBeInstanceOf(Array); + expect(userCreated.pets).toHaveLength(0); + }); + + test("Should create a new entity with attribute overrided", async () => { + const userCreated = await factory.create({ + name: "john", + }); + + expect(userCreated.name).toBe("john"); + }); + + test("Should create a new entity with function as attribute", async () => { + const userCreated = await factory.create({ + name: () => "john", + }); + + expect(userCreated.name).toBe("john"); + }); + + test("Should create a new entity with async function as attribute", async () => { + const userCreated = await factory.create({ + name: async () => "john", + }); + + expect(userCreated.name).toBe("john"); + }); + + test("Should create a new entity with instance attributes", async () => { + const userCreated = await factory.create({ + email: new EagerInstanceAttribute((instance) => + [instance.name.toLowerCase(), instance.lastName.toLowerCase(), "@email.com"].join(""), + ), + }); + + expect(userCreated.email).toMatch(userCreated.name.toLowerCase()); + expect(userCreated.email).toMatch(userCreated.lastName.toLowerCase()); + }); + + test("Should create a new entity with lazy instance attributes", async () => { + const userCreated = await factory.create({ + email: new EagerInstanceAttribute((instance) => + [instance.name.toLowerCase(), instance.lastName.toLowerCase(), "@email.com"].join(""), + ), + }); + + expect(userCreated.email).toMatch(userCreated.name.toLowerCase()); + expect(userCreated.email).toMatch(userCreated.lastName.toLowerCase()); + }); + + test("Should create a new entity with multiple subfactories", async () => { + const userCreated = await factory.create({ + pets: new LazyInstanceAttribute((instance) => new CollectionSubfactory(PetFactory, 1, { owner: instance })), + }); + + expect(userCreated.pets).toBeInstanceOf(Array); + expect(userCreated.pets).toHaveLength(1); + + for (const pet of userCreated.pets) { + expect(pet.id).toBeDefined(); + expect(pet.owner).toBeInstanceOf(User); + expect(pet.owner.id).toBeDefined(); + expect(pet.owner.id).toBe(userCreated.id); + } + }); + + test("Should make a new entity with multiple subfactories in an array", async () => { + const userCreated = await factory.create({ + pets: new LazyInstanceAttribute((instance) => [new SingleSubfactory(PetFactory, { owner: instance })]), + }); + + expect(userCreated.pets).toBeInstanceOf(Array); + expect(userCreated.pets).toHaveLength(1); + + for (const pet of userCreated.pets) { + expect(pet.id).toBeDefined(); + expect(pet.owner).toBeInstanceOf(User); + expect(pet.owner.id).toBeDefined(); + expect(pet.owner.id).toBe(userCreated.id); + } + }); + + test("Should create two entities with different attributes", async () => { + const userCreated1 = await factory.create(); + const userCreated2 = await factory.create(); + + expect(userCreated1).not.toStrictEqual(userCreated2); + }); + }); + + describe(PetFactory, () => { + const factory = new PetFactory(); + + test("Should create a new entity with single subfactory", async () => { + const petCreated = await factory.create(); + + expect(petCreated).toBeInstanceOf(Pet); + expect(petCreated.id).toBeDefined(); + expect(petCreated.name).toBeDefined(); + expect(petCreated.owner).toBeDefined(); + expect(petCreated.owner).toBeInstanceOf(User); + expect(petCreated.owner.id).toBeDefined(); + }); + }); + }); + + describe(Factory.prototype.createMany, () => { + beforeAll(async () => { + await dataSource.initialize(); + }); + + beforeEach(async () => { + await dataSource.synchronize(true); + }); + + afterAll(async () => { + await dataSource.destroy(); + }); + + test("Should create many new entities", async () => { + const count = 2; + const factory = new UserFactory(); + const entitiesCreated = await factory.createMany(count); + + expect(entitiesCreated).toHaveLength(count); + for (const entity of entitiesCreated) { + expect(entity.id).toBeDefined(); + } + }); + }); +}); diff --git a/test/fixtures/Pet.entity.ts b/test/fixtures/Pet.entity.ts index 49af1b7..eff4344 100644 --- a/test/fixtures/Pet.entity.ts +++ b/test/fixtures/Pet.entity.ts @@ -1,15 +1,18 @@ -import { Entity, PrimaryGeneratedColumn, Column, JoinColumn, ManyToOne } from 'typeorm' -import { User } from './User.entity' +import { Entity, PrimaryGeneratedColumn, Column, JoinColumn, ManyToOne } from "typeorm"; +import { User } from "./User.entity"; @Entity() export class Pet { - @PrimaryGeneratedColumn('increment') - id!: string + @PrimaryGeneratedColumn("increment") + id!: string; - @Column() - name!: string + @Column() + name!: string; - @ManyToOne(() => User, (user) => user.pets) - @JoinColumn({ name: 'owner_id' }) - owner!: User + @ManyToOne( + () => User, + (user) => user.pets, + ) + @JoinColumn({ name: "owner_id" }) + owner!: User; } diff --git a/test/fixtures/Pet.factory.ts b/test/fixtures/Pet.factory.ts index 58bbff4..5947987 100644 --- a/test/fixtures/Pet.factory.ts +++ b/test/fixtures/Pet.factory.ts @@ -1,18 +1,18 @@ -import { faker } from '@faker-js/faker' -import { LazyInstanceAttribute, SingleSubfactory } from '../../src' -import { Factory } from '../../src/factory' -import type { FactorizedAttrs } from '../../src/types' -import { Pet } from './Pet.entity' -import { UserFactory } from './User.factory' -import { dataSource } from './dataSource' +import { faker } from "@faker-js/faker"; +import { LazyInstanceAttribute, SingleSubfactory } from "../../src"; +import { Factory } from "../../src/factory"; +import type { FactorizedAttrs } from "../../src/types"; +import { Pet } from "./Pet.entity"; +import { UserFactory } from "./User.factory"; +import { dataSource } from "./dataSource"; export class PetFactory extends Factory { - protected entity = Pet - protected dataSource = dataSource - protected attrs(): FactorizedAttrs { - return { - name: faker.animal.insect(), - owner: new LazyInstanceAttribute((instance) => new SingleSubfactory(UserFactory, { pets: [instance] })), - } - } + protected entity = Pet; + protected dataSource = dataSource; + protected attrs(): FactorizedAttrs { + return { + name: faker.animal.insect(), + owner: new LazyInstanceAttribute((instance) => new SingleSubfactory(UserFactory, { pets: [instance] })), + }; + } } diff --git a/test/fixtures/User.entity.ts b/test/fixtures/User.entity.ts index a2ec341..9f83eed 100644 --- a/test/fixtures/User.entity.ts +++ b/test/fixtures/User.entity.ts @@ -1,32 +1,35 @@ -import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn, OneToMany } from 'typeorm' -import { Pet } from './Pet.entity' +import { Entity, Column, PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn, OneToMany } from "typeorm"; +import { Pet } from "./Pet.entity"; @Entity() export class User { - @PrimaryGeneratedColumn('increment') - id!: number + @PrimaryGeneratedColumn("increment") + id!: number; - @CreateDateColumn({ name: 'created_at' }) - createdAt!: Date + @CreateDateColumn({ name: "created_at" }) + createdAt!: Date; - @UpdateDateColumn({ name: 'updated_at' }) - updatedAt!: Date + @UpdateDateColumn({ name: "updated_at" }) + updatedAt!: Date; - @Column() - name!: string + @Column() + name!: string; - @Column({ name: 'last_name' }) - lastName!: string + @Column({ name: "last_name" }) + lastName!: string; - @Column({ name: 'second_last_name', nullable: true }) - secondLastName?: string + @Column({ name: "second_last_name", nullable: true }) + secondLastName?: string; - @Column() - age!: number + @Column() + age!: number; - @Column() - email!: string + @Column() + email!: string; - @OneToMany(() => Pet, (pet) => pet.owner) - pets!: Pet[] + @OneToMany( + () => Pet, + (pet) => pet.owner, + ) + pets!: Pet[]; } diff --git a/test/fixtures/User.factory.ts b/test/fixtures/User.factory.ts index 44d80de..aabe865 100644 --- a/test/fixtures/User.factory.ts +++ b/test/fixtures/User.factory.ts @@ -1,20 +1,20 @@ -import { faker } from '@faker-js/faker' -import { Factory } from '../../src/factory' -import type { FactorizedAttrs } from '../../src/types' -import { User } from '../fixtures/User.entity' -import { dataSource } from './dataSource' +import { faker } from "@faker-js/faker"; +import { Factory } from "../../src/factory"; +import type { FactorizedAttrs } from "../../src/types"; +import { User } from "../fixtures/User.entity"; +import { dataSource } from "./dataSource"; export class UserFactory extends Factory { - protected entity = User - protected dataSource = dataSource + protected entity = User; + protected dataSource = dataSource; - protected attrs(): FactorizedAttrs { - return { - name: faker.person.firstName(), - lastName: faker.person.lastName(), - age: faker.number.int({ min: 18, max: 65 }), - email: faker.internet.email(), - pets: [], - } - } + protected attrs(): FactorizedAttrs { + return { + name: faker.person.firstName(), + lastName: faker.person.lastName(), + age: faker.number.int({ min: 18, max: 65 }), + email: faker.internet.email(), + pets: [], + }; + } } diff --git a/test/fixtures/dataSource.ts b/test/fixtures/dataSource.ts index e4ab1b7..9c8d970 100644 --- a/test/fixtures/dataSource.ts +++ b/test/fixtures/dataSource.ts @@ -1,7 +1,7 @@ -import { DataSource } from 'typeorm' +import { DataSource } from "typeorm"; export const dataSource = new DataSource({ - type: 'sqlite', - database: ':memory:', - entities: ['test/fixtures/**/*.entity.ts'], -}) + type: "sqlite", + database: ":memory:", + entities: ["test/fixtures/**/*.entity.ts"], +}); diff --git a/tsconfig.build.json b/tsconfig.build.json index 173b3a8..cf5838b 100644 --- a/tsconfig.build.json +++ b/tsconfig.build.json @@ -1,17 +1,10 @@ { - "extends": "./tsconfig.json", - "exclude": [ - "dist", - "coverage", - "examples", - "jest.config.ts", - "node_modules", - "test" - ], - "compilerOptions": { - "declaration": true, - "importHelpers": true, - "outDir": "dist", - "sourceMap": true, - } -} \ No newline at end of file + "extends": "./tsconfig.json", + "exclude": ["dist", "coverage", "examples", "jest.config.ts", "node_modules", "test"], + "compilerOptions": { + "declaration": true, + "importHelpers": true, + "outDir": "dist", + "sourceMap": true + } +} diff --git a/tsconfig.json b/tsconfig.json index 80dd283..d65eabe 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -1,32 +1,27 @@ { - "exclude": [ - "dist", - "coverage" - ], - "compilerOptions": { - "allowUnreachableCode": false, - "allowUnusedLabels": false, - "checkJs": true, - "emitDecoratorMetadata": true, - "esModuleInterop": true, - "exactOptionalPropertyTypes": true, - "experimentalDecorators": true, - "forceConsistentCasingInFileNames": true, - "isolatedModules": true, - "lib": [ - "es2023" - ], - "module": "es2022", - "moduleResolution": "Node", - "noFallthroughCasesInSwitch": true, - "noImplicitOverride": true, - "noImplicitReturns": true, - "noPropertyAccessFromIndexSignature": true, - "noUncheckedIndexedAccess": true, - "noUnusedLocals": true, - "noUnusedParameters": true, - "skipLibCheck": true, - "strict": true, - "target": "es2022" - } -} \ No newline at end of file + "exclude": ["dist", "coverage"], + "compilerOptions": { + "allowUnreachableCode": false, + "allowUnusedLabels": false, + "checkJs": true, + "emitDecoratorMetadata": true, + "esModuleInterop": true, + "exactOptionalPropertyTypes": true, + "experimentalDecorators": true, + "forceConsistentCasingInFileNames": true, + "isolatedModules": true, + "lib": ["es2023"], + "module": "es2022", + "moduleResolution": "Node", + "noFallthroughCasesInSwitch": true, + "noImplicitOverride": true, + "noImplicitReturns": true, + "noPropertyAccessFromIndexSignature": true, + "noUncheckedIndexedAccess": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "skipLibCheck": true, + "strict": true, + "target": "es2022" + } +}