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

package/cjs/migration/migration.runner.js

@@ -75,6 +75,36 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+function getLabel(tenantId) {
+    return tenantId ? `[${tenantId}]` : '[default]';
+}
+async function withDataSource(config, tenantId, operation) {
+    const { database } = (0, _utils.getDatabaseForTenant)(config, tenantId);
+    const label = getLabel(tenantId);
+    try {
+        const ds = await (0, _datasourcefactory.initializeDataSource)({
+            config,
+            tenantId
+        });
+        const partial = await operation(ds, label);
+        await ds.destroy();
+        return {
+            tenantId,
+            database,
+            success: true,
+            ...partial
+        };
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`${label} ✗ Failed: ${errorMessage}`);
+        return {
+            tenantId,
+            database,
+            success: false,
+            error: errorMessage
+        };
+    }
+}
 function ensureMigrationsFolder(basePath, tenantId) {
     const folder = (0, _utils.getMigrationsFolderPath)(basePath, tenantId);
     if (!_fs.existsSync(folder)) {
@@ -116,15 +146,8 @@ function findDatasourcePath() {
     throw new Error('Could not find datasource file. Specify with --datasource=<path>');
 }
 async function runMigrations(config, tenantId) {
-    const { database } = (0, _utils.getDatabaseForTenant)(config, tenantId);
-    const label = tenantId ? `[${tenantId}]` : '[default]';
-    try {
-        const ds = await (0, _datasourcefactory.initializeDataSource)({
-            config,
-            tenantId
-        });
+    return withDataSource(config, tenantId, async (ds, label)=>{
         const migrations = await ds.runMigrations();
-        await ds.destroy();
         if (migrations.length === 0) {
             console.log(`${label} No pending migrations.`);
         } else {
@@ -132,78 +155,27 @@ async function runMigrations(config, tenantId) {
             migrations.forEach((m)=>console.log(`   - ${m.name}`));
         }
         return {
-            tenantId,
-            database,
-            success: true,
             migrationsRun: migrations.map((m)=>m.name)
         };
-    } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(`${label} ✗ Failed: ${errorMessage}`);
-        return {
-            tenantId,
-            database,
-            success: false,
-            error: errorMessage
-        };
-    }
+    });
 }
 async function revertMigration(config, tenantId) {
-    const { database } = (0, _utils.getDatabaseForTenant)(config, tenantId);
-    const label = tenantId ? `[${tenantId}]` : '[default]';
-    try {
-        const ds = await (0, _datasourcefactory.initializeDataSource)({
-            config,
-            tenantId
-        });
+    return withDataSource(config, tenantId, async (ds, label)=>{
         await ds.undoLastMigration();
-        await ds.destroy();
         console.log(`${label} ✓ Reverted!`);
-        return {
-            tenantId,
-            database,
-            success: true
-        };
-    } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(`${label} ✗ Failed: ${errorMessage}`);
-        return {
-            tenantId,
-            database,
-            success: false,
-            error: errorMessage
-        };
-    }
+        return {};
+    });
 }
 async function migrationStatus(config, tenantId) {
-    const { database } = (0, _utils.getDatabaseForTenant)(config, tenantId);
-    const label = tenantId ? `[${tenantId}]` : '[default]';
-    try {
-        const ds = await (0, _datasourcefactory.initializeDataSource)({
-            config,
-            tenantId
-        });
+    return withDataSource(config, tenantId, async (ds, label)=>{
         const hasPending = await ds.showMigrations();
-        await ds.destroy();
         console.log(`${label} Pending: ${hasPending ? 'Yes' : 'No'}`);
         return {
-            tenantId,
-            database,
-            success: true,
             migrationsRun: [
                 hasPending ? 'Has pending' : 'Up to date'
             ]
         };
-    } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(`${label} ✗ Failed: ${errorMessage}`);
-        return {
-            tenantId,
-            database,
-            success: false,
-            error: errorMessage
-        };
-    }
+    });
 }
 async function runForAllTenants(config, command) {
     const tenants = (0, _utils.getActiveTenants)(config);

package/cjs/utils/datasource-config.builder.js

@@ -12,9 +12,6 @@ _export(exports, {
     get buildDataSourceOptions () {
         return buildDataSourceOptions;
     },
-    get buildTenantDatabaseConfig () {
-        return buildTenantDatabaseConfig;
-    },
     get getActiveTenants () {
         return getActiveTenants;
     },
@@ -70,7 +67,8 @@ function getDatabaseForTenant(config, tenantId) {
     const defaultTenantConfig = {
         id: 'default',
         database: config.defaultDatabaseConfig.database || 'default',
-        enableCompanyFeature: config.bootstrapAppConfig?.enableCompanyFeature ?? false
+        enableCompanyFeature: config.bootstrapAppConfig?.enableCompanyFeature ?? false,
+        permissionMode: config.bootstrapAppConfig?.permissionMode ?? 'FULL'
     };
     return {
         database: defaultTenantConfig.database,
@@ -83,16 +81,6 @@ function resolveEntities(config, tenantConfig) {
     }
     return config.entities;
 }
-function buildTenantDatabaseConfig(baseConfig, tenant) {
-    return {
-        type: baseConfig.type,
-        host: tenant.host ?? baseConfig.host,
-        port: tenant.port ?? baseConfig.port,
-        username: tenant.username ?? baseConfig.username,
-        password: tenant.password ?? baseConfig.password,
-        database: tenant.database
-    };
-}
 function getActiveTenants(config) {
     return config.tenants || [];
 }

package/config/env-config.service.d.ts

@@ -10,13 +10,14 @@ declare class EnvConfigService {
     getBoolean(key: string, throwOnMissing?: boolean): boolean;
     getPort(): number;
     isProduction(): boolean;
-    getFrontendUrl(): string;
     getOrigins(): string[];
     getTypeOrmConfig(): {
+        type: "mysql" | "postgres" | "mariadb" | "sqlite" | "mssql";
         host: string;
         port: number;
         username: string;
         password: string;
+        database: string;
     };
     getJwtConfig(): {
         secret: string;
@@ -36,6 +37,7 @@ declare class EnvConfigService {
         level: string;
         maxSize: string;
         maxFiles: string;
+        disableHttpLogging: boolean;
     };
     getEnv(): Record<string, string>;
 }

package/docs/docs.config.d.ts

@@ -14,6 +14,11 @@ export interface IQueryParameterExclusion {
     method?: string;
     parameters: string[];
 }
+export interface IExampleExclusion {
+    pathPattern: string;
+    method?: string;
+    examples: string[];
+}
 export interface IModuleSwaggerOptions {
     modules?: Type<unknown>[];
     title: string;
@@ -25,5 +30,8 @@ export interface IModuleSwaggerOptions {
     excludeTags?: string[];
     excludeSchemaProperties?: ISchemaPropertyExclusion[];
     excludeQueryParameters?: IQueryParameterExclusion[];
+    excludeExamples?: IExampleExclusion[];
+    excludePaths?: string[];
 }
 export declare function setupModuleSwaggerDocs(app: INestApplication, configs: IModuleSwaggerOptions[]): void;
+export declare function setupSwaggerDocs(app: INestApplication, ...modules: IModuleSwaggerOptions[]): void;

package/docs/index.d.ts

@@ -1,2 +1 @@
 export * from './docs.config';
-export * from './docs.setup';

package/fesm/config/env-config.service.js

@@ -34,24 +34,25 @@ let EnvConfigService = class EnvConfigService {
         return this.getValue(key, throwOnMissing).toLowerCase() === 'true';
     }
     getPort() {
-        return this.getNumber('PORT', false);
+        return this.getNumber('PORT', false) || 3000;
     }
     isProduction() {
         return this.getValue('MODE', false).toUpperCase() !== 'DEV';
     }
-    getFrontendUrl() {
-        return this.getValue('FRONTEND_URL');
-    }
     getOrigins() {
         const origins = this.getValue('ALLOW_ORIGINS');
         return origins ? origins.split(',').map((o)=>o.trim()) : [];
     }
     getTypeOrmConfig() {
+        const type = this.getValue('DB_TYPE', false) || 'mysql';
+        const defaultPort = type === 'postgres' ? 5432 : 3306;
         return {
-            host: this.getValue('DB_HOST'),
-            port: this.getNumber('DB_PORT'),
-            username: this.getValue('DB_USER'),
-            password: this.getValue('DB_PASSWORD')
+            type,
+            host: this.getValue('DB_HOST', false) || 'localhost',
+            port: this.getNumber('DB_PORT', false) || defaultPort,
+            username: this.getValue('DB_USER', false) || 'root',
+            password: this.getValue('DB_PASSWORD', false) || '',
+            database: this.getValue('DB_NAME', false) || 'flusys_main'
         };
     }
     getJwtConfig() {
@@ -82,7 +83,8 @@ let EnvConfigService = class EnvConfigService {
             dir: this.getValue('LOG_DIR', false) || 'logs',
             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'
+            maxFiles: this.getValue('LOG_MAX_FILES', false) || '14d',
+            disableHttpLogging: this.getValue('DISABLE_HTTP_LOGGING', false).toLowerCase() === 'true'
         };
     }
     getEnv() {
@@ -97,10 +99,12 @@ let EnvConfigService = class EnvConfigService {
             ALLOW_ORIGINS: 'getOrigins',
             PORT: 'getPort',
             MODE: 'isProduction',
+            DB_TYPE: 'getTypeOrmConfig',
             DB_HOST: 'getTypeOrmConfig',
             DB_PORT: 'getTypeOrmConfig',
             DB_USER: 'getTypeOrmConfig',
-            DB_PASSWORD: 'getTypeOrmConfig'
+            DB_PASSWORD: 'getTypeOrmConfig',
+            DB_NAME: 'getTypeOrmConfig'
         };
     }
 };

package/fesm/docs/docs.config.js

@@ -1,7 +1,5 @@
 import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
-/**
- * Filter OpenAPI document to exclude schema properties
- */ function filterSchemaProperties(document, exclusions) {
+function filterSchemaProperties(document, exclusions) {
     if (!exclusions?.length || !document.components?.schemas) {
         return document;
     }
@@ -36,9 +34,7 @@ import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
         }
     };
 }
-/**
- * Filter OpenAPI document to exclude query parameters from specific endpoints
- */ function filterQueryParameters(document, exclusions) {
+function filterQueryParameters(document, exclusions) {
     if (!exclusions?.length || !document.paths) {
         return document;
     }
@@ -84,18 +80,87 @@ import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
         paths: filteredPaths
     };
 }
-/**
- * Check if a path matches a pattern (supports wildcards)
- */ function pathMatchesPattern(path, pattern) {
+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];
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                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);
 }
-/**
- * Filter OpenAPI document to exclude paths and tags based on excludeTags
- */ function filterDocumentByTags(document, excludeTags) {
+function filterPaths(document, excludePaths) {
+    if (!excludePaths?.length || !document.paths) {
+        return document;
+    }
+    const filteredPaths = {};
+    for (const [path, pathItem] of Object.entries(document.paths)){
+        const isExcluded = excludePaths.some((pattern)=>pathMatchesPattern(path, pattern));
+        if (!isExcluded) {
+            filteredPaths[path] = pathItem;
+        }
+    }
+    return {
+        ...document,
+        paths: filteredPaths
+    };
+}
+function filterDocumentByTags(document, excludeTags) {
     if (!excludeTags?.length) {
         return document;
     }
@@ -138,9 +203,7 @@ import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
         tags: filteredTags
     };
 }
-/**
- * Setup Swagger documentation for multiple modules
- */ export function setupModuleSwaggerDocs(app, configs) {
+export 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
@@ -167,6 +230,10 @@ import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
             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);
@@ -179,6 +246,13 @@ import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
         if (config.excludeQueryParameters?.length) {
             document = filterQueryParameters(document, config.excludeQueryParameters);
         }
+        // Filter out excluded examples
+        if (config.excludeExamples?.length) {
+            document = filterExamples(document, config.excludeExamples);
+        }
         SwaggerModule.setup(config.path, app, document);
     });
 }
