@flusys/nestjs-core 1.1.0-beta → 1.2.0-rc.1

package/cjs/seeders/template-generator.js

@@ -1,297 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "TemplateGenerator", {
-    enumerable: true,
-    get: function() {
-        return TemplateGenerator;
-    }
-});
-const _fs = /*#__PURE__*/ _interop_require_wildcard(require("fs"));
-const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
-function _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
-    return (_getRequireWildcardCache = function(nodeInterop) {
-        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-    })(nodeInterop);
-}
-function _interop_require_wildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {
-        __proto__: null
-    };
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
-let TemplateGenerator = class TemplateGenerator {
-    /**
-   * Generate seeder file for an entity
-   * @param entityInfo Entity metadata
-   * @param outputDir Output directory for seeder files
-   */ generateSeederFile(entityInfo, outputDir) {
-        const fileName = this.getSeederFileName(entityInfo.name);
-        const filePath = _path.join(outputDir, fileName);
-        const content = this.generateSeederContent(entityInfo);
-        // Ensure directory exists
-        if (!_fs.existsSync(outputDir)) {
-            _fs.mkdirSync(outputDir, {
-                recursive: true
-            });
-        }
-        // Write file
-        _fs.writeFileSync(filePath, content, 'utf-8');
-        return filePath;
-    }
-    /**
-   * Generate index file that exports all seeders
-   * @param entityInfos Array of entity metadata
-   * @param outputDir Output directory
-   */ generateIndexFile(entityInfos, outputDir) {
-        const indexPath = _path.join(outputDir, 'index.ts');
-        const exports1 = entityInfos.map((info)=>{
-            const className = this.getSeederClassName(info.name);
-            const fileName = this.getSeederFileName(info.name).replace('.ts', '');
-            return `export { ${className} } from './${fileName}';`;
-        }).join('\n');
-        _fs.writeFileSync(indexPath, exports1, 'utf-8');
-        return indexPath;
-    }
-    /**
-   * Generate seeder file content
-   */ generateSeederContent(entityInfo) {
-        const className = this.getSeederClassName(entityInfo.name);
-        const imports = this.generateImports(entityInfo);
-        const classContent = this.generateClass(entityInfo, className);
-        return `${imports}\n\n${classContent}\n`;
-    }
-    /**
-   * Generate import statements
-   */ generateImports(entityInfo) {
-        const imports = [
-            `import { DataSource } from 'typeorm';`,
-            `import { faker } from '@faker-js/faker';`,
-            `import { BaseSeeder } from '@flusys/nestjs-core/seeders/base-seeder';`
-        ];
-        // Add entity import (adjust path as needed)
-        const entityImportPath = this.getEntityImportPath(entityInfo.name);
-        imports.push(`import { ${entityInfo.name} } from '${entityImportPath}';`);
-        // Add relation imports
-        const relationEntities = new Set(entityInfo.relations.map((r)=>r.targetEntity));
-        for (const relEntity of relationEntities){
-            const relPath = this.getEntityImportPath(relEntity);
-            imports.push(`import { ${relEntity} } from '${relPath}';`);
-        }
-        return imports.join('\n');
-    }
-    /**
-   * Generate class content
-   */ generateClass(entityInfo, className) {
-        const generateMethod = this.generateGenerateMethod(entityInfo);
-        const relationMethod = this.generateRelationMethod(entityInfo);
-        return `
-/**
- * ${className}
- *
- * Seeder for ${entityInfo.name} entity.
- * Generates sample data for development/testing.
- */
-export class ${className} extends BaseSeeder<${entityInfo.name}> {
-  constructor(dataSource: DataSource) {
-    super(dataSource, ${entityInfo.name});
-  }
-
-${generateMethod}${relationMethod ? '\n\n' + relationMethod : ''}
-}`.trim();
-    }
-    /**
-   * Generate the generate() method
-   */ generateGenerateMethod(entityInfo) {
-        const fields = this.generateFieldAssignments(entityInfo.columns);
-        return `  /**
-   * Generate sample ${entityInfo.name} data
-   * @param count Number of records to generate
-   * @returns Array of created entities
-   */
-  async generate(count: number = 10): Promise<${entityInfo.name}[]> {
-    const entities: ${entityInfo.name}[] = [];
-
-    for (let i = 0; i < count; i++) {
-      const entity = this.repository.create({
-${fields}
-      });
-
-      entities.push(entity);
-    }
-
-    return this.repository.save(entities);
-  }`;
-    }
-    /**
-   * Generate field assignments for entity creation
-   */ generateFieldAssignments(columns) {
-        const assignments = [];
-        for (const column of columns){
-            // Skip system fields
-            if (this.isSystemField(column.propertyName)) {
-                continue;
-            }
-            // Skip foreign keys (handled in relations method)
-            if (column.propertyName.endsWith('Id')) {
-                continue;
-            }
-            const fakerCall = this.getFakerCall(column);
-            const comment = column.isNullable ? ' // Optional' : ' // Required';
-            assignments.push(`        ${column.propertyName}: ${fakerCall},${comment}`);
-        }
-        return assignments.join('\n');
-    }
-    /**
-   * Generate relation handling method if entity has relations
-   */ generateRelationMethod(entityInfo) {
-        const manyToOneRelations = entityInfo.relations.filter((r)=>r.type === 'many-to-one');
-        if (manyToOneRelations.length === 0) {
-            return null;
-        }
-        const relationParams = manyToOneRelations.map((r)=>`${r.propertyName}s: ${r.targetEntity}[]`).join(', ');
-        const relationAssignments = manyToOneRelations.map((r)=>{
-            return `      const random${r.targetEntity} = faker.helpers.arrayElement(${r.propertyName}s);
-      entity.${r.propertyName}Id = random${r.targetEntity}.id;`;
-        }).join('\n');
-        return `  /**
-   * Generate with related entities
-   * @param ${relationParams}
-   * @param count Number of records to generate
-   */
-  async generateWithRelations(${relationParams}, count: number = 10): Promise<${entityInfo.name}[]> {
-    const entities = await this.generate(count);
-
-    for (const entity of entities) {
-${relationAssignments}
-      await this.repository.save(entity);
-    }
-
-    return entities;
-  }`;
-    }
-    /**
-   * Get faker call for column based on its properties
-   */ getFakerCall(column) {
-        const nameLower = column.propertyName.toLowerCase();
-        // Name fields
-        if (nameLower.includes('firstname')) return 'faker.person.firstName()';
-        if (nameLower.includes('lastname')) return 'faker.person.lastName()';
-        if (nameLower === 'name' || nameLower.includes('fullname')) {
-            return 'faker.person.fullName()';
-        }
-        // Contact
-        if (nameLower.includes('email')) return 'faker.internet.email().toLowerCase()';
-        if (nameLower.includes('phone')) return 'faker.phone.number()';
-        // Text
-        if (nameLower.includes('description')) return 'faker.lorem.paragraph()';
-        if (nameLower.includes('content')) return 'faker.lorem.paragraphs(2)';
-        if (nameLower.includes('title')) return 'faker.lorem.sentence()';
-        // URL/Web
-        if (nameLower.includes('slug')) {
-            return "faker.helpers.slugify(faker.lorem.words(3)).toLowerCase()";
-        }
-        if (nameLower.includes('url')) return 'faker.internet.url()';
-        // Status
-        if (nameLower.includes('isactive') || nameLower.includes('isenabled')) {
-            return 'true';
-        }
-        // Type-based
-        const type = column.type.toLowerCase();
-        if (type.includes('bool')) return 'faker.datatype.boolean()';
-        if (type.includes('int') || type.includes('serial')) {
-            return 'faker.number.int({ min: 1, max: 1000 })';
-        }
-        if (type.includes('decimal') || type.includes('float') || type.includes('numeric')) {
-            return 'faker.number.float({ min: 0, max: 1000, precision: 0.01 })';
-        }
-        if (type.includes('date') || type.includes('timestamp')) {
-            return 'faker.date.recent({ days: 30 })';
-        }
-        if (type.includes('uuid')) return 'faker.string.uuid()';
-        if (type.includes('json')) return '{ key: faker.lorem.word() }';
-        // Default string
-        const maxLength = typeof column.length === 'number' ? column.length : 255;
-        if (maxLength <= 50) {
-            return 'faker.lorem.word()';
-        } else if (maxLength <= 255) {
-            return 'faker.lorem.sentence()';
-        } else {
-            return 'faker.lorem.paragraph()';
-        }
-    }
-    /**
-   * Check if field is a system field (should be skipped)
-   */ isSystemField(fieldName) {
-        const systemFields = [
-            'id',
-            'createdAt',
-            'updatedAt',
-            'deletedAt',
-            'createdById',
-            'updatedById',
-            'deletedById'
-        ];
-        return systemFields.includes(fieldName);
-    }
-    /**
-   * Get seeder class name from entity name
-   */ getSeederClassName(entityName) {
-        return `${entityName}Seeder`;
-    }
-    /**
-   * Get seeder file name from entity name
-   */ getSeederFileName(entityName) {
-        const kebab = entityName.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-        return `${kebab}.seeder.ts`;
-    }
-    /**
-   * Get entity import path (adjust based on project structure)
-   */ getEntityImportPath(entityName) {
-        // Try to determine module from entity name
-        // This is a simplified approach - adjust based on actual project structure
-        const nameLower = entityName.toLowerCase();
-        if (nameLower.includes('user') || nameLower.includes('company') || nameLower.includes('branch')) {
-            return `@flusys/nestjs-auth/entities`;
-        }
-        if (nameLower.includes('role') || nameLower.includes('permission') || nameLower.includes('action') || nameLower.includes('menu')) {
-            return `@flusys/nestjs-iam/entities`;
-        }
-        if (nameLower.includes('file') || nameLower.includes('folder') || nameLower.includes('storage')) {
-            return `@flusys/nestjs-storage/entities`;
-        }
-        // Default fallback
-        return `@flusys/nestjs-shared/entities`;
-    }
-};

