add db seed handler

src/modules/database/resolver/data.factory.ts

@@ -0,0 +1,107 @@
+import { isPromise } from 'node:util/types';
+
+import { isNil } from 'lodash';
+import { EntityManager, EntityTarget } from 'typeorm';
+
+import { panic } from '@/modules/core/helpers';
+import { DBFactoryHandler, FactoryOverride } from '@/modules/database/types';
+
+export class DataFactory<P, T> {
+    private mapFunction!: (entity: P) => Promise<P>;
+
+    constructor(
+        public name: string,
+        public config: Configure,
+        public entity: EntityTarget<P>,
+        protected em: EntityManager,
+        protected factory: DBFactoryHandler<P, T>,
+        protected settings: T,
+    ) {}
+
+    map(mapFunction: (entity: P) => Promise<P>): DataFactory<P, T> {
+        this.mapFunction = mapFunction;
+        return this;
+    }
+
+    async make(params: FactoryOverride<P> = {}): Promise<P> {
+        if (this.factory) {
+            let entity: P = await this.resolveEntity(
+                await this.factory(this.configure, this.settings),
+            );
+            if (this.mapFunction) {
+                entity = await this.mapFunction(entity);
+            }
+            for (const key in params) {
+                if (params[key]) {
+                    entity[key] = params[key];
+                }
+            }
+            return entity;
+        }
+        throw new Error('Could not found entity');
+    }
+
+    async create(params: FactoryOverride<P> = {}, existsCheck?: string): Promise<P> {
+        try {
+            const entity = await this.make(params);
+            if (!isNil(existsCheck)) {
+                const repo = this.em.getRepository(this.entity);
+                const value = (entity as any)[existsCheck];
+                if (!isNil(value)) {
+                    const item = await repo.findOneBy({ [existsCheck]: value } as any);
+                    if (isNil(item)) {
+                        return await this.em.save(entity);
+                    }
+                    return item;
+                }
+            }
+            return await this.em.save(entity);
+        } catch (error) {
+            const message = 'Could not save entity';
+            await panic({ message, error });
+            throw new Error(message);
+        }
+    }
+
+    async makeMany(amount: number, params: FactoryOverride<P> = {}): Promise<P[]> {
+        const list = [];
+        for (let i = 0; i < amount; i++) {
+            list[i] = await this.make(params);
+        }
+        return list;
+    }
+
+    async createMany(
+        amount: number,
+        params: FactoryOverride<P> = {},
+        existsCheck?: string,
+    ): Promise<P[]> {
+        const list = [];
+        for (let i = 0; i < amount; i++) {
+            list[i] = await this.create(params, existsCheck);
+        }
+        return list;
+    }
+
+    private async resolveEntity(entity: P): Promise<P> {
+        for (const attr in entity) {
+            if (entity[attr]) {
+                if (isPromise(entity[attr])) {
+                    entity[attr] = await entity[attr];
+                } else if (typeof entity[attr] === 'object' && !(entity[attr] instanceof Date)) {
+                    const item = entity[attr];
+                    try {
+                        if (typeof (item as any).make === 'function') {
+                            entity[attr] = await (item as any).make();
+                        }
+                    } catch (error) {
+                        const message = `Could not make ${(subEntityFactory as any).name}`;
+                        await panic({ message, error });
+                        throw new Error(message);
+                    }
+                }
+            }
+        }
+        return entity;
+    }
+}