@ackplus/nest-seeder 1.1.2 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ackplus/nest-seeder",
-  "version": "1.1.2",
+  "version": "1.1.6",
   "type": "commonjs",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",

package/src/cli.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seeder = void 0;
+const tslib_1 = require("tslib");
+const seeder_module_1 = require("./lib/seeder/seeder.module");
+const yargs_1 = tslib_1.__importDefault(require("yargs"));
+const core_1 = require("@nestjs/core");
+const seeder_service_1 = require("./lib/seeder/seeder.service");
+const path = tslib_1.__importStar(require("path"));
+const fs = tslib_1.__importStar(require("fs"));
+async function parseArguments() {
+    const argv = await (0, yargs_1.default)(process.argv.slice(2))
+        .option('refresh', {
+        alias: 'r',
+        type: 'boolean',
+        description: 'Drop all data before seeding',
+        default: false
+    })
+        .option('name', {
+        alias: 'n',
+        type: 'array',
+        string: true,
+        description: 'Specific seeder names to run',
+    })
+        .option('dummyData', {
+        alias: 'd',
+        type: 'boolean',
+        description: 'Include dummy data',
+        default: false
+    })
+        .option('config', {
+        alias: 'c',
+        type: 'string',
+        description: 'Path to seeder configuration file',
+        demandOption: true
+    })
+        .help()
+        .example('nest-seed -c ./seeder.config.ts', 'Run all seeders')
+        .example('nest-seed -c ./seeder.config.ts --refresh', 'Drop and reseed all data')
+        .example('nest-seed -c ./seeder.config.ts --name UserSeeder', 'Run specific seeder')
+        .parseAsync();
+    return {
+        refresh: argv.refresh,
+        name: argv.name,
+        dummyData: argv.dummyData,
+        config: argv.config,
+    };
+}
+function setupTsNode() {
+    try {
+        // Register ts-node for TypeScript support
+        require('ts-node').register({
+            transpileOnly: true,
+            compilerOptions: {
+                module: 'commonjs',
+                experimentalDecorators: true,
+                emitDecoratorMetadata: true,
+                esModuleInterop: true,
+                allowSyntheticDefaultImports: true,
+                skipLibCheck: true,
+            }
+        });
+    }
+    catch (error) {
+        console.error('Failed to setup TypeScript support. Make sure ts-node is installed:');
+        console.error('npm install -D ts-node typescript');
+        process.exit(1);
+    }
+}
+async function loadSeederConfig(configPath) {
+    try {
+        // Resolve the config path relative to current working directory
+        const resolvedPath = path.resolve(process.cwd(), configPath);
+        // Check if file exists
+        if (!fs.existsSync(resolvedPath)) {
+            throw new Error(`Configuration file not found: ${resolvedPath}`);
+        }
+        // Setup TypeScript support if needed
+        if (configPath.endsWith('.ts')) {
+            setupTsNode();
+        }
+        // Clear require cache to ensure fresh import
+        delete require.cache[resolvedPath];
+        // Import the configuration
+        const configModule = await Promise.resolve(`${resolvedPath}`).then(s => tslib_1.__importStar(require(s)));
+        const config = configModule.default || configModule;
+        if (!config) {
+            throw new Error('Configuration file must export a default configuration object');
+        }
+        return config;
+    }
+    catch (error) {
+        console.error('Error loading seeder configuration:');
+        console.error(error.message);
+        console.error('\nMake sure your configuration file:');
+        console.error('1. Exists at the specified path');
+        console.error('2. Exports a default configuration object');
+        console.error('3. Has proper TypeScript setup if using .ts files');
+        process.exit(1);
+    }
+}
+async function runSeeder() {
+    try {
+        const args = await parseArguments();
+        console.log('🌱 Starting NestJS Seeder...');
+        console.log(`📁 Loading configuration from: ${args.config}`);
+        // Load the seeder configuration from specified path
+        const seederConfig = await loadSeederConfig(args.config);
+        const cliOptions = {
+            refresh: args.refresh,
+            name: args.name,
+            dummyData: args.dummyData,
+        };
+        if (args.refresh) {
+            console.log('🔄 Refresh mode: Will drop existing data before seeding');
+        }
+        if (args.name && args.name.length > 0) {
+            console.log(`🎯 Running specific seeders: ${args.name.join(', ')}`);
+        }
+        if (args.dummyData) {
+            console.log('🎲 Dummy data mode enabled');
+        }
+        const app = await core_1.NestFactory.createApplicationContext(seeder_module_1.SeederModule.register({
+            ...seederConfig,
+            ...cliOptions,
+        }));
+        const seedersService = app.get(seeder_service_1.SeederService);
+        await seedersService.run();
+        await app.close();
+        console.log('✅ Seeding completed successfully!');
+        process.exit(0);
+    }
+    catch (error) {
+        console.error('❌ Error running seeder:');
+        console.error(error.message);
+        if (error.stack && process.env.NODE_ENV === 'development') {
+            console.error('\nStack trace:');
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+const seeder = (options) => {
+    return {
+        async 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);
+            const app = await core_1.NestFactory.createApplicationContext(seeder_module_1.SeederModule.register({
+                ...options,
+                ...extraOptions,
+            }));
+            const seedersService = app.get(seeder_service_1.SeederService);
+            await seedersService.run();
+            await app.close();
+        },
+    };
+};
+exports.seeder = seeder;
+// Only run if this file is executed directly
+if (require.main === module) {
+    runSeeder();
+}

package/src/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./lib/seeder/seeder"), exports);
+tslib_1.__exportStar(require("./lib/seeder/seeder.interface"), exports);
+tslib_1.__exportStar(require("./lib/seeder/seeder.module"), exports);
+tslib_1.__exportStar(require("./lib/seeder/seeder.service"), exports);
+tslib_1.__exportStar(require("./lib/factory/data.factory"), exports);
+tslib_1.__exportStar(require("./lib/decorators/factory.decorator"), exports);
+tslib_1.__exportStar(require("./lib/interfaces/seeder-options-factory.interface"), exports);
+tslib_1.__exportStar(require("./lib/interfaces/seeder-module-async-options.interface"), exports);

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Factory = Factory;
+const factory_metadata_storage_1 = require("../storages/factory.metadata.storage");
+function Factory(generator, dependsOn) {
+    return (target, propertyKey) => {
+        factory_metadata_storage_1.FactoryMetadataStorage.addPropertyMetadata({
+            target: target.constructor,
+            propertyKey: propertyKey,
+            arg: {
+                generator,
+                dependsOn,
+            },
+        });
+    };
+}

package/src/lib/factory/data.factory.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataFactory = void 0;
+const faker_1 = require("@faker-js/faker");
+const factory_metadata_storage_1 = require("../storages/factory.metadata.storage");
+class DataFactory {
+    static createForClass(target) {
+        if (!target) {
+            throw new Error(`Target class "${target}" passed in to the "TemplateFactory#createForClass()" method is "undefined".`);
+        }
+        const properties = factory_metadata_storage_1.FactoryMetadataStorage.getPropertyMetadatasByTarget(target);
+        return {
+            generate: (count, values = {}) => {
+                const ret = [];
+                for (let i = 0; i < count; i++) {
+                    ret.push(this.generate(properties, values));
+                }
+                return ret;
+            },
+        };
+    }
+    static generate(properties, values) {
+        const ctx = { ...values };
+        return properties.reduce((result, property) => {
+            const propertyKey = property.propertyKey;
+            const { generator, dependsOn } = property.arg;
+            // Skip if the value is already generated in the context (ctx)
+            if (ctx[propertyKey] !== undefined) {
+                return {
+                    [propertyKey]: ctx[propertyKey],
+                    ...result,
+                };
+            }
+            // If the property has dependencies, ensure they are generated first
+            if (Array.isArray(dependsOn)) {
+                dependsOn.forEach((dependency) => {
+                    if (ctx[dependency] === undefined) {
+                        // Find the dependent property and generate it if it hasn't been generated yet
+                        const dependentProperty = properties.find((p) => p.propertyKey === dependency);
+                        if (dependentProperty) {
+                            ctx[dependency] = typeof dependentProperty.arg.generator ===
+                                'function' ?
+                                dependentProperty.arg.generator(faker_1.faker, ctx) :
+                                dependentProperty.arg;
+                        }
+                    }
+                });
+            }
+            // Generate the current field
+            ctx[propertyKey] = typeof generator === 'function' ?
+                generator(faker_1.faker, ctx) :
+                generator;
+            return {
+                [propertyKey]: ctx[propertyKey],
+                ...result,
+            };
+        }, {});
+        // return properties.reduce(
+        //   (r, p) => ({
+        //     [p.propertyKey]: ctx[p.propertyKey] = typeof p.arg === 'function' ? p.arg(faker, ctx) : p.arg,
+        //     ...r,
+        //   }),
+        //   {},
+        // );
+    }
+}
+exports.DataFactory = DataFactory;

package/src/lib/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./seeder/seeder"), exports);
+tslib_1.__exportStar(require("./seeder/seeder.interface"), exports);
+tslib_1.__exportStar(require("./factory/data.factory"), exports);
+tslib_1.__exportStar(require("./decorators/factory.decorator"), exports);

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

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

package/src/lib/interfaces/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./property-metadata.interface"), exports);
+tslib_1.__exportStar(require("./factory.interface"), exports);

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

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

package/src/lib/interfaces/seeder-module-async-options.interface.js

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

package/src/lib/interfaces/seeder-options-factory.interface.js

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

package/src/lib/seeder/seeder.interface.js

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

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.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.js

@@ -0,0 +1,62 @@
+"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 {
+            await this.seed();
+        }
+    }
+    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() {
+        const seeders = this.getSeederToRun();
+        for (const seeder of seeders) {
+            console.info(`Truncate ${seeder.constructor.name} start`);
+            await seeder.drop(this.options);
+            console.info(`Truncate ${seeder.constructor.name} completed`);
+        }
+    }
+    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);
+            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');
+                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');
+        }
+        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.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());