+export function setupSwaggerDocs(app, ...modules) {
+    setupModuleSwaggerDocs(app, modules);
+}

package/fesm/docs/index.js

@@ -1,2 +1 @@
 export * from './docs.config';
-export * from './docs.setup';

package/fesm/index.js

@@ -6,7 +6,5 @@ export * from './constants';
 export * from './utils';
 // Migration
 export * from './migration';
-// Seeders
-export * from './seeders';
 // Config
 export * from './config';

package/fesm/interfaces/app-config.interfaces.js

@@ -1,3 +1 @@
-/**
- * Async module options - common pattern for NestJS async module registration
- */ export { };
+/** Async module options pattern */ export { };

package/fesm/interfaces/base-entity.interface.js

@@ -1,6 +1,6 @@
 /**
- * Base Entity Interface
- * All entities should implement this for consistency
- */ /**
- * Entity with metadata
- */ export { };
+ * Entity Contract Interfaces
+ *
+ * These interfaces define the standard fields that entities should have.
+ * Use them as contracts when implementing new entities.
+ */ /** Base entity with UUID, timestamps, and soft delete */ /** Entity with company relation (for multi-company support) */ export { };

package/fesm/interfaces/database.interface.js

@@ -1,5 +1 @@
-/**
- * Supported database types
- */ /**
- * DataSource build options for TypeORM
- */ export { };
+export { };

