@ackplus/nest-seeder 1.1.1 → 1.1.5

package/src/lib/seeder/seeder.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seeder = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@nestjs/core");
+const yargs_1 = tslib_1.__importDefault(require("yargs"));
+const seeder_module_1 = require("./seeder.module");
+const seeder_service_1 = require("./seeder.service");
+async function bootstrap(options) {
+    const app = await core_1.NestFactory.createApplicationContext(seeder_module_1.SeederModule.register(options));
+    const seedersService = app.get(seeder_service_1.SeederService);
+    await seedersService.run();
+    await app.close();
+}
+const seeder = (options) => {
+    return {
+        run(extraOptions) {
+            const cliOptions = {};
+            const argv = (0, yargs_1.default)(process.argv).argv;
+            if (argv.r || argv.refresh) {
+                cliOptions.refresh = true;
+            }
+            if (argv.n || argv.name) {
+                cliOptions.name = argv.n || argv.name;
+            }
+            if (argv.d || argv.dummyData) {
+                cliOptions.dummyData = argv.d || argv.dummyData;
+            }
+            extraOptions = Object.assign(extraOptions, cliOptions);
+            return bootstrap({
+                ...options,
+                ...extraOptions,
+            });
+        },
+    };
+};
+exports.seeder = seeder;

package/src/lib/seeder/seeder.module.d.ts

@@ -0,0 +1,18 @@
+import { DynamicModule, Provider, Type, ForwardReference } from '@nestjs/common';
+import { Seeder, SeederServiceOptions } from './seeder.interface';
+import { SeederModuleAsyncOptions } from '../interfaces/seeder-module-async-options.interface';
+export interface SeederModuleExtraOptions extends SeederServiceOptions {
+    seeders?: Provider<Seeder>[];
+    plugins?: any[];
+}
+export interface SeederModuleOptions extends SeederModuleExtraOptions {
+    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
+    providers?: Provider[];
+}
+export declare class SeederModule {
+    static register(options: SeederModuleOptions): DynamicModule;
+    static forRootAsync(options: SeederModuleAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+}
+//# sourceMappingURL=seeder.module.d.ts.map

package/src/lib/seeder/seeder.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seeder.module.d.ts","sourceRoot":"","sources":["../../../../../../packages/nest-seeder/src/lib/seeder/seeder.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,aAAa,EACb,QAAQ,EACR,IAAI,EACJ,gBAAgB,EACnB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAElE,OAAO,EAAE,wBAAwB,EAAE,MAAM,qDAAqD,CAAC;AAG/F,MAAM,WAAW,wBAAyB,SAAQ,oBAAoB;IAClE,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;IAC7B,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,mBAAoB,SAAQ,wBAAwB;IACjE,OAAO,CAAC,EAAE,KAAK,CACX,IAAI,CAAC,GAAG,CAAC,GAAG,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,GAAG,gBAAgB,CACxE,CAAC;IACF,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;CAC1B;AAID,qBACa,YAAY;IAErB,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,mBAAmB,GAAG,aAAa;IAkB5D,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,wBAAwB,GAAG,aAAa;IAkBrE,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAcnC,OAAO,CAAC,MAAM,CAAC,0BAA0B;CAgB5C"}

package/src/lib/seeder/seeder.module.js

@@ -0,0 +1,74 @@
+"use strict";
+var SeederModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeederModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const seeder_service_1 = require("./seeder.service");
+const SEEDER_MODULE_OPTIONS = 'SEEDER_MODULE_OPTIONS';
+let SeederModule = SeederModule_1 = class SeederModule {
+    static register(options) {
+        return {
+            module: SeederModule_1,
+            imports: options.imports || [],
+            providers: [
+                ...(options.providers || []),
+                ...options.seeders || [],
+                {
+                    provide: seeder_service_1.SeederService,
+                    useFactory: (...seeders) => {
+                        return new seeder_service_1.SeederService(seeders, options);
+                    },
+                    inject: (options.seeders || []),
+                },
+            ],
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: SeederModule_1,
+            global: options.isGlobal,
+            imports: options.imports || [],
+            providers: [
+                ...this.createAsyncProviders(options),
+                {
+                    provide: seeder_service_1.SeederService,
+                    useFactory: async (seederOptions, ...seeders) => {
+                        return new seeder_service_1.SeederService(seeders, seederOptions);
+                    },
+                    inject: [SEEDER_MODULE_OPTIONS, ...(options.inject || [])],
+                },
+            ],
+        };
+    }
+    static createAsyncProviders(options) {
+        if (options.useExisting || options.useFactory) {
+            return [this.createAsyncOptionsProvider(options)];
+        }
+        return [
+            this.createAsyncOptionsProvider(options),
+            {
+                provide: options.useClass,
+                useClass: options.useClass,
+            },
+        ];
+    }
+    static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+            return {
+                provide: SEEDER_MODULE_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject || [],
+            };
+        }
+        return {
+            provide: SEEDER_MODULE_OPTIONS,
+            useFactory: async (optionsFactory) => await optionsFactory.createSeederOptions(),
+            inject: [options.useExisting || options.useClass],
+        };
+    }
+};
+exports.SeederModule = SeederModule;
+exports.SeederModule = SeederModule = SeederModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({})
+], SeederModule);

