🥅 Await promise

.gitignore

@@ -1,5 +1,4 @@
 node_modules
-lib
 coverage/
 
 # IDEs and editors

lib/decorators/index.d.ts

@@ -0,0 +1 @@
+export * from './post-generation.decorator';

lib/decorators/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./post-generation.decorator"), exports);

lib/decorators/post-generation.decorator.d.ts

@@ -0,0 +1 @@
+export declare function PostGeneration(): (target: any, propertyKey: string) => void;

lib/decorators/post-generation.decorator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostGeneration = void 0;
+const factory_storage_1 = require("../factory-storage");
+function PostGeneration() {
+    return function (target, propertyKey) {
+        factory_storage_1.FactoryStorage.storage.addFactoryPostGenerator(target.constructor.name, propertyKey);
+    };
+}
+exports.PostGeneration = PostGeneration;

lib/factory-storage.d.ts

@@ -0,0 +1,10 @@
+export declare class FactoryStorage {
+    private static instance;
+    factoryPostGenerators: {
+        [factoryName: string]: string[];
+    };
+    private constructor();
+    static get storage(): FactoryStorage;
+    addFactoryPostGenerator(factoryName: string, fnName: string): void;
+    getPostGenerators(factoryName: string): string[];
+}

lib/factory-storage.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FactoryStorage = void 0;
+class FactoryStorage {
+    constructor() {
+        this.factoryPostGenerators = {};
+    }
+    static get storage() {
+        if (!this.instance) {
+            this.instance = new FactoryStorage();
+        }
+        return this.instance;
+    }
+    addFactoryPostGenerator(factoryName, fnName) {
+        if (!this.factoryPostGenerators[factoryName]) {
+            this.factoryPostGenerators[factoryName] = [fnName];
+        }
+        else {
+            this.factoryPostGenerators[factoryName].push(fnName);
+        }
+    }
+    getPostGenerators(factoryName) {
+        return this.factoryPostGenerators[factoryName];
+    }
+}
+exports.FactoryStorage = FactoryStorage;

lib/factory.d.ts

@@ -0,0 +1,12 @@
+import { ObjectLiteral } from 'typeorm';
+import { Constructable } from './types';
+export declare abstract class Factory<T extends ObjectLiteral> {
+    abstract get entity(): Constructable<T>;
+    constructor();
+    create(values?: Partial<T>): Promise<T>;
+    createMany(count: number, values?: Partial<T>): Promise<T[]>;
+    protected getOrCreate(): string[];
+    private getExistingEntity;
+    private createEntity;
+    private static getEntityValue;
+}

lib/factory.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Factory = void 0;
+const typeorm_1 = require("typeorm");
+const subfactory_1 = require("./subfactory");
+const sequence_1 = require("./sequence");
+const factory_storage_1 = require("./factory-storage");
+class Factory {
+    constructor() { }
+    async create(values = {}) {
+        if (this.getOrCreate().length !== 0) {
+            const existingEntity = await this.getExistingEntity(values);
+            if (existingEntity) {
+                return existingEntity;
+            }
+        }
+        const entity = await this.createEntity(values);
+        const savedEntity = await (0, typeorm_1.getRepository)(this.entity).save(entity);
+        const storage = factory_storage_1.FactoryStorage.storage;
+        const postGenerators = storage.getPostGenerators(this.constructor.name);
+        if (postGenerators && postGenerators.length !== 0) {
+            await Promise.all(postGenerators.map(async (fnName) => this[fnName](savedEntity)));
+        }
+        return savedEntity;
+    }
+    async createMany(count, values = {}) {
+        const entities = await Promise.all(Array.from({ length: count }).map(() => this.createEntity(values)));
+        return (0, typeorm_1.getRepository)(this.entity).save(entities);
+    }
+    getOrCreate() {
+        return [];
+    }
+    async getExistingEntity(values) {
+        const whereClauses = {};
+        this.getOrCreate().forEach((key) => {
+            whereClauses[key] = values[key] ? values[key] : this[key];
+        });
+        return (0, typeorm_1.getRepository)(this.entity).findOne({ where: whereClauses });
+    }
+    async createEntity(values) {
+        const entity = new this.entity();
+        await Promise.all(Object.entries(this).map(async ([key, value]) => {
+            const _value = Object.prototype.hasOwnProperty.call(values, key) ? values[key] : value;
+            const entityValue = await Factory.getEntityValue(_value);
+            Object.assign(entity, { [key]: entityValue });
+        }));
+        return entity;
+    }
+    static async getEntityValue(value) {
+        if (value instanceof subfactory_1.SubFactory) {
+            return value.factory.create(value.values);
+        }
+        else if (value instanceof sequence_1.Sequence) {
+            return value.nextValue;
+        }
+        else {
+            return value;
+        }
+    }
+}
+exports.Factory = Factory;

lib/index.d.ts

@@ -0,0 +1,6 @@
+export * from './factory';
+export * from './sequence';
+export * from './subfactory';
+export * from './types';
+export * from './factory-storage';
+export * from './decorators';

lib/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./factory"), exports);
+__exportStar(require("./sequence"), exports);
+__exportStar(require("./subfactory"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./factory-storage"), exports);
+__exportStar(require("./decorators"), exports);

lib/sequence.d.ts

@@ -0,0 +1,7 @@
+import { SequenceFn } from './types';
+export declare class Sequence {
+    fn: SequenceFn;
+    private currentIndex;
+    constructor(fn: SequenceFn);
+    get nextValue(): any;
+}

lib/sequence.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sequence = void 0;
+class Sequence {
+    constructor(fn) {
+        this.currentIndex = 0;
+        this.fn = fn;
+    }
+    get nextValue() {
+        const value = this.fn(this.currentIndex);
+        this.currentIndex++;
+        return value;
+    }
+}
+exports.Sequence = Sequence;

lib/subfactory.d.ts

@@ -0,0 +1,8 @@
+import { FactoryClass } from './types';
+import { Factory } from './factory';
+import { ObjectLiteral } from 'typeorm';
+export declare class SubFactory<T extends ObjectLiteral> {
+    factory: Factory<T>;
+    values: Partial<T> | undefined;
+    constructor(factory: FactoryClass<T>, values?: Partial<T>);
+}

lib/subfactory.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubFactory = void 0;
+class SubFactory {
+    constructor(factory, values) {
+        this.factory = new factory();
+        this.values = values;
+    }
+}
+exports.SubFactory = SubFactory;

lib/types.d.ts

@@ -0,0 +1,5 @@
+import { ObjectLiteral } from 'typeorm';
+import { Factory } from './factory';
+export type FactoryClass<T extends ObjectLiteral> = new () => Factory<T>;
+export type Constructable<T> = new (...args: any[]) => T;
+export type SequenceFn = (i: number) => any;

lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });