@flusys/nestjs-core 4.1.0 → 5.0.0

package/fesm/seeders/data-generator.js

@@ -1,216 +0,0 @@
-import { faker } from '@faker-js/faker';
-import { detectFieldPattern, detectTypeCategory, getStringLengthCategory, getTokenLength } from './field-patterns';
-export class DataGenerator {
-    generateValue(column) {
-        if (column.isGenerated) return undefined;
-        // Handle nullable fields (50% chance of 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 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);
-    }
-    generateEntity(columns) {
-        const entity = {};
-        for (const column of columns){
-            const value = this.generateValue(column);
-            if (value !== undefined) {
-                entity[column.propertyName] = value;
-            }
-        }
-        return entity;
-    }
-    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();
-            case 'emailProvider':
-                return faker.helpers.arrayElement([
-                    'smtp',
-                    'sendgrid',
-                    'mailgun',
-                    'ses',
-                    'postmark'
-                ]);
-            case 'formAccessType':
-                return faker.helpers.arrayElement([
-                    'public',
-                    'authenticated',
-                    'permission'
-                ]);
-            case 'notificationType':
-                return faker.helpers.arrayElement([
-                    'INFO',
-                    'SUCCESS',
-                    'WARNING',
-                    'ERROR'
-                ]);
-            case 'languageCode':
-                return faker.helpers.arrayElement([
-                    'en',
-                    'ar',
-                    'bn',
-                    'es',
-                    'fr',
-                    'de',
-                    'zh',
-                    'ja',
-                    'ko',
-                    'hi'
-                ]);
-            case 'languageDirection':
-                return faker.helpers.arrayElement([
-                    'ltr',
-                    'rtl'
-                ]);
-            default:
-                return undefined;
-        }
-    }
-    generateByType(column) {
-        const category = detectTypeCategory(column.type);
-        switch(category){
-            case 'string':
-                return this.generateString(column);
-            case 'integer':
-                return faker.number.int({
-                    min: 1,
-                    max: 1000
-                });
-            case 'decimal':
-                return faker.number.float({
-                    min: 0,
-                    max: 10000,
-                    fractionDigits: column.scale || 2
-                });
-            case 'boolean':
-                return faker.datatype.boolean();
-            case 'date':
-            case 'timestamp':
-                return faker.date.recent({
-                    days: 30
-                });
-            case 'time':
-                return faker.date.recent().toTimeString().split(' ')[0];
-            case 'uuid':
-                return faker.string.uuid();
-            case 'json':
-                return {
-                    key1: faker.lorem.word(),
-                    key2: faker.number.int({
-                        min: 1,
-                        max: 100
-                    })
-                };
-            case 'array':
-                return [
-                    faker.lorem.word(),
-                    faker.lorem.word()
-                ];
-            default:
-                return faker.lorem.word();
-        }
-    }
-    generateString(column) {
-        const maxLength = typeof column.length === 'number' ? column.length : 255;
-        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);
-        }
-    }
-    generateRelationId(relatedEntities) {
-        if (relatedEntities.length === 0) return null;
-        return faker.helpers.arrayElement(relatedEntities).id;
-    }
-    generateRelationIds(relatedEntities, min = 1, max = 3) {
-        if (relatedEntities.length === 0) return [];
-        const count = faker.number.int({
-            min,
-            max: Math.min(max, relatedEntities.length)
-        });
-        return faker.helpers.arrayElements(relatedEntities, count).map((e)=>e.id);
-    }
-    constructor(locale = 'en'){
-        faker.setDefaultRefDate(new Date());
-        if (locale !== 'en') {
-            // @ts-expect-error - faker locale property access
-            faker.locale = locale;
-        }
-    }
-}

package/fesm/seeders/entity-reader.js

