@flusys/nestjs-core 7.1.0 → 8.0.0

package/fesm/229.js

@@ -0,0 +1,729 @@
+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) {
+function __rspack_empty_async_context(req) {
+  // Here Promise.resolve().then() is used instead of new Promise() to prevent
+  // uncaught exception popping up in devtools
+  return Promise.resolve().then(function() {
+    var e = new Error("Cannot find module '" + req + "'");
+    e.code = 'MODULE_NOT_FOUND';
+    throw e;
+  });
+}
+__rspack_empty_async_context.keys = () => ([]);
+__rspack_empty_async_context.resolve = __rspack_empty_async_context;
+__rspack_empty_async_context.id = 398;
+module.exports = __rspack_empty_async_context;
+
+
+},
+892(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  K: () => (/* reexport */ envConfig)
+});
+
+;// CONCATENATED MODULE: external "dotenv"
+
+;// CONCATENATED MODULE: ./projects/nestjs-core/src/config/env-config.service.ts
+
+__rspack_external_dotenv.config();
+let EnvConfigService = class EnvConfigService {
+    env;
+    restrictedKeys = {
+        FRONTEND_URL: 'getFrontendUrl',
+        ALLOW_ORIGINS: 'getOrigins',
+        PORT: 'getPort',
+        MODE: 'isProduction',
+        DB_TYPE: 'getTypeOrmConfig',
+        DB_HOST: 'getTypeOrmConfig',
+        DB_PORT: 'getTypeOrmConfig',
+        DB_USER: 'getTypeOrmConfig',
+        DB_PASSWORD: 'getTypeOrmConfig',
+        DB_NAME: 'getTypeOrmConfig'
+    };
+    constructor(env){
+        this.env = env;
+    }
+    getValue(key, throwOnMissing = true) {
+        const value = this.env[key];
+        if (!value && throwOnMissing) {
+            throw new Error(`Config error - missing env.${key}`);
+        }
+        return value ?? '';
+    }
+    tryGetValue(key, throwOnMissing = false) {
+        if (this.restrictedKeys[key]) {
+            throw new Error(`Access denied for env key "${key}". Use the method \`${this.restrictedKeys[key]}()\` instead.`);
+        }
+        return this.getValue(key, throwOnMissing);
+    }
+    getNumber(key, throwOnMissing = true) {
+        return Number(this.getValue(key, throwOnMissing));
+    }
+    getBoolean(key, throwOnMissing = true) {
+        return this.getValue(key, throwOnMissing).toLowerCase() === 'true';
+    }
+    getPort() {
+        return this.getNumber('PORT', false) || 3000;
+    }
+    isProduction() {
+        return this.getValue('MODE', false).toUpperCase() !== 'DEV';
+    }
+    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 {
+            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() {
+        return {
+            secret: this.getValue('JWT_SECRET'),
+            expiration: this.getValue('JWT_EXPIRATION', false) || '1h',
+            refreshSecret: this.getValue('REFRESH_TOKEN_SECRET'),
+            refreshExpiration: this.getValue('REFRESH_TOKEN_EXPIRATION', false) || '7d'
+        };
+    }
+    getRedisUrl() {
+        return this.getValue('REDIS_URL', false) || 'redis://localhost:6379';
+    }
+    getMailConfig() {
+        return {
+            MAIL_FROM: this.getValue('MAIL_FROM', false) || '',
+            MAIL_APP_PASSWORD: this.getValue('MAIL_APP_PASSWORD', false) || ''
+        };
+    }
+    getTenantId() {
+        return this.getValue('TENANT_ID', false) || null;
+    }
+    useTenantMode() {
+        return this.getValue('USE_TENANT_MODE', false).toLowerCase() === 'true';
+    }
+    getLogConfig() {
+        return {
+            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',
+            disableHttpLogging: this.getValue('DISABLE_HTTP_LOGGING', false).toLowerCase() === 'true'
+        };
+    }
+    getEnv() {
+        return process.env;
+    }
+};
+const envConfig = new EnvConfigService(process.env);
+
+
+;// CONCATENATED MODULE: ./projects/nestjs-core/src/config/index.ts
+
+
+
+},
+193(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  O: () => (/* binding */ createMigrationDataSource),
+  w: () => (/* binding */ initializeDataSource)
+});
+
+// EXTERNAL MODULE: external "typeorm"
+var external_typeorm_ = __webpack_require__(158);
+;// CONCATENATED MODULE: external "typeorm-naming-strategies"
+
+// EXTERNAL MODULE: ./projects/nestjs-core/src/utils/datasource-config.builder.ts
+var datasource_config_builder = __webpack_require__(722);
+;// CONCATENATED MODULE: ./projects/nestjs-core/src/migration/datasource.factory.ts
+
+
+
+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💡 Multi-tenant mode. Available tenants:`);
+        config.tenants.forEach((t)=>console.log(`   - TENANT_ID=${t.id} → ${t.database}`));
+    }
+    const dbConfig = (0,datasource_config_builder/* .resolveDatabaseConnection */.ul)(config, tenantId);
+    const entities = (0,datasource_config_builder/* .resolveEntities */.Md)(config, tenantConfig);
+    const dsOptions = (0,datasource_config_builder/* .buildDataSourceOptions */.QP)(dbConfig, entities, (0,datasource_config_builder/* .getMigrationsGlobPattern */.Q0)(config.migrationsPath, tenantId), config.migrationsTableName);
+    return new external_typeorm_.DataSource({
+        ...dsOptions,
+        namingStrategy: new __rspack_external_typeorm_naming_strategies_48a68f8e.SnakeNamingStrategy()
+    });
+}
+async function initializeDataSource(options) {
+    const ds = createMigrationDataSource(options);
+    await ds.initialize();
+    return ds;
+}
+
+
+},
+164(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  w: () => (/* binding */ runMigrationCli)
+});
+
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(521);
+;// CONCATENATED MODULE: external "url"
+
+// EXTERNAL MODULE: ./projects/nestjs-core/src/config/index.ts + 2 modules
+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);
+;// CONCATENATED MODULE: ./projects/nestjs-core/src/migration/migration.cli.ts
+
+
+
+
+
+function showHelp() {
+    console.log(`
+Migration CLI
+
+Usage:
+  npm run migration <command> [options]
+
+Commands:
+  generate --name=<Name>   Generate migration
+  run                      Run pending migrations
+  revert                   Revert last migration
+  reset                    Drop db, wipe migration files, recreate db, generate + run initial migration (dev only)
+  status                   Show migration status
+  run:all                  Run for all tenants
+  revert:all               Revert for all tenants
+  status:all               Status for all tenants
+
+Options:
+  --config=<path>    Migration config file (default: src/persistence/migration.config.ts)
+  --name=<Name>      Migration name (for generate command)
+  --force            Required to run 'reset' when MODE is not 'dev'
+
+Environment:
+  TENANT_ID          Target tenant (default: uses default database)
+  MIGRATION_CONFIG   Default config path (overrides auto-detection)
+
+Examples:
+  npm run migration generate --name=CreateUsers
+  npm run migration -- generate --name=CreateUsers --config=src/persistence/migration.config.ts
+  TENANT_ID=tenant1 npm run migration run
+  npm run migration run:all
+  npm run migration reset
+`);
+}
+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];
+        if (arg.startsWith('--name=')) {
+            name = arg.split('=')[1];
+        } else if (arg.startsWith('--config=')) {
+            configPath = arg.split('=')[1];
+        } else if (arg.startsWith('--datasource=')) {
+            datasourcePath = arg.split('=')[1];
+        } else if (arg === '--force') {
+            force = true;
+        } else if (!arg.startsWith('-') && !command) {
+            command = arg;
+        }
+    }
+    return {
+        command,
+        name,
+        configPath,
+        datasourcePath,
+        force
+    };
+}
+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;
+}
+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') {
+        config = await loadConfig(configOrPath);
+        dsPath = dsPath || configOrPath;
+    } else if (configOrPath) {
+        config = configOrPath;
+    } else if (argConfigPath) {
+        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,
+            'src/persistence/migration.config.ts',
+            'src/persistence/migration.config.js',
+            '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) {
+            console.error('❌ Config not found. Use --config=<path> or set MIGRATION_CONFIG env var');
+            console.error('   Tried paths:', defaultPaths.join(', '));
+            showHelp();
+            process.exit(1);
+        }
+    }
+    if (!command) {
+        showHelp();
+        return;
+    }
+    // Multi-tenant batch commands
+    if (command.endsWith(':all')) {
+        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}`);
+    console.log(`📁 Migrations: ${external_path_.relative(process.cwd(), folder)}`);
+    switch(command){
+        case 'generate':
+            if (!migrationName) {
+                console.error('❌ Migration name required. Use --name=<Name>');
+                process.exit(1);
+            }
+            await (0,migration_runner/* .generateMigration */.iL)(config, migrationName, tenantId, dsPath);
+            break;
+        case 'run':
+            {
+                const result = await (0,migration_runner/* .runMigrations */.vI)(config, tenantId);
+                if (!result.success) process.exit(1);
+                break;
+            }
+        case 'revert':
+            {
+                const result = await (0,migration_runner/* .revertMigration */.$N)(config, tenantId);
+                if (!result.success) process.exit(1);
+                break;
+            }
+        case 'reset':
+            {
+                if (src_config/* .envConfig.isProduction */.K.isProduction() && !force) {
+                    console.error('❌ Refusing to reset database outside dev mode. Pass --force to override.');
+                    process.exit(1);
+                }
+                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);
+                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;
+        default:
+            console.error(`❌ Unknown command: ${command}`);
+            showHelp();
+            process.exit(1);
+    }
+}
+
+
+},
+654(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  Mg: () => (/* binding */ ensureMigrationsFolder),
+  iL: () => (/* binding */ generateMigration),
+  vd: () => (/* binding */ migrationStatus),
+  $7: () => (/* binding */ resetDatabase),
+  $N: () => (/* binding */ revertMigration),
+  XR: () => (/* binding */ runForAllTenants),
+  vI: () => (/* binding */ runMigrations)
+});
+
+;// CONCATENATED MODULE: external "child_process"
+
+;// CONCATENATED MODULE: external "fs"
+
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(521);
+// EXTERNAL MODULE: external "typeorm"
+var external_typeorm_ = __webpack_require__(158);
+// EXTERNAL MODULE: ./projects/nestjs-core/src/config/index.ts + 2 modules
+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/datasource.factory.ts + 1 modules
+var datasource_factory = __webpack_require__(193);
+;// CONCATENATED MODULE: ./projects/nestjs-core/src/migration/migration.runner.ts
+
+
+
+
+
+
+
+function getLabel(tenantId) {
+    return tenantId ? `[${tenantId}]` : '[default]';
+}
+async function withDataSource(config, tenantId, operation) {
+    const { database } = (0,datasource_config_builder/* .getDatabaseForTenant */.LH)(config, tenantId);
+    const label = getLabel(tenantId);
+    try {
+        const ds = await (0,datasource_factory/* .initializeDataSource */.w)({
+            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,datasource_config_builder/* .getMigrationsFolderPath */.jr)(basePath, tenantId);
+    if (!__rspack_external_fs.existsSync(folder)) {
+        __rspack_external_fs.mkdirSync(folder, {
+            recursive: true
+        });
+        console.log(`📁 Created: ${folder}`);
+    }
+    return folder;
+}
+async function generateMigration(config, name, tenantId, datasourcePath) {
+    const label = tenantId ? `[${tenantId}]` : '[default]';
+    const folder = ensureMigrationsFolder(config.migrationsPath, tenantId);
+    console.log(`${label} Generating migration: ${name}`);
+    console.log(`${label} Target folder: ${folder}`);
+    const dsPath = datasourcePath || findDatasourcePath();
+    const migrationFile = external_path_.join(folder, name);
+    const command = `tsx ./node_modules/typeorm/cli.js migration:generate "${migrationFile}" -d "${dsPath}"`;
+    (0,__rspack_external_child_process.execSync)(command, {
+        stdio: 'inherit',
+        env: {
+            ...src_config/* .envConfig.getEnv */.K.getEnv(),
+            TENANT_ID: tenantId || ''
+        },
+        cwd: process.cwd()
+    });
+    console.log(`${label} ✓ Generated!`);
+}
+function findDatasourcePath() {
+    const possiblePaths = [
+        'src/persistence/migration.config.ts',
+        'projects/flusysnest/src/persistence/migration.config.ts'
+    ];
+    for (const p of possiblePaths){
+        if (__rspack_external_fs.existsSync(external_path_.join(process.cwd(), p))) {
+            return p;
+        }
+    }
+    throw new Error('Could not find datasource file. Specify with --datasource=<path>');
+}
+async function runMigrations(config, tenantId) {
+    return withDataSource(config, tenantId, async (ds, label)=>{
+        const migrations = await ds.runMigrations();
+        if (migrations.length === 0) {
+            console.log(`${label} No pending migrations.`);
+        } else {
+            console.log(`${label} ✓ Executed ${migrations.length} migration(s):`);
+            migrations.forEach((m)=>console.log(`   - ${m.name}`));
+        }
+        return {
+            migrationsRun: migrations.map((m)=>m.name)
+        };
+    });
+}
+async function revertMigration(config, tenantId) {
+    return withDataSource(config, tenantId, async (ds, label)=>{
+        await ds.undoLastMigration();
+        console.log(`${label} ✓ Reverted!`);
+        return {};
+    });
+}
+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)));
+    console.log(`${label} ✓ Removed ${files.length} migration file(s) from ${folder}`);
+}
+async function dropAndRecreateDatabase(dbConfig, label) {
+    const { type, database } = dbConfig;
+    if (type === 'sqlite') {
+        if (database && __rspack_external_fs.existsSync(database)) __rspack_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}'`);
+    }
+    const adminDs = new external_typeorm_.DataSource({
+        type,
+        host: dbConfig.host,
+        port: dbConfig.port,
+        username: dbConfig.username,
+        password: dbConfig.password,
+        database: type === 'postgres' ? 'postgres' : undefined
+    });
+    await adminDs.initialize();
+    try {
+        if (type === 'postgres') {
+            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}"`);
+        } else {
+            await adminDs.query(`DROP DATABASE IF EXISTS \`${database}\``);
+            await adminDs.query(`CREATE DATABASE \`${database}\` CHARACTER SET utf8mb4`);
+        }
+        console.log(`${label} ✓ Database '${database}' dropped and recreated`);
+    } finally{
+        await adminDs.destroy();
+    }
+}
+async function resetDatabase(config, tenantId) {
+    const { database } = (0,datasource_config_builder/* .getDatabaseForTenant */.LH)(config, tenantId);
+    const label = getLabel(tenantId);
+    try {
+        clearMigrationFiles(config.migrationsPath, tenantId, label);
+        const dbConfig = (0,datasource_config_builder/* .resolveDatabaseConnection */.ul)(config, tenantId);
+        await dropAndRecreateDatabase(dbConfig, label);
+        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
+        };
+    }
+}
+async function migrationStatus(config, tenantId) {
+    return withDataSource(config, tenantId, async (ds, label)=>{
+        const hasPending = await ds.showMigrations();
+        console.log(`${label} Pending: ${hasPending ? 'Yes' : 'No'}`);
+        return {
+            migrationsRun: [
+                hasPending ? 'Has pending' : 'Up to date'
+            ]
+        };
+    });
+}
+async function runForAllTenants(config, 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;
+        }
+        results.push(result);
+        console.log('');
+    }
+    console.log('\n=== Summary ===');
+    results.forEach((r)=>{
+        const icon = r.success ? '✓' : '✗';
+        const msg = r.error ? ` - ${r.error}` : '';
+        console.log(`${icon} ${r.tenantId || 'default'}${msg}`);
+    });
+    return results;
+}
+
+
+},
+722(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/**
+ * Build DataSource options from database config
+ */ function buildDataSourceOptions(config, entities, migrationsPath, migrationsTableName = 'migrations') {
+    return {
+        type: config.type,
+        host: config.host,
+        port: config.port,
+        username: config.username,
+        password: config.password,
+        database: config.database || '',
+        entities,
+        migrations: [
+            migrationsPath
+        ],
+        migrationsTableName,
+        synchronize: false
+    };
+}
+/**
+ * Get migration folder path for a tenant
+ */ function getMigrationsFolderPath(basePath, tenantId) {
+    const folder = tenantId || 'default';
+    return `${basePath}/${folder}`;
+}
+/**
+ * Get migrations glob pattern for a tenant
+ */ 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);
+        if (!tenant) {
+            throw new Error(`Tenant '${tenantId}' not found. Available: ${config.tenants.map((t)=>t.id).join(', ')}`);
+        }
+        return {
+            database: tenant.database,
+            tenant,
+            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'
+    };
+    return {
+        database: defaultTenantConfig.database,
+        tenantConfig: defaultTenantConfig
+    };
+}
+/**
+ * Resolve full connection details for a tenant.
+ */ function resolveDatabaseConnection(config, tenantId) {
+    const { database, tenant } = getDatabaseForTenant(config, tenantId);
+    return tenant ? {
+        ...config.defaultDatabaseConfig,
+        host: tenant.host ?? config.defaultDatabaseConfig.host,
+        port: tenant.port ?? config.defaultDatabaseConfig.port,
+        username: tenant.username ?? config.defaultDatabaseConfig.username,
+        password: tenant.password ?? config.defaultDatabaseConfig.password,
+        database: tenant.database
+    } : {
+        ...config.defaultDatabaseConfig,
+        database
+    };
+}
+/**
+ * Resolve entities based on tenant config
+ */ function resolveEntities(config, tenantConfig) {
+    if (typeof config.entities === 'function') {
+        return config.entities(tenantConfig);
+    }
+    return config.entities;
+}
+/**
+ * Get active tenants from config
+ */ function getActiveTenants(config) {
+    return config.tenants || [];
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  LH: () => (getDatabaseForTenant),
+  Md: () => (resolveEntities),
+  Q0: () => (getMigrationsGlobPattern),
+  QP: () => (buildDataSourceOptions),
+  SP: () => (getActiveTenants),
+  jr: () => (getMigrationsFolderPath),
+  ul: () => (resolveDatabaseConnection)
+});
+
+
+},
+521(module) {
+
+module.exports = __rspack_external_path;
+
+
+},
+158(module) {
+
+module.exports = __rspack_external_typeorm;
+
+
+},
+
+};