@zintrust/core 0.1.19 → 0.1.21

package/src/config/cache.js

@@ -3,6 +3,7 @@
  * Caching drivers and settings
  * Sealed namespace for immutability
  */
+import { StartupConfigFile, StartupConfigFileRegistry } from '../runtime/StartupConfigFileRegistry.js';
 import { Env } from './env.js';
 import { ErrorFactory } from '../exceptions/ZintrustError.js';
 const getCacheDriver = (config, name) => {
@@ -22,22 +23,16 @@ const getCacheDriver = (config, name) => {
     }
     throw ErrorFactory.createConfigError(`Cache default store not configured: ${storeName || '<empty>'}`);
 };
-const cacheConfigObj = {
-    /**
-     * Default cache driver
-     */
-    default: (() => {
+const createCacheConfig = () => {
+    const baseDefault = (() => {
         const envConnection = Env.get('CACHE_CONNECTION', '').trim();
         const envDriver = typeof Env.CACHE_DRIVER === 'string'
             ? String(Env.CACHE_DRIVER)
             : Env.get('CACHE_DRIVER', 'memory');
         const selected = envConnection.length > 0 ? envConnection : String(envDriver ?? 'memory');
         return selected.trim().toLowerCase();
-    })(),
-    /**
-     * Cache drivers
-     */
-    drivers: {
+    })();
+    const baseDrivers = {
         memory: {
             driver: 'memory',
             ttl: Env.getInt('CACHE_MEMORY_TTL', 3600),
@@ -62,20 +57,69 @@ const cacheConfigObj = {
             driver: 'kv-remote',
             ttl: Env.getInt('CACHE_KV_TTL', 3600),
         },
+    };
+    const overrides = StartupConfigFileRegistry.get(StartupConfigFile.Cache) ?? {};
+    const mergedDrivers = {
+        ...baseDrivers,
+        ...(overrides.drivers ?? {}),
+    };
+    const mergedDefault = typeof overrides.default === 'string' && overrides.default.trim() !== ''
+        ? overrides.default.trim().toLowerCase()
+        : baseDefault;
+    const mergedKeyPrefix = typeof overrides.keyPrefix === 'string' && overrides.keyPrefix.length > 0
+        ? overrides.keyPrefix
+        : Env.get('CACHE_KEY_PREFIX', 'zintrust:');
+    const mergedTtl = typeof overrides.ttl === 'number' && Number.isFinite(overrides.ttl) ? overrides.ttl : 3600;
+    const cacheConfigObj = {
+        /**
+         * Default cache driver
+         */
+        default: mergedDefault,
+        /**
+         * Cache drivers
+         */
+        drivers: mergedDrivers,
+        /**
+         * Get cache driver config
+         */
+        getDriver(name) {
+            return getCacheDriver(this, name);
+        },
+        /**
+         * Key prefix for all cache keys
+         */
+        keyPrefix: mergedKeyPrefix,
+        /**
+         * Default cache TTL (seconds)
+         */
+        ttl: mergedTtl,
+    };
+    return Object.freeze(cacheConfigObj);
+};
+let cached = null;
+const proxyTarget = {};
+const ensureCacheConfig = () => {
+    if (cached)
+        return cached;
+    cached = createCacheConfig();
+    try {
+        Object.defineProperties(proxyTarget, Object.getOwnPropertyDescriptors(cached));
+    }
+    catch {
+        // best-effort
+    }
+    return cached;
+};
+export const cacheConfig = new Proxy(proxyTarget, {
+    get(_target, prop) {
+        return ensureCacheConfig()[prop];
     },
-    /**
-     * Get cache driver config
-     */
-    getDriver(name) {
-        return getCacheDriver(this, name);
+    ownKeys() {
+        ensureCacheConfig();
+        return Reflect.ownKeys(proxyTarget);
     },
-    /**
-     * Key prefix for all cache keys
-     */
-    keyPrefix: Env.get('CACHE_KEY_PREFIX', 'zintrust:'),
-    /**
-     * Default cache TTL (seconds)
-     */
-    ttl: Env.getInt('CACHE_DEFAULT_TTL', 3600),
-};
-export const cacheConfig = Object.freeze(cacheConfigObj);
+    getOwnPropertyDescriptor(_target, prop) {
+        ensureCacheConfig();
+        return Object.getOwnPropertyDescriptor(proxyTarget, prop);
+    },
+});

package/src/config/cloudflare.d.ts

@@ -4,7 +4,7 @@
  * Centralizes access to Workers bindings via globalThis.env.
  * This keeps runtime-specific globals out of adapters/drivers.
  */
-import { KVNamespace, WorkersEnv } from './type';
+import type { KVNamespace, WorkersEnv } from './type';
 import type { DatabaseConfig, ID1Database } from '../orm/DatabaseAdapter';
 export declare const Cloudflare: Readonly<{
     getWorkersEnv: () => WorkersEnv | null;

package/src/config/cloudflare.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../../../src/config/cloudflare.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AA8BxE,eAAO,MAAM,UAAU;yBA5BG,UAAU,GAAG,IAAI;2BAOb,cAAc,KAAG,WAAW,GAAG,IAAI;4CAanB,WAAW,GAAG,IAAI;EAY9D,CAAC"}
+{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../../../src/config/cloudflare.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AA8BxE,eAAO,MAAM,UAAU;yBA5BG,UAAU,GAAG,IAAI;2BAOb,cAAc,KAAG,WAAW,GAAG,IAAI;4CAanB,WAAW,GAAG,IAAI;EAY9D,CAAC"}

package/src/config/database.d.ts

@@ -3,81 +3,39 @@
  * Database connections and pooling settings
  * Sealed namespace for immutability
  */
-import { DatabaseConfigShape, DatabaseConnectionConfig } from './type';
-export declare const databaseConfig: Readonly<{
-    /**
-     * Default database connection
-     */
+import type { DatabaseConfigShape, DatabaseConnectionConfig, DatabaseConnections } from './type';
+export type DatabaseConfigOverrides = Partial<{
     default: string;
-    /**
-     * Database connections
-     */
-    connections: {
-        sqlite: {
-            driver: "sqlite";
-            database: string;
-            migrations: string;
-        };
-        d1: {
-            driver: "d1";
-        };
-        'd1-remote': {
-            driver: "d1-remote";
-        };
-        postgresql: {
-            driver: "postgresql";
-            host: string;
-            port: number;
-            database: string;
-            username: string;
-            password: string;
-            ssl: boolean;
-            pooling: {
-                enabled: boolean;
-                min: number;
-                max: number;
-                idleTimeout: number;
-                connectionTimeout: number;
-            };
-        };
-        mysql: {
-            driver: "mysql";
-            host: string;
-            port: number;
-            database: string;
-            username: string;
-            password: string;
-            pooling: {
-                enabled: boolean;
-                min: number;
-                max: number;
-            };
-        };
-    };
-    /**
-     * Get current connection config
-     */
-    getConnection(this: DatabaseConfigShape): DatabaseConnectionConfig;
-    /**
-     * Enable query logging
-     */
+    connections: DatabaseConnections;
     logging: {
         enabled: boolean;
         level: string;
     };
-    /**
-     * Migration settings
-     */
     migrations: {
         directory: string;
         extension: string;
     };
-    /**
-     * Seeding settings
-     */
     seeders: {
         directory: string;
     };
 }>;
-export type DatabaseConfig = typeof databaseConfig;
+declare const createDatabaseConfig: () => {
+    default: string;
+    connections: DatabaseConnections;
+    getConnection: (this: DatabaseConfigShape) => DatabaseConnectionConfig;
+    logging: {
+        enabled: boolean;
+        level: string;
+    };
+    migrations: {
+        directory: string;
+        extension: string;
+    };
+    seeders: {
+        directory: string;
+    };
+};
+export type DatabaseConfig = ReturnType<typeof createDatabaseConfig>;
+export declare const databaseConfig: DatabaseConfig;
+export {};
 //# sourceMappingURL=database.d.ts.map

package/src/config/database.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../src/config/database.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,mBAAmB,EAAE,wBAAwB,EAAuB,MAAM,cAAc,CAAC;AA0HlG,eAAO,MAAM,cAAc;IAzCzB;;OAEG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGH;;OAEG;wBACiB,mBAAmB,GAAG,wBAAwB;IAIlE;;OAEG;;;;;IAMH;;OAEG;;;;;IAMH;;OAEG;;;;EAMyD,CAAC;AAC/D,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC"}
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../src/config/database.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EACV,mBAAmB,EACnB,wBAAwB,EACxB,mBAAmB,EACpB,MAAM,cAAc,CAAC;AAGtB,MAAM,MAAM,uBAAuB,GAAG,OAAO,CAAC;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,mBAAmB,CAAC;IACjC,OAAO,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7C,UAAU,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IACrD,OAAO,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CAChC,CAAC,CAAC;AA0LH,QAAA,MAAM,oBAAoB,QAAO;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,mBAAmB,CAAC;IACjC,aAAa,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,wBAAwB,CAAC;IACvE,OAAO,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7C,UAAU,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IACrD,OAAO,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CAyEhC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAqBrE,eAAO,MAAM,cAAc,EAAE,cAY3B,CAAC"}

package/src/config/database.js

@@ -3,11 +3,105 @@
  * Database connections and pooling settings
  * Sealed namespace for immutability
  */
+import { StartupConfigFile, StartupConfigFileRegistry } from '../runtime/StartupConfigFileRegistry.js';
 import { Env } from './env.js';
 import { ErrorFactory } from '../exceptions/ZintrustError.js';
+const isNodeProcess = () => {
+    return typeof process !== 'undefined' && typeof process.cwd === 'function';
+};
+const isExplicitEnvValue = (key) => {
+    if (!isNodeProcess())
+        return false;
+    const raw = process.env[key];
+    return typeof raw === 'string' && raw.trim() !== '';
+};
+const looksLikeSqliteFilePath = (value) => {
+    const v = value.trim();
+    if (v === '')
+        return false;
+    if (v === ':memory:')
+        return true;
+    // Heuristic: if it's a path, has an extension, or is explicitly relative.
+    if (v.includes('/') || v.includes('\\'))
+        return true;
+    if (v.startsWith('.'))
+        return true;
+    if (v.startsWith('~'))
+        return true;
+    if (v.endsWith('.sqlite') || v.endsWith('.db'))
+        return true;
+    // Otherwise it's likely a placeholder name (e.g. "zintrust"), not a file path.
+    return false;
+};
+const toSafeDbBasename = (raw) => {
+    const trimmed = raw.trim();
+    if (trimmed === '')
+        return 'zintrust';
+    // Conservative filename allowlist: letters/numbers/_/-, collapse everything else.
+    // Avoid regexes that can exhibit catastrophic backtracking; do deterministic collapsing/trimming.
+    const collapsed = trimmed.toLowerCase().replaceAll(/[^a-z0-9_-]+/g, '-');
+    // Collapse consecutive hyphens deterministically without regex backtracking.
+    let normalized = '';
+    let prevHyphen = false;
+    for (const element of collapsed) {
+        const ch = element;
+        if (ch === '-') {
+            if (!prevHyphen) {
+                normalized += ch;
+                prevHyphen = true;
+            }
+        }
+        else {
+            normalized += ch;
+            prevHyphen = false;
+        }
+    }
+    // Trim leading/trailing hyphens deterministically without regex.
+    let start = 0;
+    let end = normalized.length;
+    while (start < end && normalized.charAt(start) === '-')
+        start++;
+    while (end > start && normalized.charAt(end - 1) === '-')
+        end--;
+    const result = normalized.slice(start, end);
+    return result === '' ? 'zintrust' : result;
+};
+const resolveSqliteDefaultBasename = () => {
+    const service = typeof process.env['SERVICE_NAME'] === 'string' ? process.env['SERVICE_NAME'] : '';
+    if (service.trim() !== '')
+        return toSafeDbBasename(service);
+    const app = typeof process.env['APP_NAME'] === 'string' ? process.env['APP_NAME'] : '';
+    if (app.trim() !== '')
+        return toSafeDbBasename(app);
+    return 'zintrust';
+};
+const resolveDefaultSqliteDatabasePath = () => {
+    // Respect explicit sqlite *file path* configuration.
+    // Note: we intentionally treat plain names like "zintrust" as placeholders, not file paths,
+    // to avoid creating stray DB files in the project root.
+    if (isExplicitEnvValue('DB_DATABASE') || isExplicitEnvValue('DB_PATH')) {
+        const configured = Env.DB_DATABASE;
+        if (looksLikeSqliteFilePath(configured))
+            return configured;
+    }
+    // Only change the default behavior for dev/testing; production should be explicit.
+    if (!isNodeProcess() || Env.NODE_ENV === 'production')
+        return Env.DB_DATABASE;
+    // Store dev sqlite files in project-local metadata folder.
+    // Note: the SQLite adapter ensures the parent directory exists.
+    const base = resolveSqliteDefaultBasename();
+    return `.zintrust/dbs/${base}.sqlite`;
+};
 const hasOwn = (obj, key) => {
     return Object.hasOwn(obj, key);
 };
+const parseReadHosts = (raw) => {
+    const list = String(raw ?? '')
+        .split(',')
+        .map((v) => v.trim())
+        .filter((v) => v.length > 0);
+    return list.length > 0 ? list : undefined;
+};
 const getDefaultConnection = (connections) => {
     const envSelectedRaw = Env.get('DB_CONNECTION', '');
     const value = String(envSelectedRaw ?? '').trim();
@@ -35,7 +129,7 @@ const getDatabaseConnection = (config) => {
 const connections = {
     sqlite: {
         driver: 'sqlite',
-        database: Env.DB_DATABASE,
+        database: resolveDefaultSqliteDatabasePath(),
         migrations: 'database/migrations',
     },
     d1: {
@@ -47,11 +141,12 @@ const connections = {
     postgresql: {
         driver: 'postgresql',
         host: Env.DB_HOST,
-        port: Env.DB_PORT,
-        database: Env.DB_DATABASE,
-        username: Env.DB_USERNAME,
-        password: Env.DB_PASSWORD,
+        port: Env.DB_PORT_POSTGRESQL,
+        database: Env.DB_DATABASE_POSTGRESQL,
+        username: Env.DB_USERNAME_POSTGRESQL,
+        password: Env.DB_PASSWORD_POSTGRESQL,
         ssl: Env.getBool('DB_SSL', false),
+        readHosts: parseReadHosts(Env.DB_READ_HOSTS_POSTGRESQL),
         pooling: {
             enabled: Env.getBool('DB_POOLING', true),
             min: Env.getInt('DB_POOL_MIN', 5),
@@ -67,47 +162,106 @@ const connections = {
         database: Env.DB_DATABASE,
         username: Env.DB_USERNAME,
         password: Env.DB_PASSWORD,
+        readHosts: parseReadHosts(Env.DB_READ_HOSTS),
         pooling: {
             enabled: Env.getBool('DB_POOLING', true),
             min: Env.getInt('DB_POOL_MIN', 5),
             max: Env.getInt('DB_POOL_MAX', 20),
         },
     },
-};
-const databaseConfigObj = {
-    /**
-     * Default database connection
-     */
-    default: getDefaultConnection(connections),
-    /**
-     * Database connections
-     */
-    connections,
-    /**
-     * Get current connection config
-     */
-    getConnection() {
-        return getDatabaseConnection(this);
+    sqlserver: {
+        driver: 'sqlserver',
+        host: Env.DB_HOST_MSSQL,
+        port: Env.DB_PORT_MSSQL,
+        database: Env.DB_DATABASE_MSSQL,
+        username: Env.DB_USERNAME_MSSQL,
+        password: Env.DB_PASSWORD_MSSQL,
+        readHosts: parseReadHosts(Env.DB_READ_HOSTS_MSSQL),
     },
-    /**
-     * Enable query logging
-     */
-    logging: {
-        enabled: Env.DEBUG,
+};
+const createDatabaseConfig = () => {
+    const overrides = StartupConfigFileRegistry.get(StartupConfigFile.Database) ?? {};
+    const mergedConnections = {
+        ...connections,
+        ...overrides.connections,
+    };
+    const baseLogging = {
+        enabled: Env.getBool('DB_LOG_QUERIES', Env.DEBUG),
         level: Env.get('DB_LOG_LEVEL', 'debug'),
-    },
-    /**
-     * Migration settings
-     */
-    migrations: {
+    };
+    const baseMigrations = {
         directory: 'database/migrations',
         extension: Env.get('DB_MIGRATION_EXT', '.ts'),
-    },
-    /**
-     * Seeding settings
-     */
-    seeders: {
+    };
+    const baseSeeders = {
         directory: 'database/seeders',
-    },
+    };
+    const mergedDefault = typeof overrides.default === 'string' && overrides.default.trim() !== ''
+        ? overrides.default.trim()
+        : getDefaultConnection(mergedConnections);
+    const databaseConfigObj = {
+        /**
+         * Default database connection
+         */
+        default: mergedDefault,
+        /**
+         * Database connections
+         */
+        connections: mergedConnections,
+        /**
+         * Get current connection config
+         */
+        getConnection() {
+            return getDatabaseConnection(this);
+        },
+        /**
+         * Enable query logging
+         */
+        logging: {
+            ...baseLogging,
+            ...overrides.logging,
+        },
+        /**
+         * Migration settings
+         */
+        migrations: {
+            ...baseMigrations,
+            ...overrides.migrations,
+        },
+        /**
+         * Seeding settings
+         */
+        seeders: {
+            ...baseSeeders,
+            ...overrides.seeders,
+        },
+    };
+    return Object.freeze(databaseConfigObj);
+};
+let cached = null;
+const proxyTarget = {};
+const ensureDatabaseConfig = () => {
+    if (cached)
+        return cached;
+    cached = createDatabaseConfig();
+    try {
+        Object.defineProperties(proxyTarget, Object.getOwnPropertyDescriptors(cached));
+    }
+    catch {
+        // best-effort
+    }
+    return cached;
 };
-export const databaseConfig = Object.freeze(databaseConfigObj);
+export const databaseConfig = new Proxy(proxyTarget, {
+    get(_target, prop) {
+        return ensureDatabaseConfig()[prop];
+    },
+    ownKeys() {
+        ensureDatabaseConfig();
+        return Reflect.ownKeys(proxyTarget);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+        ensureDatabaseConfig();
+        return Object.getOwnPropertyDescriptor(proxyTarget, prop);
+    },
+});

package/src/config/env.d.ts

@@ -12,6 +12,7 @@ export declare const Env: Readonly<{
     NODE_ENV: string;
     PORT: number;
     HOST: string;
+    BASE_URL: string;
     APP_NAME: string;
     APP_KEY: string;
     APP_PREVIOUS_KEYS: string;
@@ -22,6 +23,17 @@ export declare const Env: Readonly<{
     DB_USERNAME: string;
     DB_PASSWORD: string;
     DB_READ_HOSTS: string;
+    DB_PORT_POSTGRESQL: number;
+    DB_DATABASE_POSTGRESQL: string;
+    DB_USERNAME_POSTGRESQL: string;
+    DB_PASSWORD_POSTGRESQL: string;
+    DB_READ_HOSTS_POSTGRESQL: string;
+    DB_HOST_MSSQL: string;
+    DB_PORT_MSSQL: number;
+    DB_DATABASE_MSSQL: string;
+    DB_USERNAME_MSSQL: string;
+    DB_PASSWORD_MSSQL: string;
+    DB_READ_HOSTS_MSSQL: string;
     D1_DATABASE_ID: string;
     KV_NAMESPACE_ID: string;
     D1_REMOTE_URL: string;

package/src/config/env.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../src/config/env.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA+CH,eAAO,MAAM,GAAG;eA/BE,MAAM,iBAAiB,MAAM,KAAG,MAAM;kBAMnC,MAAM,iBAAiB,MAAM,KAAG,MAAM;mBASrC,MAAM,iBAAiB,OAAO,KAAG,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAqGP,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO;;;;;;;;;EAkCxF,CAAC"}
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../src/config/env.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA+CH,eAAO,MAAM,GAAG;eA/BE,MAAM,iBAAiB,MAAM,KAAG,MAAM;kBAMnC,MAAM,iBAAiB,MAAM,KAAG,MAAM;mBASrC,MAAM,iBAAiB,OAAO,KAAG,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAoHP,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO;;;;;;;;;EAkCxF,CAAC"}

package/src/config/env.js

@@ -58,6 +58,7 @@ export const Env = Object.freeze({
     // Prefer PORT, fallback to APP_PORT for compatibility
     PORT: getInt('PORT', getInt('APP_PORT', 3000)),
     HOST: get('HOST', 'localhost'),
+    BASE_URL: get('BASE_URL', ''),
     APP_NAME: get('APP_NAME', 'ZinTrust'),
     APP_KEY: get('APP_KEY', ''),
     // Optional key rotation support (comma-separated or JSON array of keys)
@@ -71,6 +72,19 @@ export const Env = Object.freeze({
     DB_USERNAME: get('DB_USERNAME', 'postgres'),
     DB_PASSWORD: get('DB_PASSWORD', ''),
     DB_READ_HOSTS: get('DB_READ_HOSTS', ''),
+    // PostgreSQL-specific configuration (with _POSTGRESQL suffix to avoid conflicts with MySQL)
+    DB_PORT_POSTGRESQL: getInt('DB_PORT_POSTGRESQL', 5432),
+    DB_DATABASE_POSTGRESQL: get('DB_DATABASE_POSTGRESQL', 'postgres'),
+    DB_USERNAME_POSTGRESQL: get('DB_USERNAME_POSTGRESQL', 'postgres'),
+    DB_PASSWORD_POSTGRESQL: get('DB_PASSWORD_POSTGRESQL', ''),
+    DB_READ_HOSTS_POSTGRESQL: get('DB_READ_HOSTS_POSTGRESQL', ''),
+    // SQL Server (MSSQL) specific configuration
+    DB_HOST_MSSQL: get('DB_HOST_MSSQL', get('DB_HOST', 'localhost')),
+    DB_PORT_MSSQL: getInt('DB_PORT_MSSQL', 1433),
+    DB_DATABASE_MSSQL: get('DB_DATABASE_MSSQL', 'zintrust'),
+    DB_USERNAME_MSSQL: get('DB_USERNAME_MSSQL', 'sa'),
+    DB_PASSWORD_MSSQL: get('DB_PASSWORD_MSSQL', ''),
+    DB_READ_HOSTS_MSSQL: get('DB_READ_HOSTS_MSSQL', ''),
     // Cloudflare
     D1_DATABASE_ID: get('D1_DATABASE_ID'),
     KV_NAMESPACE_ID: get('KV_NAMESPACE_ID'),