@flusys/nestjs-core 1.1.0-beta → 2.0.0

package/fesm/seeders/data-generator.js

@@ -1,37 +1,26 @@
 import { faker } from '@faker-js/faker';
+import { detectFieldPattern, detectTypeCategory, getStringLengthCategory, getTokenLength } from './field-patterns';
 /**
  * Data Generator Service
  *
  * Generates realistic sample data based on column metadata.
  * Uses @faker-js/faker for data generation with intelligent field detection.
- *
- * Usage:
- * ```typescript
- * const generator = new DataGenerator();
- * const value = generator.generateValue(columnInfo);
- * const entity = generator.generateEntity(columns);
- * ```
  */ export class DataGenerator {
     /**
    * Generate value for a single column based on its metadata
    */ generateValue(column) {
-        // Skip generated fields
-        if (column.isGenerated) {
-            return undefined;
-        }
+        if (column.isGenerated) return undefined;
         // Handle nullable fields (50% chance of null)
-        if (column.isNullable && faker.datatype.boolean()) {
-            return null;
-        }
+        if (column.isNullable && faker.datatype.boolean()) return null;
         // Check for enum
         if (column.enum && column.enum.length > 0) {
             return faker.helpers.arrayElement(column.enum);
         }
-        // Generate based on column name pattern
-        const nameLower = column.propertyName.toLowerCase();
-        const value = this.generateByName(nameLower, column);
-        if (value !== undefined) {
-            return value;
+        // Generate based on field pattern
+        const pattern = detectFieldPattern(column);
+        if (pattern) {
+            const value = this.generateByPattern(pattern, column);
+            if (value !== undefined) return value;
         }
         // Generate based on column type
         return this.generateByType(column);
@@ -49,143 +38,108 @@ import { faker } from '@faker-js/faker';
         return entity;
     }
     /**
-   * Generate value based on column name patterns
-   */ generateByName(nameLower, column) {
-        // Identity fields (skip, handled by database)
-        if ([
-            'id',
-            'createdat',
-            'updatedat',
-            'deletedat'
-        ].includes(nameLower)) {
-            return undefined;
-        }
-        // Audit fields (skip, handled by interceptors)
-        if ([
-            'createdbyid',
-            'updatedbyid',
-            'deletedbyid'
-        ].includes(nameLower)) {
-            return null;
-        }
-        // Name fields
-        if (nameLower.includes('firstname')) return faker.person.firstName();
-        if (nameLower.includes('lastname')) return faker.person.lastName();
-        if (nameLower.includes('fullname') || nameLower === 'name') {
-            return faker.person.fullName();
-        }
-        // Contact fields
-        if (nameLower.includes('email')) return faker.internet.email().toLowerCase();
-        if (nameLower.includes('phone')) return faker.phone.number();
-        if (nameLower.includes('mobile')) return faker.phone.number();
-        // Location fields
-        if (nameLower.includes('address')) return faker.location.streetAddress();
-        if (nameLower.includes('street')) return faker.location.street();
-        if (nameLower.includes('city')) return faker.location.city();
-        if (nameLower.includes('state')) return faker.location.state();
-        if (nameLower.includes('country')) return faker.location.country();
-        if (nameLower.includes('zipcode') || nameLower.includes('postalcode')) {
-            return faker.location.zipCode();
-        }
-        // URL/Web fields
-        if (nameLower.includes('url')) return faker.internet.url();
-        if (nameLower.includes('website')) return faker.internet.url();
-        if (nameLower.includes('domain')) return faker.internet.domainName();
-        if (nameLower.includes('slug')) {
-            return faker.helpers.slugify(faker.lorem.words(3)).toLowerCase();
-        }
-        // Text fields
-        if (nameLower.includes('description')) return faker.lorem.paragraph();
-        if (nameLower.includes('summary')) return faker.lorem.sentence();
-        if (nameLower.includes('content')) return faker.lorem.paragraphs(3);
-        if (nameLower.includes('title')) return faker.lorem.sentence();
-        // User fields
-        if (nameLower.includes('username')) return faker.internet.username();
-        if (nameLower.includes('password')) return '$2b$12$dummy.hashed.password.value'; // Dummy bcrypt hash
-        // Status/Active fields
-        if (nameLower.includes('isactive')) return faker.datatype.boolean();
-        if (nameLower.includes('isenabled')) return faker.datatype.boolean();
-        if (nameLower.includes('ispublic')) return faker.datatype.boolean();
-        if (nameLower.includes('isverified')) return faker.datatype.boolean();
-        // Date fields
-        if (nameLower.includes('birthdate') || nameLower.includes('dateofbirth')) {
-            return faker.date.birthdate({
-                min: 18,
-                max: 80,
-                mode: 'age'
-            });
-        }
-        if (nameLower.includes('expiresat') || nameLower.includes('expirydate')) {
-            return faker.date.future();
-        }
-        if (nameLower.includes('verifiedat')) {
-            return faker.datatype.boolean() ? faker.date.recent() : null;
-        }
-        // Serial/Order fields
-        if (nameLower.includes('serial') || nameLower.includes('order')) {
-            return faker.number.int({
-                min: 1,
-                max: 100
-            });
-        }
-        // Company/Organization
-        if (nameLower.includes('company') && !nameLower.includes('id')) {
-            return faker.company.name();
+   * Generate value based on detected field pattern
+   */ generateByPattern(pattern, column) {
+        switch(pattern){
+            case 'skip':
+                return undefined;
+            case 'null':
+                return null;
+            case 'boolean':
+                return faker.datatype.boolean();
+            case 'token':
+                return faker.string.alphanumeric(getTokenLength(column));
+            case 'firstName':
+                return faker.person.firstName();
+            case 'lastName':
+                return faker.person.lastName();
+            case 'fullName':
+                return faker.person.fullName();
+            case 'email':
+                return faker.internet.email().toLowerCase();
+            case 'phone':
+                return faker.phone.number();
+            case 'address':
+                return faker.location.streetAddress();
+            case 'street':
+                return faker.location.street();
+            case 'city':
+                return faker.location.city();
+            case 'state':
+                return faker.location.state();
+            case 'country':
+                return faker.location.country();
+            case 'zipCode':
+                return faker.location.zipCode();
+            case 'url':
+                return faker.internet.url();
+            case 'domain':
+                return faker.internet.domainName();
+            case 'slug':
+                return faker.helpers.slugify(faker.lorem.words(3)).toLowerCase();
+            case 'description':
+                return faker.lorem.paragraph();
+            case 'summary':
+                return faker.lorem.sentence();
+            case 'content':
+                return faker.lorem.paragraphs(3);
+            case 'title':
+                return faker.lorem.sentence();
+            case 'username':
+                return faker.internet.username();
+            case 'password':
+                return '$2b$12$dummy.hashed.password.value';
+            case 'birthdate':
+                return faker.date.birthdate({
+                    min: 18,
+                    max: 80,
+                    mode: 'age'
+                });
+            case 'futureDate':
+                return faker.date.future();
+            case 'recentDateOrNull':
+                return faker.datatype.boolean() ? faker.date.recent() : null;
+            case 'serial':
+                return faker.number.int({
+                    min: 1,
+                    max: 100
+                });
+            case 'company':
+                return faker.company.name();
+            default:
+                return undefined;
         }
-        return undefined;
     }
     /**
    * Generate value based on column type
    */ generateByType(column) {
-        const type = column.type.toLowerCase();
-        switch(type){
-            // String types
-            case 'varchar':
-            case 'character varying':
-            case 'text':
+        const category = detectTypeCategory(column.type);
+        switch(category){
             case 'string':
                 return this.generateString(column);
-            // Number types
-            case 'int':
             case 'integer':
-            case 'smallint':
-            case 'bigint':
                 return faker.number.int({
                     min: 1,
                     max: 1000
                 });
             case 'decimal':
-            case 'numeric':
-            case 'float':
-            case 'double':
-            case 'real':
                 return faker.number.float({
                     min: 0,
                     max: 10000,
                     fractionDigits: column.scale || 2
                 });
-            // Boolean
             case 'boolean':
-            case 'bool':
                 return faker.datatype.boolean();
-            // Date/Time
             case 'date':
-                return faker.date.recent({
-                    days: 30
-                });
             case 'timestamp':
-            case 'datetime':
                 return faker.date.recent({
                     days: 30
                 });
             case 'time':
                 return faker.date.recent().toTimeString().split(' ')[0];
-            // UUID
             case 'uuid':
                 return faker.string.uuid();
-            // JSON
             case 'json':
-            case 'jsonb':
                 return {
                     key1: faker.lorem.word(),
                     key2: faker.number.int({
@@ -193,13 +147,11 @@ import { faker } from '@faker-js/faker';
                         max: 100
                     })
                 };
-            // Array
             case 'array':
                 return [
                     faker.lorem.word(),
                     faker.lorem.word()
                 ];
-            // Default
             default:
                 return faker.lorem.word();
         }
@@ -208,42 +160,37 @@ import { faker } from '@faker-js/faker';
    * Generate string value respecting length constraints
    */ generateString(column) {
         const maxLength = typeof column.length === 'number' ? column.length : 255;
-        if (maxLength <= 50) {
-            return faker.lorem.word().substring(0, maxLength);
-        } else if (maxLength <= 255) {
-            return faker.lorem.sentence().substring(0, maxLength);
-        } else {
-            return faker.lorem.paragraph().substring(0, maxLength);
+        const category = getStringLengthCategory(column.length);
+        switch(category){
+            case 'word':
+                return faker.lorem.word().substring(0, maxLength);
+            case 'sentence':
+                return faker.lorem.sentence().substring(0, maxLength);
+            case 'paragraph':
+                return faker.lorem.paragraph().substring(0, maxLength);
         }
     }
     /**
    * Generate related entity ID (for foreign keys)
-   * @param relatedEntities Array of entities to pick from
    */ generateRelationId(relatedEntities) {
-        if (relatedEntities.length === 0) {
-            return null;
-        }
+        if (relatedEntities.length === 0) return null;
         return faker.helpers.arrayElement(relatedEntities).id;
     }
     /**
    * Generate multiple related entity IDs (for many-to-many)
-   * @param relatedEntities Array of entities to pick from
-   * @param min Minimum number of relations
-   * @param max Maximum number of relations
    */ generateRelationIds(relatedEntities, min = 1, max = 3) {
-        if (relatedEntities.length === 0) {
-            return [];
-        }
+        if (relatedEntities.length === 0) return [];
         const count = faker.number.int({
             min,
             max: Math.min(max, relatedEntities.length)
         });
-        const selected = faker.helpers.arrayElements(relatedEntities, count);
-        return selected.map((e)=>e.id);
+        return faker.helpers.arrayElements(relatedEntities, count).map((e)=>e.id);
     }
     constructor(locale = 'en'){
-    // Note: faker v8+ uses faker.locale instead of setLocale
-    // For v8+: faker.locale = locale;
-    // Locale is set globally, not needed for basic usage
+        faker.setDefaultRefDate(new Date());
+        if (locale !== 'en') {
+            // @ts-expect-error - faker locale property access
+            faker.locale = locale;
+        }
     }
 }

package/fesm/seeders/entity-reader.js

@@ -55,23 +55,6 @@ function _define_property(obj, key, value) {
         return this.topologicalSort(graph);
     }
     /**
-   * Check if entity has required columns populated
-   * Used to determine if entity is ready for seeding
-   */ hasRequiredDependencies(entityName, dataSource) {
-        const info = this.getEntityInfo(entityName);
-        for (const relation of info.relations){
-            if (!relation.isNullable && relation.type === 'many-to-one') {
-                const targetRepo = dataSource.getRepository(relation.targetEntity);
-                if (targetRepo) {
-                    // Check if target entity has data
-                    // Note: This is a simplified check, actual implementation may need async
-                    return true;
-                }
-            }
-        }
-        return true;
-    }
-    /**
    * Find entity metadata by name or table name
    */ findEntityMetadata(entityName) {
         return this.getAllEntities().find((e)=>e.name === entityName || e.tableName === entityName);

package/fesm/seeders/field-patterns.js

@@ -0,0 +1,143 @@
+/** System fields that should be skipped during generation */ export const SYSTEM_FIELDS = [
+    'id',
+    'createdAt',
+    'updatedAt',
+    'deletedAt',
+    'createdById',
+    'updatedById',
+    'deletedById'
+];
+/** Audit fields that return null */ export const AUDIT_FIELDS = [
+    'createdbyid',
+    'updatedbyid',
+    'deletedbyid'
+];
+/** Identity fields that are skipped */ export const IDENTITY_FIELDS = [
+    'id',
+    'createdat',
+    'updatedat',
+    'deletedat'
+];
+/** Boolean indicator keywords */ export const BOOLEAN_KEYWORDS = [
+    'verified',
+    'active',
+    'enabled',
+    'public',
+    'readonly',
+    'valid'
+];
+/**
+ * Detect field pattern from column name
+ */ export function detectFieldPattern(column) {
+    const nameLower = column.propertyName.toLowerCase();
+    const typeLower = column.type.toLowerCase();
+    // Identity fields (skip)
+    if (IDENTITY_FIELDS.includes(nameLower)) return 'skip';
+    // Audit fields (null)
+    if (AUDIT_FIELDS.includes(nameLower)) return 'null';
+    // Boolean fields with specific keywords
+    if ((typeLower === 'boolean' || typeLower === 'bool') && BOOLEAN_KEYWORDS.some((k)=>nameLower.includes(k))) {
+        return 'boolean';
+    }
+    // Token fields
+    if (nameLower.includes('token')) return 'token';
+    // Name fields
+    if (nameLower.includes('firstname')) return 'firstName';
+    if (nameLower.includes('lastname')) return 'lastName';
+    if (nameLower.includes('fullname') || nameLower === 'name') return 'fullName';
+    // Contact fields
+    if (nameLower.includes('email') && typeLower !== 'boolean') return 'email';
+    if (nameLower.includes('phone') || nameLower.includes('mobile')) return 'phone';
+    // Location fields
+    if (nameLower.includes('address')) return 'address';
+    if (nameLower.includes('street')) return 'street';
+    if (nameLower.includes('city')) return 'city';
+    if (nameLower.includes('state')) return 'state';
+    if (nameLower.includes('country')) return 'country';
+    if (nameLower.includes('zipcode') || nameLower.includes('postalcode')) return 'zipCode';
+    // URL/Web fields
+    if (nameLower.includes('url') || nameLower.includes('website')) return 'url';
+    if (nameLower.includes('domain')) return 'domain';
+    if (nameLower.includes('slug')) return 'slug';
+    // Text fields
+    if (nameLower.includes('description')) return 'description';
+    if (nameLower.includes('summary')) return 'summary';
+    if (nameLower.includes('content')) return 'content';
+    if (nameLower.includes('title')) return 'title';
+    // User fields
+    if (nameLower.includes('username')) return 'username';
+    if (nameLower.includes('password')) return 'password';
+    // Boolean status fields (fallback)
+    if (nameLower.includes('isactive') || nameLower.includes('isenabled') || nameLower.includes('ispublic') || nameLower.includes('isverified')) {
+        return 'boolean';
+    }
+    // Date fields
+    if (nameLower.includes('birthdate') || nameLower.includes('dateofbirth')) return 'birthdate';
+    if (nameLower.includes('expiresat') || nameLower.includes('expirydate')) return 'futureDate';
+    if (nameLower.includes('verifiedat')) return 'recentDateOrNull';
+    // Serial/Order fields
+    if (nameLower.includes('serial') || nameLower.includes('order')) return 'serial';
+    // Company
+    if (nameLower.includes('company') && !nameLower.includes('id')) return 'company';
+    return undefined;
+}
+/**
+ * Detect column type category
+ */ export function detectTypeCategory(type) {
+    const typeLower = type.toLowerCase();
+    if ([
+        'varchar',
+        'character varying',
+        'text',
+        'string'
+    ].includes(typeLower)) return 'string';
+    if ([
+        'int',
+        'integer',
+        'smallint',
+        'bigint'
+    ].includes(typeLower)) return 'integer';
+    if ([
+        'decimal',
+        'numeric',
+        'float',
+        'double',
+        'real'
+    ].includes(typeLower)) return 'decimal';
+    if ([
+        'boolean',
+        'bool'
+    ].includes(typeLower)) return 'boolean';
+    if (typeLower === 'date') return 'date';
+    if ([
+        'timestamp',
+        'datetime'
+    ].includes(typeLower)) return 'timestamp';
+    if (typeLower === 'time') return 'time';
+    if (typeLower === 'uuid') return 'uuid';
+    if ([
+        'json',
+        'jsonb'
+    ].includes(typeLower)) return 'json';
+    if (typeLower === 'array') return 'array';
+    return 'unknown';
+}
+/**
+ * Get string length category for faker generation
+ */ export function getStringLengthCategory(length) {
+    const maxLength = typeof length === 'number' ? length : 255;
+    if (maxLength <= 50) return 'word';
+    if (maxLength <= 255) return 'sentence';
+    return 'paragraph';
+}
+/**
+ * Check if field is a system field
+ */ export function isSystemField(fieldName) {
+    return SYSTEM_FIELDS.includes(fieldName);
+}
+/**
+ * Get token max length respecting column constraints
+ */ export function getTokenLength(column) {
+    const maxLength = typeof column.length === 'number' ? column.length : 64;
+    return Math.min(maxLength, 32);
+}

package/fesm/seeders/index.js

@@ -1,11 +1,7 @@
-/**
- * Seed System Exports
- *
- * Public API for seed data generation system.
- */ export { BaseSeeder } from './base-seeder';
+export { BaseSeeder } from './base-seeder';
 export { EntityReader, IEntityInfo, IColumnInfo, IRelationInfo } from './entity-reader';
 export { DataGenerator } from './data-generator';
-export { TemplateGenerator } from './template-generator';
 export { SeedRunner, ISeedResult, ISeedOptions, ISeederLogger, defaultLogger } from './seed-runner';
-export { seedConfig, ISeedConfig, getEntityCount, shouldSkipEntity, getSeedingOrder } from './seed-config';
+export { seedConfig, ISeedConfig, getEntityCount, shouldSkipEntity, getSeedingOrder, configureSeedConfig } from './seed-config';
+export { SYSTEM_FIELDS, isSystemField, detectFieldPattern, detectTypeCategory } from './field-patterns';
 export { runSeedCli } from './cli';

package/fesm/seeders/seed-config.js

@@ -1,81 +1,31 @@
-/**
- * Seed Configuration
- *
- * Configuration for seed data generation.
- * Customize record counts, seeding order, and behavior.
- */ /**
- * Default seed configuration
- */ export const seedConfig = {
-    // Default record counts per entity
-    counts: {
-        // Auth entities
-        Company: 10,
-        CompanyBranch: 25,
-        User: 50,
-        // IAM entities
-        Role: 8,
-        Permission: 45,
-        Action: 30,
-        Menu: 20,
-        UserIAMPermission: 50,
-        UserCompanyPermission: 100,
-        // Storage entities
-        StorageConfig: 5,
-        Folder: 20,
-        FileManager: 100
-    },
-    // Entity seeding order (respects FK constraints)
-    // Parent entities must come before child entities
-    order: [
-        // Auth - foundational
-        'Company',
-        'CompanyBranch',
-        'User',
-        // IAM - permissions system
-        'Action',
-        'Role',
-        'Permission',
-        'Menu',
-        'UserIAMPermission',
-        'UserCompanyPermission',
-        // Storage - file system
-        'StorageConfig',
-        'Folder',
-        'FileManager'
-    ],
-    // Skip these entities (system tables, migrations)
+export const seedConfig = {
+    counts: {},
+    order: [],
     skipEntities: [
         'migrations',
         'typeorm_metadata',
         'Migration',
         'Typeorm_Metadata'
     ],
-    // Faker locale (en, ar, es, fr, de, etc.)
     locale: 'en',
-    // Respect soft delete when clearing data
     respectSoftDelete: true
 };
-/**
- * Get count for entity (with default fallback)
- */ export function getEntityCount(entityName, config = seedConfig) {
+export function configureSeedConfig(config) {
+    Object.assign(seedConfig, config);
+}
+export function getEntityCount(entityName, config = seedConfig) {
     return config.counts[entityName] || 10;
 }
-/**
- * Check if entity should be skipped
- */ export function shouldSkipEntity(entityName, config = seedConfig) {
+export function shouldSkipEntity(entityName, config = seedConfig) {
     return config.skipEntities.some((skip)=>skip.toLowerCase() === entityName.toLowerCase());
 }
-/**
- * Get seeding order for entities
- */ export function getSeedingOrder(availableEntities, config = seedConfig) {
+export function getSeedingOrder(availableEntities, config = seedConfig) {
     const ordered = [];
-    // Add entities in configured order
     for (const entityName of config.order){
         if (availableEntities.includes(entityName) && !shouldSkipEntity(entityName, config)) {
             ordered.push(entityName);
         }
     }
-    // Add remaining entities not in order configuration
     for (const entityName of availableEntities){
         if (!ordered.includes(entityName) && !shouldSkipEntity(entityName, config)) {
             ordered.push(entityName);

package/fesm/seeders/seed-runner.js

@@ -61,6 +61,12 @@ import { seedConfig, getEntityCount, shouldSkipEntity, getSeedingOrder } from '.
    */ hasCustomSeeder(entityName) {
         return this.customSeeders.has(entityName);
     }
+    getSeeder(entityName, entity, dataSource, entityInfo, batchSize) {
+        if (this.customSeeders.has(entityName)) {
+            return this.customSeeders.get(entityName);
+        }
+        return new GenericSeeder(dataSource, entity, this.dataGenerator, entityInfo, batchSize);
+    }
     /**
    * Run seeds for all entities
    * @param options Seeding options
@@ -125,13 +131,7 @@ import { seedConfig, getEntityCount, shouldSkipEntity, getSeedingOrder } from '.
             if (!entity) {
                 throw new Error(`Entity ${entityName} not found`);
             }
-            // Get seeder (custom or generic)
-            let seeder;
-            if (this.customSeeders.has(entityName)) {
-                seeder = this.customSeeders.get(entityName);
-            } else {
-                seeder = new GenericSeeder(queryRunner.manager.connection, entity, this.dataGenerator, entityInfo, options.batchSize);
-            }
+            const seeder = this.getSeeder(entityName, entity, queryRunner.manager.connection, entityInfo, options.batchSize);
             // Dry run mode - preview without executing
             if (options.dryRun) {
                 const count = options.count ?? getEntityCount(entityName);
@@ -203,13 +203,7 @@ import { seedConfig, getEntityCount, shouldSkipEntity, getSeedingOrder } from '.
                 if (!entity) {
                     throw new Error(`Entity ${entityName} not found`);
                 }
-                // Use custom seeder if available, otherwise generic
-                let seeder;
-                if (this.customSeeders.has(entityName)) {
-                    seeder = this.customSeeders.get(entityName);
-                } else {
-                    seeder = new GenericSeeder(this.dataSource, entity, this.dataGenerator, this.entityReader.getEntityInfo(entityName));
-                }
+                const seeder = this.getSeeder(entityName, entity, this.dataSource, this.entityReader.getEntityInfo(entityName));
                 const countBefore = await seeder.count(true);
                 // Skip if already empty
                 if (countBefore === 0) {