@dauflo/nest-fixtures 0.0.1

package/.prettierrc

@@ -0,0 +1,9 @@
+{
+    "singleQuote": true,
+    "trailingComma": "all",
+    "semi": false,
+    "printWidth": 160,
+    "tabWidth": 4,
+    "endOfLine": "auto",
+    "parser": "typescript"
+}

package/dist/fixtures.command.d.ts

@@ -0,0 +1,16 @@
+import { Connection } from 'mongoose';
+import { CommandRunner } from 'nest-commander';
+import { Fixtures } from './fixtures';
+declare type FixturesObject = {
+    [key: string]: Fixtures;
+};
+export declare class FixturesCommand extends CommandRunner {
+    private fixtures;
+    private readonly connection;
+    private fixturesDone;
+    constructor(fixtures: FixturesObject, connection: Connection);
+    private loadData;
+    run(passedParams: string[], options?: Record<string, any>): Promise<void>;
+    purgeDatabase(): void;
+}
+export {};

package/dist/fixtures.command.js

@@ -0,0 +1,84 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FixturesCommand = void 0;
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("@nestjs/mongoose");
+const mongoose_2 = require("mongoose");
+const nest_commander_1 = require("nest-commander");
+let FixturesCommand = class FixturesCommand extends nest_commander_1.CommandRunner {
+    constructor(fixtures, connection) {
+        super();
+        this.fixtures = fixtures;
+        this.connection = connection;
+        this.fixturesDone = [];
+    }
+    loadData(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.fixturesDone.includes(key)) {
+                this.fixturesDone.push(key);
+                if (this.fixtures[key].getDependencies().length !== 0) {
+                    for (const dependency of this.fixtures[key].getDependencies()) {
+                        yield this.loadData(dependency);
+                    }
+                }
+                console.log(`Loading ${key}...`);
+                yield this.fixtures[key].load();
+                console.log(`Done loading ${key}`);
+            }
+        });
+    }
+    run(passedParams, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('=== Starting fixtures load ===');
+            for (const key of Object.keys(this.fixtures)) {
+                yield this.loadData(key);
+            }
+            console.log('=== Fixtures loaded ===');
+            return;
+        });
+    }
+    purgeDatabase() {
+        console.log('Starting purging database...');
+        for (const collection of Object.keys(this.connection.collections)) {
+            this.connection.dropCollection(collection);
+        }
+        console.log('Database purging done');
+    }
+};
+__decorate([
+    (0, nest_commander_1.Option)({
+        flags: '--delete',
+        description: 'Purge all the current collections'
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], FixturesCommand.prototype, "purgeDatabase", null);
+FixturesCommand = __decorate([
+    (0, nest_commander_1.Command)({ name: 'fixtures', description: 'load fixtures into the database' }),
+    __param(0, (0, common_1.Inject)('FIXTURES')),
+    __param(1, (0, mongoose_1.InjectConnection)()),
+    __metadata("design:paramtypes", [Object, mongoose_2.Connection])
+], FixturesCommand);
+exports.FixturesCommand = FixturesCommand;

package/dist/fixtures.d.ts

@@ -0,0 +1,14 @@
+interface IFixtures {
+    load(): void;
+    getDependencies(): string[];
+}
+export declare class ReferenceRepository {
+    private reference;
+    addReference(key: string, data: any): void;
+    getReference<T = any>(key: string): T;
+}
+export declare abstract class Fixtures implements IFixtures {
+    load(): Promise<void>;
+    getDependencies(): string[];
+}
+export {};

package/dist/fixtures.js

@@ -0,0 +1,51 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fixtures = exports.ReferenceRepository = void 0;
+const common_1 = require("@nestjs/common");
+let ReferenceRepository = class ReferenceRepository {
+    constructor() {
+        this.reference = {};
+    }
+    addReference(key, data) {
+        if (this.reference[key] !== undefined) {
+            throw new Error(`Key "${key}" already exists`);
+        }
+        this.reference[key] = data;
+    }
+    getReference(key) {
+        if (this.reference[key] === undefined) {
+            throw new Error(`Key "${key}" does not exist`);
+        }
+        return this.reference[key];
+    }
+};
+ReferenceRepository = __decorate([
+    (0, common_1.Injectable)()
+], ReferenceRepository);
+exports.ReferenceRepository = ReferenceRepository;
+class Fixtures {
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new common_1.NotImplementedException();
+        });
+    }
+    getDependencies() {
+        return [];
+    }
+}
+exports.Fixtures = Fixtures;

package/dist/fixtures.module.d.ts

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

package/dist/fixtures.module.js

@@ -0,0 +1,54 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FixturesModule = void 0;
+const mongoose_1 = require("@nestjs/mongoose");
+const glob_1 = require("glob");
+class FixturesModule {
+    static forRootAsync(fixturesPathPattern, entitiesPathPattern) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fixturesPath = glob_1.glob.sync(fixturesPathPattern);
+            const fixturesRelativePath = fixturesPath.map((path) => path.replace('src/', './../')).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) => path.replace('src/', './../')).map((path) => path.replace('.ts', ''));
+            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)[0]],
+                });
+            });
+            return {
+                module: FixturesModule,
+                imports: [mongoose_1.MongooseModule.forFeature(importedEntities)],
+                providers: [
+                    ...fixturesProviders,
+                    {
+                        provide: 'FIXTURES',
+                        useFactory(...args) {
+                            const providersObject = {};
+                            args.forEach((arg) => (providersObject[arg.constructor.name] = arg));
+                            return providersObject;
+                        },
+                    },
+                ],
+                exports: ['FIXTURES'],
+            };
+        });
+    }
+}
+exports.FixturesModule = FixturesModule;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './fixtures';
+export * from './fixtures.command';
+export * from './fixtures.module';

