@dauflo/nest-fixtures 1.0.3 → 1.2.0

package/README.md

@@ -165,6 +165,29 @@ To create dependencies, just add the `getDependencies` method and give the fixtu
 
 The `ReferenceRepository` is a `singleton` that will keep track of the data passed from fixtures to fixtures.
 
+## Discriminator
+You can use the mongoose discriminator feature in your fixtures. You just need to add put your discriminators class in a folder named for example `discri` and add the following definition when importing the fixtures modules:
+
+```ts
+// src/app.module.ts
+
+import { FixturesCommand, FixturesModule } from '@dauflo/nest-fixtures'
+
+@Module({
+    imports: [
+        FixturesModule.forRootAsync(
+            'src/datafixtures/*.fixtures.ts',
+            'src/models/**/*.schema.ts',
+            'discri'
+        )
+    ],
+    providers: [
+        FixturesCommand
+    ]
+})
+export class AppModule {}
+```
+
 ## License
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/dist/fixtures.module.d.ts

@@ -1,4 +1,5 @@
 import { DynamicModule } from '@nestjs/common';
 export declare class FixturesModule {
-    static forRootAsync(fixturesPathPattern: string, entitiesPathPattern: string): Promise<DynamicModule>;
+    static forRootAsync(fixturesPathPattern: string, entitiesPathPattern: string, discriminatorDir?: string): Promise<DynamicModule>;
+    static forRootAsyncMonorepo(fixturesPathPattern: string, entitiesPathPattern: string, discriminatorDir?: string, buildDir?: string): Promise<DynamicModule>;
 }

package/dist/fixtures.module.js