package/fesm/migration/cli.js

@@ -1,24 +1,5 @@
 #!/usr/bin/env node
-/**
- * Migration CLI Entry Point
- *
- * Main executable for running TypeORM migrations via npm scripts.
- *
- * Usage (via package.json scripts):
- * - npm run migration generate --name=CreateUsers
- * - npm run migration run
- * - npm run migration revert
- * - npm run migration status
- * - npm run migration run:all (multi-tenant)
- * - npm run migration revert:all (multi-tenant)
- * - npm run migration status:all (multi-tenant)
- *
- * Environment Variables:
- * - TENANT_ID: Target specific tenant (optional)
- *
- * This file is the executable entry point referenced in package.json.
- * The actual CLI logic is in migration.cli.ts (runMigrationCli function).
- */ import { runMigrationCli } from './migration.cli';
+import { runMigrationCli } from './migration.cli';
 runMigrationCli().catch((err)=>{
     console.error('CLI Error:', err.message);
     process.exit(1);

package/fesm/migration/datasource.factory.js

@@ -1,20 +1,12 @@
 import { DataSource } from 'typeorm';
 import { SnakeNamingStrategy } from 'typeorm-naming-strategies';
 import { buildDataSourceOptions, getDatabaseForTenant, getMigrationsGlobPattern, resolveEntities } from '../utils/datasource-config.builder';
-/**
- * Create a DataSource for migrations
- *
- * @param options - Configuration options
- * @param options.config - Migration configuration
- * @param options.tenantId - Optional tenant ID for multi-tenant mode
- * @returns DataSource instance (not initialized)
- */ export function createMigrationDataSource(options) {
+export function createMigrationDataSource(options) {
     const { config, tenantId } = options;
     const { database, tenant, tenantConfig } = getDatabaseForTenant(config, tenantId);
-    // Log target info
     console.log(`\n📦 Database: ${database}${tenant ? ` [${tenant.name}]` : ' [default]'}`);
     console.log(`📁 Migrations: migrations/${tenantId || 'default'}/`);
-    if (config.bootstrapAppConfig?.databaseMode == 'multi-tenant' && !tenantId && config.tenants && config.tenants.length > 0) {
+    if (config.bootstrapAppConfig?.databaseMode === 'multi-tenant' && !tenantId && config.tenants && config.tenants.length > 0) {
         console.log(`\n💡 Multi-tenant mode. Available tenants:`);
         config.tenants.forEach((t)=>console.log(`   - TENANT_ID=${t.id} → ${t.database}`));
     }
@@ -29,7 +21,6 @@ import { buildDataSourceOptions, getDatabaseForTenant, getMigrationsGlobPattern,
         ...config.defaultDatabaseConfig,
         database
     };
-    // Resolve entities based on tenant config
     const entities = resolveEntities(config, tenantConfig);
     const dsOptions = buildDataSourceOptions(dbConfig, entities, getMigrationsGlobPattern(config.migrationsPath, tenantId), config.migrationsTableName);
     return new DataSource({
@@ -37,15 +28,7 @@ import { buildDataSourceOptions, getDatabaseForTenant, getMigrationsGlobPattern,
         namingStrategy: new SnakeNamingStrategy()
     });
 }
-/**
- * Initialize and return a DataSource
- *
- * Creates a DataSource and initializes the connection.
- * The connection should be destroyed after use with `ds.destroy()`.
- *
- * @param options - Configuration options
- * @returns Initialized DataSource instance
- */ export async function initializeDataSource(options) {
+export async function initializeDataSource(options) {
     const ds = createMigrationDataSource(options);
     await ds.initialize();
     return ds;

package/fesm/migration/index.js

@@ -1,17 +1,3 @@
-/**
- * Migration Module Exports
- *
- * Public API for TypeORM migration management in single and multi-tenant databases.
- *
- * Main exports:
- * - createMigrationDataSource: Create DataSource for migrations
- * - initializeDataSource: Create and initialize DataSource
- * - runMigrationCli: Programmatic CLI execution
- *
- * The CLI entry point is at ./cli.ts (used by npm scripts)
- */ // DataSource factory for migration config files
 export { createMigrationDataSource, initializeDataSource } from './datasource.factory';
-// CLI service for programmatic usage
 export { runMigrationCli } from './migration.cli';
-// Migration runner functions (optional, for advanced usage)
 export { generateMigration, runMigrations, revertMigration, migrationStatus, runForAllTenants, ensureMigrationsFolder } from './migration.runner';

package/fesm/migration/migration.cli.js

@@ -2,23 +2,7 @@ import * as path from 'path';
 import { envConfig } from '../config';
 import { getDatabaseForTenant, getMigrationsFolderPath } from '../utils';
 import { generateMigration, migrationStatus, revertMigration, runForAllTenants, runMigrations } from './migration.runner';
-/**
- * Migration CLI Service
- *
- * Handles migration command execution for single and multi-tenant databases.
- *
- * Commands:
- * - generate: Create new migration
- * - run: Execute pending migrations
- * - revert: Rollback last migration
- * - status: Check migration status
- * - run:all/revert:all/status:all: Batch operations for all tenants
- *
- * Configuration:
- * - TENANT_ID: Target tenant (optional, defaults to default database)
- * - --config=<path>: Migration config file path
- * - --datasource=<path>: DataSource file path for TypeORM CLI
- */ function showHelp() {
+function showHelp() {
     console.log(`
 Migration CLI