package/src/lib/seeder/seeder.service.d.ts

@@ -0,0 +1,11 @@
+import { Seeder, SeederServiceOptions } from './seeder.interface';
+export declare class SeederService {
+    private readonly seeders;
+    private readonly options;
+    constructor(seeders: Seeder[], options?: SeederServiceOptions);
+    run(): Promise<any>;
+    seed(): Promise<any>;
+    drop(): Promise<any>;
+    getSeederToRun(): Seeder[];
+}
+//# sourceMappingURL=seeder.service.d.ts.map

package/src/lib/seeder/seeder.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seeder.service.d.ts","sourceRoot":"","sources":["../../../../../../packages/nest-seeder/src/lib/seeder/seeder.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAGlE,qBACa,aAAa;IAGlB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADP,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,GAAE,oBAAyB;IAGjD,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC;IASnB,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC;IAYpB,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC;IAS1B,cAAc,IAAI,MAAM,EAAE;CAmC7B"}

package/src/lib/seeder/{seeder.service.ts → seeder.service.js}

@@ -1,38 +1,33 @@
-import { Injectable } from '@nestjs/common';
-
-import { Seeder, SeederServiceOptions } from './seeder.interface';
-
-
-@Injectable()
-export class SeederService {
-
-    constructor(
-        private readonly seeders: Seeder[],
-        private readonly options: SeederServiceOptions = {},
-    ) { }
-
-    async run(): Promise<any> {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeederService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+let SeederService = class SeederService {
+    constructor(seeders, options = {}) {
+        this.seeders = seeders;
+        this.options = options;
+    }
+    async run() {
         if (this.options.refresh) {
             await this.drop();
             await this.seed();
-        } else {
+        }
+        else {
             await this.seed();
         }
     }
-
-    async seed(): Promise<any> {
+    async seed() {
         // Don't use `Promise.all` during insertion.
         // `Promise.all` will run all promises in parallel which is not what we want.
         const seeders = this.getSeederToRun();
-
         for (const seeder of seeders) {
             console.info(`${seeder.constructor.name} start`);
             await seeder.seed(this.options);
             console.info(`${seeder.constructor.name} completed`);
         }
     }
-
-    async drop(): Promise<any> {
+    async drop() {
         const seeders = this.getSeederToRun();
         for (const seeder of seeders) {
             console.info(`Truncate ${seeder.constructor.name} start`);
@@ -40,40 +35,28 @@ export class SeederService {
             console.info(`Truncate ${seeder.constructor.name} completed`);
         }
     }
-
-    getSeederToRun(): Seeder[] {
+    getSeederToRun() {
         if (this.options?.name && typeof this.options.name === 'string') {
             this.options.name = [this.options.name];
         }
-
         if (this.options.name) {
             const nameArray = Array.isArray(this.options.name) ? this.options.name : [this.options.name];
-            const seeders = this.seeders.filter(
-                (s) => nameArray.indexOf(s.constructor.name) >= 0,
-            );
+            const seeders = this.seeders.filter((s) => nameArray.indexOf(s.constructor.name) >= 0);
             if (seeders?.length === 0) {
                 const allNames = this.seeders.map((s) => s.constructor.name);
-                console.warn(
-                    '\x1b[43m',
-                    'Warning : No Seeder Found.  Available Name are',
-                    '\x1b[0m',
-                    '\x1b[32m',
-                    '\n',
-                    `${allNames.join('\n')}`,
-                    '\x1b[0m',
-                );
+                console.warn('\x1b[43m', 'Warning : No Seeder Found.  Available Name are', '\x1b[0m', '\x1b[32m', '\n', `${allNames.join('\n')}`, '\x1b[0m');
                 return [];
             }
             return seeders;
         }
         if (this.seeders?.length === 0) {
-            console.info(
-                '\x1b[43m',
-                'Warning : No seeders to run. Make sure you have passed default seeder',
-                '\x1b[0m',
-            );
+            console.info('\x1b[43m', 'Warning : No seeders to run. Make sure you have passed default seeder', '\x1b[0m');
         }
         return this.seeders;
     }
-
-}
+};
+exports.SeederService = SeederService;
+exports.SeederService = SeederService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [Array, Object])
+], SeederService);

package/src/lib/storages/factory.metadata.storage.d.ts

@@ -0,0 +1,17 @@
+import { Type } from '@nestjs/common';
+import { FactoryValue, FactoryValueGenerator } from '../decorators/factory.decorator';
+export type PropertyMetadataType = {
+    target?: any;
+    propertyKey?: any;
+    arg: {
+        generator: FactoryValueGenerator | FactoryValue;
+        dependsOn?: string[];
+    };
+};
+export declare class FactoryMetadataStorageHost {
+    private properties;
+    addPropertyMetadata(metadata: PropertyMetadataType): void;
+    getPropertyMetadatasByTarget(target: Type<unknown>): PropertyMetadataType[];
+}
+export declare const FactoryMetadataStorage: FactoryMetadataStorageHost;
+//# sourceMappingURL=factory.metadata.storage.d.ts.map

package/src/lib/storages/factory.metadata.storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.metadata.storage.d.ts","sourceRoot":"","sources":["../../../../../../packages/nest-seeder/src/lib/storages/factory.metadata.storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAEtC,OAAO,EACH,YAAY,EACZ,qBAAqB,EACxB,MAAM,iCAAiC,CAAC;AAGzC,MAAM,MAAM,oBAAoB,GAAG;IAC/B,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,WAAW,CAAC,EAAE,GAAG,CAAC;IAClB,GAAG,EAAE;QACD,SAAS,EAAE,qBAAqB,GAAG,YAAY,CAAC;QAChD,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;KACxB,CAAC;CACL,CAAC;AAEF,qBAAa,0BAA0B;IAEnC,OAAO,CAAC,UAAU,CAA8B;IAEhD,mBAAmB,CAAC,QAAQ,EAAE,oBAAoB,GAAG,IAAI;IAIzD,4BAA4B,CACxB,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,GACtB,oBAAoB,EAAE;CAI5B;AAID,eAAO,MAAM,sBAAsB,EAAE,0BACoC,CAAC"}

package/src/lib/storages/factory.metadata.storage.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FactoryMetadataStorage = exports.FactoryMetadataStorageHost = void 0;
+class FactoryMetadataStorageHost {
+    constructor() {
+        this.properties = [];
+    }
+    addPropertyMetadata(metadata) {
+        this.properties.push(metadata);
+    }
+    getPropertyMetadatasByTarget(target) {
+        return this.properties.filter((property) => property.target === target);
+    }
+}
+exports.FactoryMetadataStorageHost = FactoryMetadataStorageHost;
+const globalRef = global;
+exports.FactoryMetadataStorage = globalRef.FactoryMetadataStorage ||
+    (globalRef.FactoryMetadataStorage = new FactoryMetadataStorageHost());

package/eslint.config.mjs

@@ -1,22 +0,0 @@
-import baseConfig from '../../eslint.base.config';
-
-export default [
-  ...baseConfig,
-  {
-    files: ['**/*.json'],
-    rules: {
-      '@nx/dependency-checks': [
-        'error',
-        {
-          ignoredFiles: ['{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}'],
-        },
-      ],
-    },
-    languageOptions: {
-      parser: await import('jsonc-eslint-parser'),
-    },
-  },
-  {
-    ignores: ['**/out-tsc'],
-  },
-];

package/jest.config.ts

@@ -1,10 +0,0 @@
-export default {
-  displayName: 'test-nest-2',
-  preset: '../../jest.preset.js',
-  testEnvironment: 'node',
-  transform: {
-    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
-  },
-  moduleFileExtensions: ['ts', 'js', 'html'],
-  coverageDirectory: '../../coverage/packages/test-nest-2',
-};

package/project.json

@@ -1,38 +0,0 @@
-{
-  "name": "nest-seeder",
-  "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "packages/nest-seeder/src",
-  "projectType": "library",
-  "release": {
-    "version": {
-      "manifestRootsToUpdate": [
-        "dist/{projectRoot}"
-      ],
-      "currentVersionResolver": "git-tag",
-      "fallbackCurrentVersionResolver": "disk"
-    }
-  },
-  "tags": [],
-  "targets": {
-    "build": {
-      "executor": "@nx/js:tsc",
-      "outputs": [
-        "{options.outputPath}"
-      ],
-      "options": {
-        "outputPath": "dist/packages/nest-seeder",
-        "tsConfig": "packages/nest-seeder/tsconfig.lib.json",
-        "packageJson": "packages/nest-seeder/package.json",
-        "main": "packages/nest-seeder/src/index.ts",
-        "assets": [
-          "packages/nest-seeder/*.md"
-        ]
-      }
-    },
-    "nx-release-publish": {
-      "options": {
-        "packageRoot": "dist/{projectRoot}"
-      }
-    }
-  }
-}

package/src/lib/decorators/factory.decorator.ts

@@ -1,32 +0,0 @@
-import { Faker } from '@faker-js/faker';
-
-import { FactoryMetadataStorage } from '../storages/factory.metadata.storage';
-
-
-type BaseType = string | number | Date | Buffer | boolean | Record<string, any>;
-
-export type FactoryValue = BaseType | Array<BaseType>;
-
-export type FactoryValueGenerator = (
-    faker?: Faker,
-    ctx?: Record<string, any>
-) => FactoryValue;
-
-export function Factory(
-    generator: FactoryValueGenerator | FactoryValue,
-    dependsOn?: string[],
-) {
-    return (
-        target: Record<string, any>,
-        propertyKey: string | symbol,
-    ): void => {
-        FactoryMetadataStorage.addPropertyMetadata({
-            target: target.constructor,
-            propertyKey: propertyKey as string,
-            arg: {
-                generator,
-                dependsOn,
-            },
-        });
-    };
-}

package/src/lib/interfaces/factory.interface.ts

@@ -1,9 +0,0 @@
-import { FactoryValue } from '../decorators/factory.decorator';
-
-
-export interface Factory {
-    generate(
-        count: number,
-        values?: Record<string, any>
-    ): Record<string, FactoryValue>[];
-}

package/src/lib/interfaces/property-metadata.interface.ts

@@ -1,11 +0,0 @@
-import {
-    FactoryValueGenerator,
-    FactoryValue,
-} from '../decorators/factory.decorator';
-
-
-export interface PropertyMetadata {
-    target: () => void;
-    propertyKey: string;
-    arg: FactoryValueGenerator | FactoryValue;
-}

package/src/lib/seeder/seeder.module.ts

@@ -1,97 +0,0 @@
-import {
-    Module,
-    DynamicModule,
-    Provider,
-    Type,
-    ForwardReference,
-} from '@nestjs/common';
-
-import { Seeder, SeederServiceOptions } from './seeder.interface';
-import { SeederService } from './seeder.service';
-import { SeederModuleAsyncOptions } from '../interfaces/seeder-module-async-options.interface';
-import { SeederOptionsFactory } from '../interfaces/seeder-options-factory.interface';
-
-export interface SeederModuleExtraOptions extends SeederServiceOptions {
-    seeders?: Provider<Seeder>[];
-    plugins?: any[];
-}
-
-export interface SeederModuleOptions extends SeederModuleExtraOptions {
-    imports?: Array<
-        Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
-    >;
-    providers?: Provider[];
-}
-
-const SEEDER_MODULE_OPTIONS = 'SEEDER_MODULE_OPTIONS';
-
-@Module({})
-export class SeederModule {
-
-    static register(options: SeederModuleOptions): DynamicModule {
-        return {
-            module: SeederModule,
-            imports: options.imports || [],
-            providers: [
-                ...(options.providers || []),
-                ...options.seeders || [],
-                {
-                    provide: SeederService,
-                    useFactory: (...seeders: Seeder[]): SeederService => {
-                        return new SeederService(seeders, options);
-                    },
-                    inject: (options.seeders || []) as Type<any>[],
-                },
-            ],
-        };
-    }
-
-    static forRootAsync(options: SeederModuleAsyncOptions): DynamicModule {
-        return {
-            module: SeederModule,
-            global: options.isGlobal,
-            imports: options.imports || [],
-            providers: [
-                ...this.createAsyncProviders(options),
-                {
-                    provide: SeederService,
-                    useFactory: async (seederOptions: SeederModuleOptions, ...seeders: Seeder[]): Promise<SeederService> => {
-                        return new SeederService(seeders, seederOptions);
-                    },
-                    inject: [SEEDER_MODULE_OPTIONS, ...(options.inject || [])],
-                },
-            ],
-        };
-    }
-
-    private static createAsyncProviders(options: SeederModuleAsyncOptions): Provider[] {
-        if (options.useExisting || options.useFactory) {
-            return [this.createAsyncOptionsProvider(options)];
-        }
-
-        return [
-            this.createAsyncOptionsProvider(options),
-            {
-                provide: options.useClass!,
-                useClass: options.useClass!,
-            },
-        ];
-    }
-
-    private static createAsyncOptionsProvider(options: SeederModuleAsyncOptions): Provider {
-        if (options.useFactory) {
-            return {
-                provide: SEEDER_MODULE_OPTIONS,
-                useFactory: options.useFactory,
-                inject: options.inject || [],
-            };
-        }
-
-        return {
-            provide: SEEDER_MODULE_OPTIONS,
-            useFactory: async (optionsFactory: SeederOptionsFactory) =>
-                await optionsFactory.createSeederOptions(),
-            inject: [options.useExisting || options.useClass!],
-        };
-    }
-}

package/src/lib/seeder/seeder.ts

@@ -1,66 +0,0 @@
-import {
-    Provider,
-    Type,
-    DynamicModule,
-    ForwardReference,
-} from '@nestjs/common';
-import { NestFactory } from '@nestjs/core';
-import yargs from 'yargs';
-
-import { SeederServiceOptions } from './seeder.interface';
-import {
-    SeederModule,
-    SeederModuleExtraOptions,
-    SeederModuleOptions,
-} from './seeder.module';
-import { SeederService } from './seeder.service';
-
-
-export interface SeederOptions {
-    imports?: Array<
-        Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
-    >;
-    providers?: Provider[];
-}
-
-export interface SeederRunner {
-    run(extraOptions: SeederModuleExtraOptions): Promise<void>;
-}
-
-async function bootstrap(options: SeederModuleOptions) {
-    const app = await NestFactory.createApplicationContext(
-        SeederModule.register(options),
-    );
-
-    const seedersService = app.get(SeederService);
-    await seedersService.run();
-
-    await app.close();
-}
-
-export const seeder = (options: SeederOptions): SeederRunner => {
-    return {
-        run(extraOptions: SeederModuleExtraOptions): Promise<void> {
-            const cliOptions: SeederServiceOptions = {};
-            const argv:any = yargs(process.argv).argv;
-            if (argv.r || argv.refresh) {
-                cliOptions.refresh = true;
-            }
-
-            if (argv.n || argv.name) {
-                cliOptions.name = argv.n || argv.name;
-            }
-
-            if (argv.d || argv.dummyData) {
-                cliOptions.dummyData = argv.d || argv.dummyData;
-            }
-
-            extraOptions = Object.assign(extraOptions, cliOptions);
-
-            return bootstrap({
-                ...options,
-                ...extraOptions,
-            });
-        },
-    };
-};

package/src/lib/storages/factory.metadata.storage.ts

@@ -1,37 +0,0 @@
-import { Type } from '@nestjs/common';
-
-import {
-    FactoryValue,
-    FactoryValueGenerator,
-} from '../decorators/factory.decorator';
-
-
-export type PropertyMetadataType = {
-    target?: any;
-    propertyKey?: any;
-    arg: {
-        generator: FactoryValueGenerator | FactoryValue;
-        dependsOn?: string[];
-    };
-};
-
-export class FactoryMetadataStorageHost {
-
-    private properties: PropertyMetadataType[] = [];
-
-    addPropertyMetadata(metadata: PropertyMetadataType): void {
-        this.properties.push(metadata);
-    }
-
-    getPropertyMetadatasByTarget(
-        target: Type<unknown>,
-    ): PropertyMetadataType[] {
-        return this.properties.filter((property) => property.target === target);
-    }
-
-}
-
-const globalRef = global as any;
-
-export const FactoryMetadataStorage: FactoryMetadataStorageHost = globalRef.FactoryMetadataStorage ||
-    (globalRef.FactoryMetadataStorage = new FactoryMetadataStorageHost());

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "forceConsistentCasingInFileNames": true
-  },
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,14 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "declaration": true,
-    "types": ["node"],
-    "target": "es2021",
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
-}