@flusys/nestjs-core 9.1.1 → 9.2.0

package/fesm/config/index.js

@@ -14,10 +14,20 @@ __webpack_require__.d(__webpack_exports__, {
 ;// CONCATENATED MODULE: ./projects/nestjs-core/src/config/env-config.service.ts
 
 __rspack_external_dotenv.config();
+const DATABASE_TYPES = [
+    'mysql',
+    'postgres',
+    'mariadb',
+    'sqlite',
+    'mssql'
+];
+const DEFAULT_DB_PORTS = {
+    postgres: 5432,
+    mssql: 1433
+};
 let env_config_service_EnvConfigService = class EnvConfigService {
     env;
     restrictedKeys = {
-        FRONTEND_URL: 'getFrontendUrl',
         ALLOW_ORIGINS: 'getOrigins',
         PORT: 'getPort',
         MODE: 'isProduction',
@@ -33,10 +43,13 @@ let env_config_service_EnvConfigService = class EnvConfigService {
     }
     getValue(key, throwOnMissing = true) {
         const value = this.env[key];
-        if (!value && throwOnMissing) {
-            throw new Error(`Config error - missing env.${key}`);
+        if (!value?.trim()) {
+            if (throwOnMissing) {
+                throw new Error(`Config error - missing env.${key}`);
+            }
+            return '';
         }
-        return value ?? '';
+        return value;
     }
     tryGetValue(key, throwOnMissing = false) {
         if (this.restrictedKeys[key]) {
@@ -45,30 +58,39 @@ let env_config_service_EnvConfigService = class EnvConfigService {
         return this.getValue(key, throwOnMissing);
     }
     getNumber(key, throwOnMissing = true) {
-        return Number(this.getValue(key, throwOnMissing));
+        const raw = this.getValue(key, throwOnMissing).trim();
+        if (!raw) return undefined;
+        const value = Number(raw);
+        if (Number.isFinite(value)) return value;
+        if (throwOnMissing) {
+            throw new Error(`Config error - env.${key} must be a number, got "${raw}"`);
+        }
+        return undefined;
     }
     getBoolean(key, throwOnMissing = true) {
-        return this.getValue(key, throwOnMissing).toLowerCase() === 'true';
+        return this.getValue(key, throwOnMissing).trim().toLowerCase() === 'true';
     }
     getPort() {
         return this.getNumber('PORT', false) || 3000;
     }
     isProduction() {
-        return this.getValue('MODE', false).toUpperCase() !== 'DEV';
+        return this.getValue('MODE', false).trim().toUpperCase() !== 'DEV';
     }
     getOrigins() {
-        const origins = this.getValue('ALLOW_ORIGINS');
-        return origins ? origins.split(',').map((o)=>o.trim()) : [];
+        return this.getValue('ALLOW_ORIGINS').split(',').map((o)=>o.trim()).filter(Boolean);
     }
     getTypeOrmConfig() {
-        const type = this.getValue('DB_TYPE', false) || 'mysql';
-        const defaultPort = type === 'postgres' ? 5432 : 3306;
+        const rawType = this.getValue('DB_TYPE', false).trim().toLowerCase() || 'mysql';
+        if (!DATABASE_TYPES.includes(rawType)) {
+            throw new Error(`Config error - unsupported env.DB_TYPE "${rawType}". Expected one of: ${DATABASE_TYPES.join(', ')}`);
+        }
+        const type = rawType;
         return {
             type,
             host: this.getValue('DB_HOST', false) || 'localhost',
-            port: this.getNumber('DB_PORT', false) || defaultPort,
+            port: this.getNumber('DB_PORT', false) || DEFAULT_DB_PORTS[type] || 3306,
             username: this.getValue('DB_USER', false) || 'root',
-            password: this.getValue('DB_PASSWORD', false) || '',
+            password: this.getValue('DB_PASSWORD', false),
             database: this.getValue('DB_NAME', false) || 'flusys_main'
         };
     }
@@ -85,15 +107,15 @@ let env_config_service_EnvConfigService = class EnvConfigService {
     }
     getMailConfig() {
         return {
-            MAIL_FROM: this.getValue('MAIL_FROM', false) || '',
-            MAIL_APP_PASSWORD: this.getValue('MAIL_APP_PASSWORD', false) || ''
+            MAIL_FROM: this.getValue('MAIL_FROM', false),
+            MAIL_APP_PASSWORD: this.getValue('MAIL_APP_PASSWORD', false)
         };
     }
     getTenantId() {
-        return this.getValue('TENANT_ID', false) || null;
+        return this.getValue('TENANT_ID', false).trim() || null;
     }
     useTenantMode() {
-        return this.getValue('USE_TENANT_MODE', false).toLowerCase() === 'true';
+        return this.getBoolean('USE_TENANT_MODE', false);
     }
     getLogConfig() {
         return {
@@ -101,11 +123,11 @@ let env_config_service_EnvConfigService = class EnvConfigService {
             level: this.getValue('LOG_LEVEL', false) || (this.isProduction() ? 'info' : 'debug'),
             maxSize: this.getValue('LOG_MAX_SIZE', false) || '20m',
             maxFiles: this.getValue('LOG_MAX_FILES', false) || '14d',
-            disableHttpLogging: this.getValue('DISABLE_HTTP_LOGGING', false).toLowerCase() === 'true'
+            disableHttpLogging: this.getBoolean('DISABLE_HTTP_LOGGING', false)
         };
     }
     getEnv() {
-        return process.env;
+        return this.env;
     }
 };
 const envConfig = new env_config_service_EnvConfigService(process.env);

package/fesm/docs/index.js

@@ -14,6 +14,23 @@ __webpack_require__.d(__webpack_exports__, {
 
 ;// CONCATENATED MODULE: ./projects/nestjs-core/src/docs/docs.config.ts
 
+const HTTP_METHODS = new Set([
+    'get',
+    'put',
+    'post',
+    'delete',
+    'options',
+    'head',
+    'patch',
+    'trace'
+]);
+function escapeRegex(value) {
+    return value.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+}
+function pathMatchesPattern(path, pattern) {
+    const regexPattern = pattern.split('**').map((part)=>part.split('*').map(escapeRegex).join('[^/]+')).join('.*');
+    return new RegExp(`^${regexPattern}$`).test(path);
+}
 function filterSchemaProperties(document, exclusions) {
     if (!exclusions?.length || !document.components?.schemas) {
         return document;
@@ -23,23 +40,22 @@ function filterSchemaProperties(document, exclusions) {
     };
     for (const exclusion of exclusions){
         const schema = schemas[exclusion.schemaName];
-        if (schema && typeof schema === 'object' && 'properties' in schema) {
-            const filteredProperties = {
-                ...schema.properties
-            };
-            for (const prop of exclusion.properties){
-                delete filteredProperties[prop];
-            }
-            // Also remove from required array if present
-            const filteredRequired = schema.required?.filter((r)=>!exclusion.properties.includes(r));
-            schemas[exclusion.schemaName] = {
-                ...schema,
-                properties: filteredProperties,
-                ...filteredRequired?.length ? {
-                    required: filteredRequired
-                } : {}
-            };
+        if (!schema || typeof schema !== 'object' || !('properties' in schema)) continue;
+        const properties = {
+            ...schema.properties
+        };
+        for (const prop of exclusion.properties){
+            delete properties[prop];
         }
+        const { required, ...rest } = schema;
+        const filteredRequired = Array.isArray(required) ? required.filter((r)=>!exclusion.properties.includes(r)) : undefined;
+        schemas[exclusion.schemaName] = {
+            ...rest,
+            properties,
+            ...filteredRequired?.length ? {
+                required: filteredRequired
+            } : {}
+        };
     }
     return {
         ...document,
@@ -49,183 +65,98 @@ function filterSchemaProperties(document, exclusions) {
         }
     };
 }
-function filterQueryParameters(document, exclusions) {
+function transformMatchingOperations(document, exclusions, transform) {
     if (!exclusions?.length || !document.paths) {
         return document;
     }
-    const filteredPaths = {};
+    const paths = {};
     for (const [path, pathItem] of Object.entries(document.paths)){
-        const filteredPathItem = {};
+        const nextPathItem = {};
         for (const [method, operation] of Object.entries(pathItem)){
-            // Skip non-operation properties
-            if (!operation || typeof operation !== 'object') {
-                filteredPathItem[method] = operation;
-                continue;
-            }
-            // Check if this endpoint matches any exclusion pattern
-            const matchingExclusions = exclusions.filter((exclusion)=>{
-                const pathMatches = pathMatchesPattern(path, exclusion.pathPattern);
-                const methodMatches = !exclusion.method || exclusion.method === method;
-                return pathMatches && methodMatches;
-            });
-            if (matchingExclusions.length > 0) {
-                // Collect all parameters to exclude
-                const paramsToExclude = new Set();
-                matchingExclusions.forEach((exclusion)=>{
-                    exclusion.parameters.forEach((param)=>paramsToExclude.add(param));
-                });
-                // Filter out excluded query parameters
-                const filteredOperation = {
-                    ...operation
-                };
-                if (Array.isArray(filteredOperation.parameters)) {
-                    filteredOperation.parameters = filteredOperation.parameters.filter((param)=>{
-                        return !(param.in === 'query' && paramsToExclude.has(param.name));
-                    });
-                }
-                filteredPathItem[method] = filteredOperation;
-            } else {
-                filteredPathItem[method] = operation;
-            }
+            const matching = operation && typeof operation === 'object' && HTTP_METHODS.has(method) ? exclusions.filter((exclusion)=>pathMatchesPattern(path, exclusion.pathPattern) && (!exclusion.method || exclusion.method.toLowerCase() === method)) : [];
+            nextPathItem[method] = matching.length ? transform(operation, matching) : operation;
         }
-        filteredPaths[path] = filteredPathItem;
+        paths[path] = nextPathItem;
     }
     return {
         ...document,
-        paths: filteredPaths
+        paths
     };
 }
+function filterQueryParameters(document, exclusions) {
+    return transformMatchingOperations(document, exclusions, (operation, matching)=>{
+        const excluded = new Set(matching.flatMap((exclusion)=>exclusion.parameters));
+        if (!Array.isArray(operation.parameters)) return {
+            ...operation
+        };
+        return {
+            ...operation,
+            parameters: operation.parameters.filter((param)=>!(param.in === 'query' && excluded.has(param.name)))
+        };
+    });
+}
 function filterExamples(document, exclusions) {
-    if (!exclusions?.length || !document.paths) {
-        return document;
-    }
-    const filteredPaths = {};
-    for (const [path, pathItem] of Object.entries(document.paths)){
-        const filteredPathItem = {};
-        for (const [method, operation] of Object.entries(pathItem)){
-            // Skip non-operation properties
-            if (!operation || typeof operation !== 'object') {
-                filteredPathItem[method] = operation;
-                continue;
-            }
-            // Check if this endpoint matches any exclusion pattern
-            const matchingExclusions = exclusions.filter((exclusion)=>{
-                const pathMatches = pathMatchesPattern(path, exclusion.pathPattern);
-                const methodMatches = !exclusion.method || exclusion.method === method;
-                return pathMatches && methodMatches;
-            });
-            if (matchingExclusions.length > 0) {
-                // Collect all examples to exclude
-                const examplesToExclude = new Set();
-                matchingExclusions.forEach((exclusion)=>{
-                    exclusion.examples.forEach((example)=>examplesToExclude.add(example));
-                });
-                // Deep clone the operation to avoid mutating original
-                const filteredOperation = JSON.parse(JSON.stringify(operation));
-                // Filter examples from responses
-                if (filteredOperation.responses) {
-                    for (const [statusCode, response] of Object.entries(filteredOperation.responses)){
-                        const responseObj = response;
-                        if (responseObj?.content) {
-                            const content = responseObj.content;
-                            for (const [mediaType, mediaTypeObj] of Object.entries(content)){
-                                const media = mediaTypeObj;
-                                if (media?.examples && typeof media.examples === 'object') {
-                                    const examples = media.examples;
-                                    for (const exampleName of examplesToExclude){
-                                        delete examples[exampleName];
-                                    }
-                                }
-                            }
-                        }
+    return transformMatchingOperations(document, exclusions, (operation, matching)=>{
+        const excluded = new Set(matching.flatMap((exclusion)=>exclusion.examples));
+        const cloned = structuredClone(operation);
+        for (const response of Object.values(cloned.responses ?? {})){
+            for (const media of Object.values(response?.content ?? {})){
+                if (media?.examples && typeof media.examples === 'object') {
+                    for (const name of excluded){
+                        delete media.examples[name];
                     }
                 }
-                filteredPathItem[method] = filteredOperation;
-            } else {
-                filteredPathItem[method] = operation;
             }
         }
-        filteredPaths[path] = filteredPathItem;
-    }
-    return {
-        ...document,
-        paths: filteredPaths
-    };
-}
-function pathMatchesPattern(path, pattern) {
-    // Convert wildcard pattern to regex
-    const regexPattern = pattern.replace(/\*/g, '[^/]+') // * matches any characters except /
-    .replace(/\*\*/g, '.*'); // ** matches any characters including /
-    const regex = new RegExp(`^${regexPattern}$`);
-    return regex.test(path);
+        return cloned;
+    });
 }
 function filterPaths(document, excludePaths) {
     if (!excludePaths?.length || !document.paths) {
         return document;
     }
-    const filteredPaths = {};
+    const paths = {};
     for (const [path, pathItem] of Object.entries(document.paths)){
-        const isExcluded = excludePaths.some((pattern)=>pathMatchesPattern(path, pattern));
-        if (!isExcluded) {
-            filteredPaths[path] = pathItem;
+        if (!excludePaths.some((pattern)=>pathMatchesPattern(path, pattern))) {
+            paths[path] = pathItem;
         }
     }
     return {
         ...document,
-        paths: filteredPaths
+        paths
     };
 }
 function filterDocumentByTags(document, excludeTags) {
-    if (!excludeTags?.length) {
+    if (!excludeTags?.length || !document.paths) {
         return document;
     }
     const excludeTagsSet = new Set(excludeTags.map((tag)=>tag.toLowerCase()));
-    // Filter out paths that have any of the excluded tags
-    const filteredPaths = {};
+    const paths = {};
     for (const [path, pathItem] of Object.entries(document.paths)){
-        const filteredPathItem = {};
+        const nextPathItem = {};
         for (const [method, operation] of Object.entries(pathItem)){
-            // Skip non-operation properties like 'parameters'
-            if (!operation || typeof operation !== 'object' || !('tags' in operation)) {
-                filteredPathItem[method] = operation;
-                continue;
-            }
-            const operationTags = operation.tags || [];
-            const hasExcludedTag = operationTags.some((tag)=>excludeTagsSet.has(tag.toLowerCase()));
-            if (!hasExcludedTag) {
-                filteredPathItem[method] = operation;
+            const tags = operation && typeof operation === 'object' ? operation.tags : undefined;
+            const excluded = Array.isArray(tags) && tags.some((tag)=>excludeTagsSet.has(String(tag).toLowerCase()));
+            if (!excluded) {
+                nextPathItem[method] = operation;
             }
         }
-        // Only include path if it has at least one operation
-        const hasOperations = Object.keys(filteredPathItem).some((key)=>[
-                'get',
-                'post',
-                'put',
-                'patch',
-                'delete',
-                'options',
-                'head'
-            ].includes(key));
-        if (hasOperations) {
-            filteredPaths[path] = filteredPathItem;
+        if (Object.keys(nextPathItem).some((key)=>HTTP_METHODS.has(key))) {
+            paths[path] = nextPathItem;
         }
     }
-    // Filter out excluded tags from the tags array
-    const filteredTags = document.tags?.filter((tag)=>!excludeTagsSet.has(tag.name.toLowerCase()));
     return {
         ...document,
-        paths: filteredPaths,
-        tags: filteredTags
+        paths,
+        tags: document.tags?.filter((tag)=>!excludeTagsSet.has(tag.name.toLowerCase()))
     };
 }
 function setupModuleSwaggerDocs(app, configs) {
     configs.forEach((config)=>{
         const builder = new DocumentBuilder().setTitle(config.title).setDescription(config.description).setVersion(config.version || '1.0');
-        // Add bearer auth
         if (config.bearerAuth) {
             builder.addBearerAuth();
         }
-        // Add custom global headers
         if (config.globalHeaders?.length) {
             config.globalHeaders.forEach((header)=>{
                 builder.addGlobalParameters({
@@ -240,31 +171,15 @@ function setupModuleSwaggerDocs(app, configs) {
                 });
             });
         }
-        // Only filter by modules if specified
         const createDocOptions = config.modules?.length ? {
             include: config.modules
         } : {};
         let document = SwaggerModule.createDocument(app, builder.build(), createDocOptions);
-        // Filter out excluded paths
-        if (config.excludePaths?.length) {
-            document = filterPaths(document, config.excludePaths);
-        }
-        // Filter out excluded tags
-        if (config.excludeTags?.length) {
-            document = filterDocumentByTags(document, config.excludeTags);
-        }
-        // Filter out excluded schema properties
-        if (config.excludeSchemaProperties?.length) {
-            document = filterSchemaProperties(document, config.excludeSchemaProperties);
-        }
-        // Filter out excluded query parameters
-        if (config.excludeQueryParameters?.length) {
-            document = filterQueryParameters(document, config.excludeQueryParameters);
-        }
-        // Filter out excluded examples
-        if (config.excludeExamples?.length) {
-            document = filterExamples(document, config.excludeExamples);
-        }
+        document = filterPaths(document, config.excludePaths ?? []);
+        document = filterDocumentByTags(document, config.excludeTags ?? []);
+        document = filterSchemaProperties(document, config.excludeSchemaProperties ?? []);
+        document = filterQueryParameters(document, config.excludeQueryParameters ?? []);
+        document = filterExamples(document, config.excludeExamples ?? []);
         SwaggerModule.setup(config.path, app, document);
     });
 }

package/fesm/index.js

@@ -62,7 +62,7 @@ __webpack_require__.d(__webpack_exports__, {
 256(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 /* import */ var _datasource_factory_js__rspack_import_0 = __webpack_require__(193);
 /* import */ var _migration_cli_js__rspack_import_1 = __webpack_require__(164);
-/* import */ var _migration_runner_js__rspack_import_2 = __webpack_require__(654);
+/* import */ var _migration_runner_js__rspack_import_2 = __webpack_require__(989);
 
 
 

package/fesm/migration/index.js

@@ -4,7 +4,7 @@ export const __webpack_modules__ = {
 256(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 /* import */ var _datasource_factory_js__rspack_import_0 = __webpack_require__(193);
 /* import */ var _migration_cli_js__rspack_import_1 = __webpack_require__(164);
-/* import */ var _migration_runner_js__rspack_import_2 = __webpack_require__(654);
+/* import */ var _migration_runner_js__rspack_import_2 = __webpack_require__(989);
 
 
 

package/fesm/utils/index.js

@@ -2,9 +2,7 @@ export const __rspack_esm_id = 152;
 export const __rspack_esm_ids = [152];
 export const __webpack_modules__ = {
 722(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/**
- * Build DataSource options from database config
- */ function buildDataSourceOptions(config, entities, migrationsPath, migrationsTableName = 'migrations') {
+function buildDataSourceOptions(config, entities, migrationsPath, migrationsTableName = 'migrations') {
     return {
         type: config.type,
         host: config.host,
@@ -20,24 +18,20 @@ export const __webpack_modules__ = {
         synchronize: false
     };
 }
-/**
- * Get migration folder path for a tenant
- */ function getMigrationsFolderPath(basePath, tenantId) {
+function getMigrationsFolderPath(basePath, tenantId) {
     const folder = tenantId || 'default';
     return `${basePath}/${folder}`;
 }
-/**
- * Get migrations glob pattern for a tenant
- */ function getMigrationsGlobPattern(basePath, tenantId) {
+function getMigrationsGlobPattern(basePath, tenantId) {
     return `${getMigrationsFolderPath(basePath, tenantId)}/*{.ts,.js}`;
 }
-/**
- * Get database and config for a tenant (or default)
- */ function getDatabaseForTenant(config, tenantId) {
-    if (tenantId && config.tenants) {
-        const tenant = config.tenants.find((t)=>t.id === tenantId);
+function getDatabaseForTenant(config, tenantId) {
+    if (tenantId) {
+        const tenants = config.tenants ?? [];
+        const tenant = tenants.find((t)=>t.id === tenantId);
         if (!tenant) {
-            throw new Error(`Tenant '${tenantId}' not found. Available: ${config.tenants.map((t)=>t.id).join(', ')}`);
+            const available = tenants.map((t)=>t.id).join(', ') || 'none';
+            throw new Error(`Tenant '${tenantId}' not found. Available: ${available}`);
         }
         return {
             database: tenant.database,
@@ -45,21 +39,20 @@ export const __webpack_modules__ = {
             tenantConfig: tenant
         };
     }
-    // Default config - use bootstrapAppConfig for feature flags
     const defaultTenantConfig = {
         id: 'default',
         database: config.defaultDatabaseConfig.database || 'default',
         enableCompanyFeature: config.bootstrapAppConfig?.enableCompanyFeature ?? false,
-        permissionMode: config.bootstrapAppConfig?.permissionMode ?? 'FULL'
+        permissionMode: config.bootstrapAppConfig?.permissionMode ?? 'FULL',
+        enableEmailVerification: config.bootstrapAppConfig?.enableEmailVerification,
+        enableSignUp: config.bootstrapAppConfig?.enableSignUp
     };
     return {
         database: defaultTenantConfig.database,
         tenantConfig: defaultTenantConfig
     };
 }
-/**
- * Resolve full connection details for a tenant.
- */ function resolveDatabaseConnection(config, tenantId) {
+function resolveDatabaseConnection(config, tenantId) {
     const { database, tenant } = getDatabaseForTenant(config, tenantId);
     return tenant ? {
         ...config.defaultDatabaseConfig,
@@ -73,17 +66,13 @@ export const __webpack_modules__ = {
         database
     };
 }
-/**
- * Resolve entities based on tenant config
- */ function resolveEntities(config, tenantConfig) {
+function resolveEntities(config, tenantConfig) {
     if (typeof config.entities === 'function') {
         return config.entities(tenantConfig);
     }
     return config.entities;
 }
-/**
- * Get active tenants from config
- */ function getActiveTenants(config) {
+function getActiveTenants(config) {
     return config.tenants || [];
 }
 

package/migration/migration.runner.d.ts

@@ -1,4 +1,5 @@
 import { type IMigrationConfig, type IMigrationResult } from '../interfaces/migration.interface.js';
+export declare function assertValidMigrationName(name: string): void;
 export declare function ensureMigrationsFolder(basePath: string, tenantId?: string): string;
 export declare function generateMigration(config: IMigrationConfig, name: string, tenantId?: string, datasourcePath?: string): Promise<void>;
 export declare function stripIgnoredTableStatements(folder: string, name: string, ignoreTable: (tableName: string) => boolean): number;
@@ -6,4 +7,12 @@ export declare function runMigrations(config: IMigrationConfig, tenantId?: strin
 export declare function revertMigration(config: IMigrationConfig, tenantId?: string): Promise<IMigrationResult>;
 export declare function resetDatabase(config: IMigrationConfig, tenantId?: string): Promise<IMigrationResult>;
 export declare function migrationStatus(config: IMigrationConfig, tenantId?: string): Promise<IMigrationResult>;
-export declare function runForAllTenants(config: IMigrationConfig, command: 'run' | 'revert' | 'status'): Promise<IMigrationResult[]>;
+declare const TENANT_ACTIONS: {
+    readonly run: typeof runMigrations;
+    readonly revert: typeof revertMigration;
+    readonly status: typeof migrationStatus;
+};
+export type TenantMigrationAction = keyof typeof TENANT_ACTIONS;
+export declare function isTenantMigrationAction(action: string): action is TenantMigrationAction;
+export declare function runForAllTenants(config: IMigrationConfig, command: TenantMigrationAction): Promise<IMigrationResult[]>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-core",
-  "version": "9.1.1",
+  "version": "9.2.0",
   "description": "Core types, interfaces, and constants for Flusys NestJS packages",
   "type": "module",
   "main": "./fesm/index.js",
@@ -53,7 +53,6 @@
     }
   },
   "peerDependencies": {
-    "@faker-js/faker": "^10.0.0",
     "@nestjs/common": "^12.0.0",
     "@nestjs/config": "^12.0.0",
     "@nestjs/core": "^12.0.0",