@@ -14,7 +14,7 @@ const mongoose_1 = require("@nestjs/mongoose");
 const glob_1 = require("glob");
 const fixtures_1 = require("./fixtures");
 class FixturesModule {
-    static forRootAsync(fixturesPathPattern, entitiesPathPattern) {
+    static forRootAsync(fixturesPathPattern, entitiesPathPattern, discriminatorDir = 'discriminatorDir') {
         return __awaiter(this, void 0, void 0, function* () {
             const fixturesPath = glob_1.glob.sync(fixturesPathPattern);
             const fixturesRelativePath = fixturesPath.map((path) => path.replace('src/', `${process.cwd()}/dist/`)).map((path) => path.replace('.ts', ''));
@@ -25,14 +25,73 @@ class FixturesModule {
             });
             const entitiesPath = glob_1.glob.sync(entitiesPathPattern);
             const entitiesRelativePath = entitiesPath.map((path) => path.replace('src/', `${process.cwd()}/dist/`)).map((path) => path.replace('.ts', ''));
+            const nonDiscriminatorsRelativePath = entitiesRelativePath.filter((e) => !e.includes(discriminatorDir));
+            const discriminatorsRelativePath = entitiesRelativePath.filter((e) => e.includes(discriminatorDir));
             const entitiesProviders = [];
-            const importedEntities = yield Promise.all(entitiesRelativePath.map((path) => Promise.resolve().then(() => require(path))));
-            importedEntities.forEach((entity) => {
-                entitiesProviders.push({
-                    name: entity[Object.keys(entity)[0]].name,
-                    schema: entity[Object.keys(entity)[1]],
-                });
+            for (const entity of nonDiscriminatorsRelativePath) {
+                const importedEntity = yield Promise.resolve().then(() => require(entity));
+                const provider = {
+                    name: importedEntity[Object.keys(importedEntity)[0]].name,
+                    schema: importedEntity[Object.keys(importedEntity)[1]],
+                };
+                const discriminators = discriminatorsRelativePath.filter((e) => e.includes(entity.replace(/(.+)(\/.+)$/gm, '$1')));
+                if (discriminators.length !== 0) {
+                    const importedDiscriminators = yield Promise.all(discriminators.map((path) => Promise.resolve().then(() => require(path))));
+                    provider['discriminators'] = importedDiscriminators.map((e) => {
+                        return { name: e[Object.keys(e)[0]].name, schema: e[Object.keys(e)[1]] };
+                    });
+                }
+                entitiesProviders.push(provider);
+            }
+            return {
+                module: FixturesModule,
+                imports: [mongoose_1.MongooseModule.forFeature(entitiesProviders)],
+                providers: [
+                    fixtures_1.ReferenceRepository,
+                    ...fixturesProviders,
+                    {
+                        provide: 'FIXTURES',
+                        useFactory(...args) {
+                            const providersObject = {};
+                            args.forEach((arg) => (providersObject[arg.constructor.name] = arg));
+                            return providersObject;
+                        },
+                        inject: fixturesProviders,
+                    },
+                ],
+                exports: ['FIXTURES'],
+            };
+        });
+    }
+    static forRootAsyncMonorepo(fixturesPathPattern, entitiesPathPattern, discriminatorDir = 'discriminators', buildDir = 'dist') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fixturesPath = glob_1.glob.sync(fixturesPathPattern);
+            const fixturesRelativePath = fixturesPath.map((path) => `${process.cwd()}/${buildDir}/${path}`).map((path) => path.replace('.ts', ''));
+            const fixturesProviders = [];
+            const importedFixtures = yield Promise.all(fixturesRelativePath.map((path) => Promise.resolve().then(() => require(path))));
+            importedFixtures.forEach((fixture) => {
+                fixturesProviders.push(fixture[Object.keys(fixture)[0]]);
             });
+            const entitiesPath = glob_1.glob.sync(entitiesPathPattern);
+            const entitiesRelativePath = entitiesPath.map((path) => `${process.cwd()}/${buildDir}/${path}`).map((path) => path.replace('.ts', ''));
+            const nonDiscriminatorsRelativePath = entitiesRelativePath.filter((e) => !e.includes(discriminatorDir));
+            const discriminatorsRelativePath = entitiesRelativePath.filter((e) => e.includes(discriminatorDir));
+            const entitiesProviders = [];
+            for (const entity of nonDiscriminatorsRelativePath) {
+                const importedEntity = yield Promise.resolve().then(() => require(entity));
+                const provider = {
+                    name: importedEntity[Object.keys(importedEntity)[0]].name,
+                    schema: importedEntity[Object.keys(importedEntity)[1]],
+                };
+                const discriminators = discriminatorsRelativePath.filter((e) => e.includes(entity.replace(/(.+)(\/.+)$/gm, '$1')));
+                if (discriminators.length !== 0) {
+                    const importedDiscriminators = yield Promise.all(discriminators.map((path) => Promise.resolve().then(() => require(path))));
+                    provider['discriminators'] = importedDiscriminators.map((e) => {
+                        return { name: e[Object.keys(e)[0]].name, schema: e[Object.keys(e)[1]] };
+                    });
+                }
+                entitiesProviders.push(provider);
+            }
             return {
                 module: FixturesModule,
                 imports: [mongoose_1.MongooseModule.forFeature(entitiesProviders)],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dauflo/nest-fixtures",
-  "version": "1.0.3",
+  "version": "1.2.0",
   "description": "A module for making fixtures with NestJS. This package is inspired by Doctrine fixtures.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/fixtures.module.ts

@@ -4,7 +4,7 @@ import { glob } from 'glob'
 import { ReferenceRepository } from './fixtures'
 
 export class FixturesModule {
-    static async forRootAsync(fixturesPathPattern: string, entitiesPathPattern: string): Promise<DynamicModule> {
+    static async forRootAsync(fixturesPathPattern: string, entitiesPathPattern: string, discriminatorDir: string = 'discriminatorDir'): Promise<DynamicModule> {
         // import fixtures
         const fixturesPath = glob.sync(fixturesPathPattern)
         const fixturesRelativePath = fixturesPath.map((path) => path.replace('src/', `${process.cwd()}/dist/`)).map((path) => path.replace('.ts', ''))
@@ -18,16 +18,97 @@ export class FixturesModule {
         // import entities
         const entitiesPath = glob.sync(entitiesPathPattern)
         const entitiesRelativePath = entitiesPath.map((path) => path.replace('src/', `${process.cwd()}/dist/`)).map((path) => path.replace('.ts', ''))
+
+        const nonDiscriminatorsRelativePath = entitiesRelativePath.filter((e) => !e.includes(discriminatorDir))
+        const discriminatorsRelativePath = entitiesRelativePath.filter((e) => e.includes(discriminatorDir))
+
         const entitiesProviders: any[] = []
-        const importedEntities = await Promise.all(entitiesRelativePath.map((path) => import(path)))
 
-        importedEntities.forEach((entity) => {
-            entitiesProviders.push({
-                name: entity[Object.keys(entity)[0]].name,
-                schema: entity[Object.keys(entity)[1]],
-            })
+        for (const entity of nonDiscriminatorsRelativePath) {
+            const importedEntity = await import(entity)
+
+            const provider = {
+                name: importedEntity[Object.keys(importedEntity)[0]].name,
+                schema: importedEntity[Object.keys(importedEntity)[1]],
+            }
+
+            const discriminators = discriminatorsRelativePath.filter((e) => e.includes(entity.replace(/(.+)(\/.+)$/gm, '$1')))
+
+            if (discriminators.length !== 0) {
+                const importedDiscriminators = await Promise.all(discriminators.map((path) => import(path)))
+                provider['discriminators'] = importedDiscriminators.map((e) => {
+                    return { name: e[Object.keys(e)[0]].name, schema: e[Object.keys(e)[1]] }
+                })
+            }
+
+            entitiesProviders.push(provider)
+        }
+
+        return {
+            module: FixturesModule,
+            imports: [MongooseModule.forFeature(entitiesProviders)],
+            providers: [
+                ReferenceRepository,
+                ...fixturesProviders,
+                {
+                    provide: 'FIXTURES',
+                    useFactory(...args) {
+                        const providersObject = {}
+                        args.forEach((arg) => (providersObject[arg.constructor.name] = arg))
+                        return providersObject
+                    },
+                    inject: fixturesProviders,
+                },
+            ],
+            exports: ['FIXTURES'],
+        }
+    }
+
+    static async forRootAsyncMonorepo(
+        fixturesPathPattern: string,
+        entitiesPathPattern: string,
+        discriminatorDir: string = 'discriminators',
+        buildDir: string = 'dist',
+    ): Promise<DynamicModule> {
+        // import fixtures
+        const fixturesPath = glob.sync(fixturesPathPattern)
+        const fixturesRelativePath = fixturesPath.map((path) => `${process.cwd()}/${buildDir}/${path}`).map((path) => path.replace('.ts', ''))
+        const fixturesProviders: any[] = []
+        const importedFixtures = await Promise.all(fixturesRelativePath.map((path) => import(path)))
+
+        importedFixtures.forEach((fixture) => {
+            fixturesProviders.push(fixture[Object.keys(fixture)[0]])
         })
 
+        // import entities
+        const entitiesPath = glob.sync(entitiesPathPattern)
+        const entitiesRelativePath = entitiesPath.map((path) => `${process.cwd()}/${buildDir}/${path}`).map((path) => path.replace('.ts', ''))
+
+        const nonDiscriminatorsRelativePath = entitiesRelativePath.filter((e) => !e.includes(discriminatorDir))
+        const discriminatorsRelativePath = entitiesRelativePath.filter((e) => e.includes(discriminatorDir))
+
+        const entitiesProviders: any[] = []
+
+        for (const entity of nonDiscriminatorsRelativePath) {
+            const importedEntity = await import(entity)
+
+            const provider = {
+                name: importedEntity[Object.keys(importedEntity)[0]].name,
+                schema: importedEntity[Object.keys(importedEntity)[1]],
+            }
+
+            const discriminators = discriminatorsRelativePath.filter((e) => e.includes(entity.replace(/(.+)(\/.+)$/gm, '$1')))
+
+            if (discriminators.length !== 0) {
+                const importedDiscriminators = await Promise.all(discriminators.map((path) => import(path)))
+                provider['discriminators'] = importedDiscriminators.map((e) => {
+                    return { name: e[Object.keys(e)[0]].name, schema: e[Object.keys(e)[1]] }
+                })
+            }
+
+            entitiesProviders.push(provider)
+        }
+
         return {
             module: FixturesModule,
             imports: [MongooseModule.forFeature(entitiesProviders)],