@@ -1,119 +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;
-}
-export class EntityReader {
-    getAllEntities() {
-        return this.dataSource.entityMetadatas;
-    }
-    getEntityInfo(entityName) {
-        const metadata = this.findEntityMetadata(entityName);
-        if (!metadata) {
-            throw new Error(`Entity ${entityName} not found in DataSource`);
-        }
-        return {
-            name: metadata.name,
-            tableName: metadata.tableName,
-            columns: this.extractColumns(metadata),
-            relations: this.extractRelations(metadata),
-            hasSoftDelete: metadata.deleteDateColumn !== undefined,
-            hasCompany: this.hasCompanyColumn(metadata)
-        };
-    }
-    getSeedingOrder(skipEntities = []) {
-        const entities = this.getAllEntities().filter((e)=>!skipEntities.includes(e.name) && !skipEntities.includes(e.tableName));
-        const graph = this.buildDependencyGraph(entities);
-        return this.topologicalSort(graph);
-    }
-    findEntityMetadata(entityName) {
-        return this.getAllEntities().find((e)=>e.name === entityName || e.tableName === entityName);
-    }
-    extractColumns(metadata) {
-        return metadata.columns.map((col)=>({
-                name: col.databaseName,
-                propertyName: col.propertyName,
-                type: this.getColumnTypeString(col.type),
-                length: col.length,
-                isNullable: col.isNullable,
-                isUnique: 'isUnique' in col ? col.isUnique === true : false,
-                isPrimary: col.isPrimary,
-                isGenerated: col.isGenerated,
-                default: col.default,
-                enum: col.enum ? Object.values(col.enum) : undefined,
-                precision: col.precision ?? undefined,
-                scale: col.scale ?? undefined
-            }));
-    }
-    extractRelations(metadata) {
-        return metadata.relations.map((rel)=>({
-                propertyName: rel.propertyName,
-                type: rel.relationType,
-                targetEntity: rel.inverseEntityMetadata.name,
-                isNullable: rel.isNullable,
-                joinColumnName: rel.joinColumns?.[0]?.databaseName
-            }));
-    }
-    hasCompanyColumn(metadata) {
-        return metadata.columns.some((col)=>col.propertyName === 'companyId' || col.databaseName === 'company_id');
-    }
-    getColumnTypeString(type) {
-        if (typeof type === 'string') {
-            return type;
-        }
-        if (typeof type === 'function') {
-            return type.name.toLowerCase();
-        }
-        return 'unknown';
-    }
-    buildDependencyGraph(entities) {
-        const graph = new Map();
-        for (const entity of entities){
-            const dependencies = [];
-            for (const relation of entity.relations){
-                if (relation.relationType === 'many-to-one' && !relation.isNullable) {
-                    dependencies.push(relation.inverseEntityMetadata.name);
-                }
-            }
-            graph.set(entity.name, dependencies);
-        }
-        return graph;
-    }
-    topologicalSort(graph) {
-        const sorted = [];
-        const visited = new Set();
-        const visiting = new Set();
-        const visit = (node)=>{
-            if (visited.has(node)) return;
-            if (visiting.has(node)) {
-                throw new Error(`Circular dependency detected involving ${node}`);
-            }
-            visiting.add(node);
-            const dependencies = graph.get(node) || [];
-            for (const dep of dependencies){
-                if (graph.has(dep)) {
-                    visit(dep);
-                }
-            }
-            visiting.delete(node);
-            visited.add(node);
-            sorted.push(node);
-        };
-        for (const node of graph.keys()){
-            visit(node);
-        }
-        return sorted;
-    }
-    constructor(dataSource){
-        _define_property(this, "dataSource", void 0);
-        this.dataSource = dataSource;
-    }
-}

package/fesm/seeders/field-patterns.js

@@ -1,143 +0,0 @@
-export const SYSTEM_FIELDS = [
-    'id',
-    'createdAt',
-    'updatedAt',
-    'deletedAt',
-    'createdById',
-    'updatedById',
-    'deletedById'
-];
-export const AUDIT_FIELDS = [
-    'createdbyid',
-    'updatedbyid',
-    'deletedbyid'
-];
-export const IDENTITY_FIELDS = [
-    'id',
-    'createdat',
-    'updatedat',
-    'deletedat'
-];
-export const BOOLEAN_KEYWORDS = [
-    'verified',
-    'active',
-    'enabled',
-    'public',
-    'readonly',
-    'valid'
-];
-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';
-    // Email provider type
-    if (nameLower === 'provider' || nameLower === 'emailprovider') return 'emailProvider';
-    // Form access type
-    if (nameLower === 'accesstype' || nameLower === 'access_type') return 'formAccessType';
-    // Notification type (short varchar for type fields)
-    if (nameLower === 'type') return 'notificationType';
-    // Language code (short varchar for language codes like 'en', 'ar', 'bn')
-    if (nameLower === 'code') return 'languageCode';
-    // Language direction (ltr/rtl)
-    if (nameLower === 'direction') return 'languageDirection';
-    return undefined;
-}
-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';
-}
-export function getStringLengthCategory(length) {
-    const maxLength = typeof length === 'number' ? length : 255;
-    if (maxLength <= 50) return 'word';
-    if (maxLength <= 255) return 'sentence';
-    return 'paragraph';
-}
-export function isSystemField(fieldName) {
-    return SYSTEM_FIELDS.includes(fieldName);
-}
-export function getTokenLength(column) {
-    const maxLength = typeof column.length === 'number' ? column.length : 64;
-    return Math.min(maxLength, 32);
-}

package/fesm/seeders/index.js

@@ -1,7 +0,0 @@
-export { BaseSeeder } from './base-seeder';
-export { EntityReader, IEntityInfo, IColumnInfo, IRelationInfo } from './entity-reader';
-export { DataGenerator } from './data-generator';
-export { SeedRunner, ISeedResult, ISeedOptions, ISeederLogger, defaultLogger } from './seed-runner';
-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,35 +0,0 @@
-export const seedConfig = {
-    counts: {},
-    order: [],
-    skipEntities: [
-        'migrations',
-        'typeorm_metadata',
-        'Migration',
-        'Typeorm_Metadata'
-    ],
-    locale: 'en',
-    respectSoftDelete: true
-};
-export function configureSeedConfig(config) {
-    Object.assign(seedConfig, config);
-}
-export function getEntityCount(entityName, config = seedConfig) {
-    return config.counts[entityName] || 10;
-}
-export function shouldSkipEntity(entityName, config = seedConfig) {
-    return config.skipEntities.some((skip)=>skip.toLowerCase() === entityName.toLowerCase());
-}
-export function getSeedingOrder(availableEntities, config = seedConfig) {
-    const ordered = [];
-    for (const entityName of config.order){
-        if (availableEntities.includes(entityName) && !shouldSkipEntity(entityName, config)) {
-            ordered.push(entityName);
-        }
-    }
-    for (const entityName of availableEntities){
-        if (!ordered.includes(entityName) && !shouldSkipEntity(entityName, config)) {
-            ordered.push(entityName);
-        }
-    }
-    return ordered;
-}