package/dist/index.js

@@ -0,0 +1,19 @@
+"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("./fixtures"), exports);
+__exportStar(require("./fixtures.command"), exports);
+__exportStar(require("./fixtures.module"), exports);

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@dauflo/nest-fixtures",
+  "version": "0.0.1",
+  "description": "",
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@nestjs/common": "^9.1.1",
+    "@nestjs/core": "^9.1.1",
+    "@nestjs/mongoose": "^9.2.0",
+    "@types/glob": "^8.0.0",
+    "glob": "^8.0.3",
+    "mongoose": "^6.6.1",
+    "nest-commander": "^3.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^4.8.3"
+  }
+}

package/src/fixtures.command.ts

@@ -0,0 +1,53 @@
+import { Inject } from '@nestjs/common'
+import { InjectConnection } from '@nestjs/mongoose'
+import { Connection } from 'mongoose'
+import { Command, CommandRunner, Option } from 'nest-commander'
+import { Fixtures } from './fixtures'
+
+type FixturesObject = {
+    [key: string]: Fixtures
+}
+
+@Command({ name: 'fixtures', description: 'load fixtures into the database' })
+export class FixturesCommand extends CommandRunner {
+    private fixturesDone: string[] = []
+
+    constructor(@Inject('FIXTURES') private fixtures: FixturesObject, @InjectConnection() private readonly connection: Connection) {
+        super()
+    }
+
+    private async loadData(key: string) {
+        if (!this.fixturesDone.includes(key)) {
+            this.fixturesDone.push(key)
+            if (this.fixtures[key].getDependencies().length !== 0) {
+                for (const dependency of this.fixtures[key].getDependencies()) {
+                    await this.loadData(dependency)
+                }
+            }
+            console.log(`Loading ${key}...`)
+            await this.fixtures[key].load()
+            console.log(`Done loading ${key}`)
+        }
+    }
+
+    async run(passedParams: string[], options?: Record<string, any>): Promise<void> {
+        console.log('=== Starting fixtures load ===')
+        for (const key of Object.keys(this.fixtures)) {
+            await this.loadData(key)
+        }
+        console.log('=== Fixtures loaded ===')
+        return
+    }
+
+    @Option({
+        flags: '--delete',
+        description: 'Purge all the current collections'
+    })
+    purgeDatabase() {
+        console.log('Starting purging database...')
+        for (const collection of Object.keys(this.connection.collections)) {
+            this.connection.dropCollection(collection)
+        }
+        console.log('Database purging done')
+    }
+}

package/src/fixtures.module.ts

@@ -0,0 +1,47 @@
+import { DynamicModule } from '@nestjs/common'
+import { MongooseModule } from '@nestjs/mongoose'
+import { glob } from 'glob'
+
+export class FixturesModule {
+    static async forRootAsync(fixturesPathPattern: string, entitiesPathPattern: string): Promise<DynamicModule> {
+        // import fixtures
+        const fixturesPath = glob.sync(fixturesPathPattern)
+        const fixturesRelativePath = fixturesPath.map((path) => path.replace('src/', './../')).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) => path.replace('src/', './../')).map((path) => path.replace('.ts', ''))
+        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)[0]],
+            })
+        })
+
+        return {
+            module: FixturesModule,
+            imports: [MongooseModule.forFeature(importedEntities)],
+            providers: [
+                ...fixturesProviders,
+                {
+                    provide: 'FIXTURES',
+                    useFactory(...args) {
+                        const providersObject = {}
+                        args.forEach((arg) => (providersObject[arg.constructor.name] = arg))
+                        return providersObject
+                    },
+                },
+            ],
+            exports: ['FIXTURES'],
+        }
+    }
+}

package/src/fixtures.ts

@@ -0,0 +1,37 @@
+import { Injectable, NotImplementedException } from '@nestjs/common'
+
+interface IFixtures {
+    load(): void
+
+    getDependencies(): string[]
+}
+
+@Injectable()
+export class ReferenceRepository {
+    private reference: { [key: string]: any } = {}
+
+    addReference(key: string, data: any) {
+        if (this.reference[key] !== undefined) {
+            throw new Error(`Key "${key}" already exists`)
+        }
+
+        this.reference[key] = data
+    }
+
+    getReference<T = any>(key: string): T {
+        if (this.reference[key] === undefined) {
+            throw new Error(`Key "${key}" does not exist`)
+        }
+        return this.reference[key]
+    }
+}
+
+export abstract class Fixtures implements IFixtures {
+    async load(): Promise<void> {
+        throw new NotImplementedException()
+    }
+
+    getDependencies(): string[] {
+        return []
+    }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './fixtures'
+export * from './fixtures.command'
+export * from './fixtures.module'

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "compilerOptions": {
+        "target": "ES6",
+        "module": "CommonJS",
+        "declaration": true,
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "removeComments": true,
+        "baseUrl": "./",
+        "experimentalDecorators": true,
+        "emitDecoratorMetadata": true
+    },
+    "include": ["src"],
+    "exclude": ["node_modules", "dist"]
+}