package/docs/docs.setup.d.ts

@@ -1,3 +0,0 @@
-import { INestApplication } from '@nestjs/common';
-import { IModuleSwaggerOptions } from './docs.config';
-export declare function setupSwaggerDocs(app: INestApplication, ...modules: IModuleSwaggerOptions[]): void;

package/fesm/docs/docs.setup.js

@@ -1,4 +0,0 @@
-import { setupModuleSwaggerDocs } from './docs.config';
-export function setupSwaggerDocs(app, ...modules) {
-    setupModuleSwaggerDocs(app, modules);
-}

package/fesm/seeders/base-seeder.js

@@ -1,110 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-/**
- * Base Seeder Class
- *
- * Abstract base class for all entity seeders.
- * Provides common methods for data generation, clearing, and counting.
- *
- * Usage:
- * ```typescript
- * export class UserSeeder extends BaseSeeder<User> {
- *   constructor(dataSource: DataSource) {
- *     super(dataSource, User);
- *   }
- *
- *   async generate(count: number): Promise<User[]> {
- *     const users: User[] = [];
- *     for (let i = 0; i < count; i++) {
- *       users.push(this.repository.create({
- *         name: faker.person.fullName(),
- *         email: faker.internet.email(),
- *       }));
- *     }
- *     return this.repository.save(users);
- *   }
- * }
- * ```
- */ export class BaseSeeder {
-    /**
-   * Clear all records from the entity table
-   * Respects soft delete if entity has deletedAt column
-   * @param hard If true, perform hard delete (ignore soft delete)
-   */ async clear(hard = false) {
-        const hasSoftDelete = this.metadata.deleteDateColumn !== undefined;
-        if (hard || !hasSoftDelete) {
-            // Hard delete - remove all records
-            await this.repository.clear();
-        } else {
-            // Soft delete - set deletedAt
-            await this.repository.createQueryBuilder().softDelete().where('id IS NOT NULL').execute();
-        }
-    }
-    /**
-   * Get count of existing records
-   * @param includeDeleted If true, count soft-deleted records
-   * @returns Total record count
-   */ async count(includeDeleted = false) {
-        const hasSoftDelete = this.metadata.deleteDateColumn !== undefined;
-        if (hasSoftDelete && !includeDeleted) {
-            return this.repository.count({
-                where: {
-                    deletedAt: null
-                }
-            });
-        }
-        return this.repository.count();
-    }
-    /**
-   * Check if entity has any records
-   * @returns True if no records exist
-   */ async isEmpty() {
-        const total = await this.count();
-        return total === 0;
-    }
-    /**
-   * Get entity name for logging
-   */ getEntityName() {
-        return this.metadata.tableName;
-    }
-    /**
-   * Wrap operation in transaction
-   * @param operation Function to execute in transaction
-   */ async withTransaction(operation) {
-        const queryRunner = this.dataSource.createQueryRunner();
-        await queryRunner.connect();
-        await queryRunner.startTransaction();
-        try {
-            const transactionalRepo = queryRunner.manager.getRepository(this.entity);
-            const result = await operation(transactionalRepo);
-            await queryRunner.commitTransaction();
-            return result;
-        } catch (error) {
-            await queryRunner.rollbackTransaction();
-            throw error;
-        } finally{
-            await queryRunner.release();
-        }
-    }
-    constructor(dataSource, entity){
-        _define_property(this, "dataSource", void 0);
-        _define_property(this, "entity", void 0);
-        _define_property(this, "repository", void 0);
-        _define_property(this, "metadata", void 0);
-        this.dataSource = dataSource;
-        this.entity = entity;
-        this.repository = dataSource.getRepository(entity);
-        this.metadata = this.repository.metadata;
-    }
-}