@flusys/nestjs-core 9.1.1 → 9.2.0

package/fesm/229.js

@@ -1,14 +1,14 @@
+import * as __rspack_external_fs from "fs";
 import * as __rspack_external_path from "path";
 import * as __rspack_external_typeorm from "typeorm";
 import * as __rspack_external_typeorm_naming_strategies_48a68f8e from "typeorm-naming-strategies";
 import * as __rspack_external_url from "url";
 import * as __rspack_external_dotenv from "dotenv";
 import * as __rspack_external_child_process from "child_process";
-import * as __rspack_external_fs from "fs";
 export const __rspack_esm_id = 229;
 export const __rspack_esm_ids = [229];
 export const __webpack_modules__ = {
-398(module) {
+631(module) {
 function __rspack_empty_async_context(req) {
   // Here Promise.resolve().then() is used instead of new Promise() to prevent
   // uncaught exception popping up in devtools
@@ -20,7 +20,7 @@ function __rspack_empty_async_context(req) {
 }
 __rspack_empty_async_context.keys = () => ([]);
 __rspack_empty_async_context.resolve = __rspack_empty_async_context;
-__rspack_empty_async_context.id = 398;
+__rspack_empty_async_context.id = 631;
 module.exports = __rspack_empty_async_context;
 
 
@@ -37,10 +37,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',
@@ -56,10 +66,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]) {
@@ -68,30 +81,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'
         };
     }
@@ -108,15 +130,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 {
@@ -124,11 +146,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);
@@ -160,9 +182,9 @@ var datasource_config_builder = __webpack_require__(722);
 function createMigrationDataSource(options) {
     const { config, tenantId } = options;
     const { database, tenant, tenantConfig } = (0,datasource_config_builder/* .getDatabaseForTenant */.LH)(config, tenantId);
-    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) {
+    console.log(`\n📦 Database: ${database} [${tenant ? tenant.name ?? tenant.id : 'default'}]`);
+    console.log(`📁 Migrations: ${(0,datasource_config_builder/* .getMigrationsFolderPath */.jr)(config.migrationsPath, tenantId)}/`);
+    if (config.bootstrapAppConfig?.databaseMode === 'multi-tenant' && !tenantId && config.tenants?.length) {
         console.log(`\n💡 Multi-tenant mode. Available tenants:`);
         config.tenants.forEach((t)=>console.log(`   - TENANT_ID=${t.id} → ${t.database}`));
     }
@@ -189,6 +211,8 @@ __webpack_require__.d(__webpack_exports__, {
   w: () => (/* binding */ runMigrationCli)
 });
 
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(421);
 // EXTERNAL MODULE: external "path"
 var external_path_ = __webpack_require__(521);
 ;// CONCATENATED MODULE: external "url"
@@ -197,14 +221,15 @@ var external_path_ = __webpack_require__(521);
 var src_config = __webpack_require__(892);
 // EXTERNAL MODULE: ./projects/nestjs-core/src/utils/datasource-config.builder.ts
 var datasource_config_builder = __webpack_require__(722);
-// EXTERNAL MODULE: ./projects/nestjs-core/src/migration/migration.runner.ts + 2 modules
-var migration_runner = __webpack_require__(654);
+// EXTERNAL MODULE: ./projects/nestjs-core/src/migration/migration.runner.ts + 1 modules
+var migration_runner = __webpack_require__(989);
 ;// CONCATENATED MODULE: ./projects/nestjs-core/src/migration/migration.cli.ts
 
 
 
 
 
+
 function showHelp() {
     console.log(`
 Migration CLI
@@ -239,21 +264,23 @@ Examples:
   npm run migration reset
 `);
 }
+function readFlag(arg, flag) {
+    const prefix = `--${flag}=`;
+    return arg.startsWith(prefix) ? arg.slice(prefix.length).trim() || undefined : undefined;
+}
 function parseArgs() {
-    const args = process.argv.slice(2);
     let command;
     let name;
     let configPath;
     let datasourcePath;
     let force = false;
-    for(let i = 0; i < args.length; i++){
-        const arg = args[i];
+    for (const arg of process.argv.slice(2)){
         if (arg.startsWith('--name=')) {
-            name = arg.split('=')[1];
+            name = readFlag(arg, 'name');
         } else if (arg.startsWith('--config=')) {
-            configPath = arg.split('=')[1];
+            configPath = readFlag(arg, 'config');
         } else if (arg.startsWith('--datasource=')) {
-            datasourcePath = arg.split('=')[1];
+            datasourcePath = readFlag(arg, 'datasource');
         } else if (arg === '--force') {
             force = true;
         } else if (!arg.startsWith('-') && !command) {
@@ -268,17 +295,21 @@ function parseArgs() {
         force
     };
 }
+function resolveConfigPath(configPath) {
+    return external_path_.isAbsolute(configPath) ? configPath : external_path_.resolve(process.cwd(), configPath);
+}
 async function loadConfig(configPath) {
-    const absolutePath = external_path_.isAbsolute(configPath) ? configPath : external_path_.resolve(process.cwd(), configPath);
-    const module = await __webpack_require__(398)((0,__rspack_external_url.pathToFileURL)(absolutePath).href);
-    return module.migrationConfig || module.default?.migrationConfig || module;
+    const module = await __webpack_require__(631)((0,__rspack_external_url.pathToFileURL)(resolveConfigPath(configPath)).href);
+    const config = module.migrationConfig ?? module.default?.migrationConfig ?? module.default;
+    if (!config?.defaultDatabaseConfig || !config.migrationsPath) {
+        throw new Error(`Migration config '${configPath}' must export a 'migrationConfig' with defaultDatabaseConfig and migrationsPath`);
+    }
+    return config;
 }
 async function runMigrationCli(configOrPath) {
     const { command, name, configPath: argConfigPath, datasourcePath, force } = parseArgs();
     const tenantId = src_config/* .envConfig.getTenantId */.K.getTenantId() ?? undefined;
-    // npm passes --name=X as npm_config_name
     const migrationName = src_config/* .envConfig.tryGetValue */.K.tryGetValue('npm_config_name') || src_config/* .envConfig.tryGetValue */.K.tryGetValue('MIGRATION_NAME') || name;
-    // Resolve config
     let config;
     let dsPath = datasourcePath;
     if (typeof configOrPath === 'string') {
@@ -290,7 +321,6 @@ async function runMigrationCli(configOrPath) {
         config = await loadConfig(argConfigPath);
         dsPath = dsPath || argConfigPath;
     } else {
-        // Try paths in order: env var, then common defaults
         const envConfigPath = src_config/* .envConfig.tryGetValue */.K.tryGetValue('MIGRATION_CONFIG');
         const defaultPaths = [
             envConfigPath,
@@ -299,18 +329,11 @@ async function runMigrationCli(configOrPath) {
             'persistence/migration.config.ts',
             'persistence/migration.config.js'
         ].filter(Boolean);
-        let loaded = false;
-        for (const tryPath of defaultPaths){
-            try {
-                config = await loadConfig(tryPath);
-                dsPath = dsPath || tryPath;
-                loaded = true;
-                break;
-            } catch  {
-            // Try next path
-            }
-        }
-        if (!loaded) {
+        const foundPath = defaultPaths.find((p)=>external_fs_.existsSync(resolveConfigPath(p)));
+        if (foundPath) {
+            config = await loadConfig(foundPath);
+            dsPath = dsPath || foundPath;
+        } else {
             console.error('❌ Config not found. Use --config=<path> or set MIGRATION_CONFIG env var');
             console.error('   Tried paths:', defaultPaths.join(', '));
             showHelp();
@@ -321,18 +344,21 @@ async function runMigrationCli(configOrPath) {
         showHelp();
         return;
     }
-    // Multi-tenant batch commands
     if (command.endsWith(':all')) {
+        const action = command.slice(0, -':all'.length);
+        if (!(0,migration_runner/* .isTenantMigrationAction */.x_)(action)) {
+            console.error(`❌ Unknown command: ${command}`);
+            showHelp();
+            process.exit(1);
+        }
         if (config.bootstrapAppConfig?.databaseMode === 'single') {
             console.error('❌ Multi-tenant mode not enabled');
             process.exit(1);
         }
-        const action = command.split(':')[0];
         const results = await (0,migration_runner/* .runForAllTenants */.XR)(config, action);
         if (results.some((r)=>!r.success)) process.exit(1);
         return;
     }
-    // Show target info
     const { database } = (0,datasource_config_builder/* .getDatabaseForTenant */.LH)(config, tenantId);
     const folder = (0,datasource_config_builder/* .getMigrationsFolderPath */.jr)(config.migrationsPath, tenantId);
     console.log(`\n📦 Database: ${database}`);
@@ -363,16 +389,21 @@ async function runMigrationCli(configOrPath) {
                     console.error('❌ Refusing to reset database outside dev mode. Pass --force to override.');
                     process.exit(1);
                 }
+                const initName = migrationName || 'Init';
+                (0,migration_runner/* .assertValidMigrationName */.On)(initName);
                 const result = await (0,migration_runner/* .resetDatabase */.$7)(config, tenantId);
                 if (!result.success) process.exit(1);
-                await (0,migration_runner/* .generateMigration */.iL)(config, migrationName || 'Init', tenantId, dsPath);
+                await (0,migration_runner/* .generateMigration */.iL)(config, initName, tenantId, dsPath);
                 const runResult = await (0,migration_runner/* .runMigrations */.vI)(config, tenantId);
                 if (!runResult.success) process.exit(1);
                 break;
             }
         case 'status':
-            await (0,migration_runner/* .migrationStatus */.vd)(config, tenantId);
-            break;
+            {
+                const result = await (0,migration_runner/* .migrationStatus */.vd)(config, tenantId);
+                if (!result.success) process.exit(1);
+                break;
+            }
         default:
             console.error(`❌ Unknown command: ${command}`);
             showHelp();
@@ -382,12 +413,14 @@ async function runMigrationCli(configOrPath) {
 
 
 },
-654(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+989(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
+  On: () => (/* binding */ assertValidMigrationName),
   Mg: () => (/* binding */ ensureMigrationsFolder),
   iL: () => (/* binding */ generateMigration),
+  x_: () => (/* binding */ isTenantMigrationAction),
   vd: () => (/* binding */ migrationStatus),
   $7: () => (/* binding */ resetDatabase),
   $N: () => (/* binding */ revertMigration),
@@ -399,8 +432,8 @@ __webpack_require__.d(__webpack_exports__, {
 
 ;// CONCATENATED MODULE: external "child_process"
 
-;// CONCATENATED MODULE: external "fs"
-
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(421);
 // EXTERNAL MODULE: external "path"
 var external_path_ = __webpack_require__(521);
 // EXTERNAL MODULE: external "typeorm"
@@ -419,19 +452,38 @@ var datasource_factory = __webpack_require__(193);
 
 
 
+const MIGRATION_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/;
+function assertValidMigrationName(name) {
+    if (!MIGRATION_NAME_PATTERN.test(name)) {
+        throw new Error(`Invalid migration name '${name}'. Use letters, digits, "_" or "-", starting with a letter.`);
+    }
+}
 function getLabel(tenantId) {
     return tenantId ? `[${tenantId}]` : '[default]';
 }
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function failure(label, tenantId, database, error) {
+    const errorMessage = toErrorMessage(error);
+    console.error(`${label} ✗ Failed: ${errorMessage}`);
+    return {
+        tenantId,
+        database,
+        success: false,
+        error: errorMessage
+    };
+}
 async function withDataSource(config, tenantId, operation) {
     const { database } = (0,datasource_config_builder/* .getDatabaseForTenant */.LH)(config, tenantId);
     const label = getLabel(tenantId);
+    let ds;
     try {
-        const ds = await (0,datasource_factory/* .initializeDataSource */.w)({
+        ds = await (0,datasource_factory/* .initializeDataSource */.w)({
             config,
             tenantId
         });
         const partial = await operation(ds, label);
-        await ds.destroy();
         return {
             tenantId,
             database,
@@ -439,20 +491,21 @@ async function withDataSource(config, tenantId, operation) {
             ...partial
         };
     } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(`${label} ✗ Failed: ${errorMessage}`);
-        return {
-            tenantId,
-            database,
-            success: false,
-            error: errorMessage
-        };
+        return failure(label, tenantId, database, error);
+    } finally{
+        if (ds) {
+            try {
+                await ds.destroy();
+            } catch (error) {
+                console.error(`${label} ✗ Failed to close connection: ${toErrorMessage(error)}`);
+            }
+        }
     }
 }
 function ensureMigrationsFolder(basePath, tenantId) {
     const folder = (0,datasource_config_builder/* .getMigrationsFolderPath */.jr)(basePath, tenantId);
-    if (!__rspack_external_fs.existsSync(folder)) {
-        __rspack_external_fs.mkdirSync(folder, {
+    if (!external_fs_.existsSync(folder)) {
+        external_fs_.mkdirSync(folder, {
             recursive: true
         });
         console.log(`📁 Created: ${folder}`);
@@ -460,7 +513,8 @@ function ensureMigrationsFolder(basePath, tenantId) {
     return folder;
 }
 async function generateMigration(config, name, tenantId, datasourcePath) {
-    const label = tenantId ? `[${tenantId}]` : '[default]';
+    assertValidMigrationName(name);
+    const label = getLabel(tenantId);
     const folder = ensureMigrationsFolder(config.migrationsPath, tenantId);
     console.log(`${label} Generating migration: ${name}`);
     console.log(`${label} Target folder: ${folder}`);
@@ -483,14 +537,11 @@ async function generateMigration(config, name, tenantId, datasourcePath) {
     }
     console.log(`${label} ✓ Generated!`);
 }
-/**
- * Removes every `queryRunner.query(...)` line of the just-generated migration whose SQL
- * mentions an ignored table or index name. Returns how many statements were removed.
- */ function stripIgnoredTableStatements(folder, name, ignoreTable) {
-    const file = __rspack_external_fs.readdirSync(folder).filter((f)=>f.endsWith(`-${name}.ts`)).sort().pop();
+function stripIgnoredTableStatements(folder, name, ignoreTable) {
+    const file = external_fs_.readdirSync(folder).filter((f)=>f.endsWith(`-${name}.ts`)).toSorted().at(-1);
     if (!file) return 0;
     const filePath = external_path_.join(folder, file);
-    const lines = __rspack_external_fs.readFileSync(filePath, 'utf8').split('\n');
+    const lines = external_fs_.readFileSync(filePath, 'utf8').split('\n');
     let removed = 0;
     const kept = lines.filter((line)=>{
         if (!line.includes('queryRunner.query(')) return true;
@@ -501,7 +552,7 @@ async function generateMigration(config, name, tenantId, datasourcePath) {
         if (touches) removed++;
         return !touches;
     });
-    if (removed > 0) __rspack_external_fs.writeFileSync(filePath, kept.join('\n'));
+    if (removed > 0) external_fs_.writeFileSync(filePath, kept.join('\n'));
     return removed;
 }
 function findDatasourcePath() {
@@ -510,7 +561,7 @@ function findDatasourcePath() {
         'projects/flusysnest/src/persistence/migration.config.ts'
     ];
     for (const p of possiblePaths){
-        if (__rspack_external_fs.existsSync(external_path_.join(process.cwd(), p))) {
+        if (external_fs_.existsSync(external_path_.join(process.cwd(), p))) {
             return p;
         }
     }
@@ -539,21 +590,30 @@ async function revertMigration(config, tenantId) {
 }
 function clearMigrationFiles(basePath, tenantId, label) {
     const folder = (0,datasource_config_builder/* .getMigrationsFolderPath */.jr)(basePath, tenantId);
-    if (!__rspack_external_fs.existsSync(folder)) return;
-    const files = __rspack_external_fs.readdirSync(folder).filter((f)=>f.endsWith('.ts') || f.endsWith('.js'));
-    files.forEach((file)=>__rspack_external_fs.rmSync(external_path_.join(folder, file)));
+    if (!external_fs_.existsSync(folder)) return;
+    const files = external_fs_.readdirSync(folder).filter((f)=>f.endsWith('.ts') || f.endsWith('.js'));
+    files.forEach((file)=>external_fs_.rmSync(external_path_.join(folder, file)));
     console.log(`${label} ✓ Removed ${files.length} migration file(s) from ${folder}`);
 }
+function quoteIdentifier(name, quote) {
+    return `${quote}${name.split(quote).join(quote + quote)}${quote}`;
+}
 async function dropAndRecreateDatabase(dbConfig, label) {
     const { type, database } = dbConfig;
+    if (!database) {
+        throw new Error('Database reset requires a database name');
+    }
     if (type === 'sqlite') {
-        if (database && __rspack_external_fs.existsSync(database)) __rspack_external_fs.rmSync(database);
+        if (external_fs_.existsSync(database)) external_fs_.rmSync(database);
         console.log(`${label} ✓ Deleted sqlite file`);
         return;
     }
     if (type !== 'mysql' && type !== 'mariadb' && type !== 'postgres') {
         throw new Error(`Database reset is not supported for type '${type}'`);
     }
+    if (type === 'postgres' && database === 'postgres') {
+        throw new Error("Refusing to reset the 'postgres' maintenance database");
+    }
     const adminDs = new external_typeorm_.DataSource({
         type,
         host: dbConfig.host,
@@ -568,11 +628,13 @@ async function dropAndRecreateDatabase(dbConfig, label) {
             await adminDs.query(`SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = $1 AND pid <> pg_backend_pid()`, [
                 database
             ]);
-            await adminDs.query(`DROP DATABASE IF EXISTS "${database}"`);
-            await adminDs.query(`CREATE DATABASE "${database}"`);
+            const quoted = quoteIdentifier(database, '"');
+            await adminDs.query(`DROP DATABASE IF EXISTS ${quoted}`);
+            await adminDs.query(`CREATE DATABASE ${quoted}`);
         } else {
-            await adminDs.query(`DROP DATABASE IF EXISTS \`${database}\``);
-            await adminDs.query(`CREATE DATABASE \`${database}\` CHARACTER SET utf8mb4`);
+            const quoted = quoteIdentifier(database, '`');
+            await adminDs.query(`DROP DATABASE IF EXISTS ${quoted}`);
+            await adminDs.query(`CREATE DATABASE ${quoted} CHARACTER SET utf8mb4`);
         }
         console.log(`${label} ✓ Database '${database}' dropped and recreated`);
     } finally{
@@ -592,14 +654,7 @@ async function resetDatabase(config, tenantId) {
             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 failure(label, tenantId, database, error);
     }
 }
 async function migrationStatus(config, tenantId) {
@@ -613,24 +668,28 @@ async function migrationStatus(config, tenantId) {
         };
     });
 }
+const TENANT_ACTIONS = {
+    run: runMigrations,
+    revert: revertMigration,
+    status: migrationStatus
+};
+function isTenantMigrationAction(action) {
+    return Object.hasOwn(TENANT_ACTIONS, action);
+}
 async function runForAllTenants(config, command) {
+    if (!isTenantMigrationAction(command)) {
+        throw new Error(`Unsupported multi-tenant command '${command}'. Use run, revert or status.`);
+    }
+    const action = TENANT_ACTIONS[command];
     const tenants = (0,datasource_config_builder/* .getActiveTenants */.SP)(config);
     console.log(`\n🔄 Running '${command}' for ${tenants.length} tenant(s)...\n`);
     const results = [];
     for (const tenant of tenants){
-        let result;
-        switch(command){
-            case 'run':
-                result = await runMigrations(config, tenant.id);
-                break;
-            case 'revert':
-                result = await revertMigration(config, tenant.id);
-                break;
-            case 'status':
-                result = await migrationStatus(config, tenant.id);
-                break;
+        try {
+            results.push(await action(config, tenant.id));
+        } catch (error) {
+            results.push(failure(getLabel(tenant.id), tenant.id, tenant.database, error));
         }
-        results.push(result);
         console.log('');
     }
     console.log('\n=== Summary ===');
@@ -645,9 +704,7 @@ async function runForAllTenants(config, command) {
 
 },
 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,
@@ -663,24 +720,20 @@ async function runForAllTenants(config, command) {
         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,
@@ -688,21 +741,20 @@ async function runForAllTenants(config, command) {
             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,
@@ -716,17 +768,13 @@ async function runForAllTenants(config, command) {
         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 || [];
 }
 
@@ -741,6 +789,12 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 
+},
+421(module) {
+
+module.exports = __rspack_external_fs;
+
+
 },
 521(module) {