@zintrust/core 0.4.17 → 0.4.18

package/src/config/database.js

@@ -0,0 +1,321 @@
+/**
+ * Database Configuration
+ * Database connections and pooling settings
+ * Sealed namespace for immutability
+ */
+import { Cloudflare } from './cloudflare.js';
+import { Env } from './env.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import { StartupConfigFile, StartupConfigFileRegistry } from '../runtime/StartupConfigFileRegistry.js';
+const isNodeProcess = () => {
+    return typeof process !== 'undefined' && typeof process.cwd === 'function';
+};
+const readEnvString = (key, fallback = '') => {
+    const anyEnv = Env;
+    const fromEnv = typeof anyEnv.get === 'function' ? anyEnv.get(key, fallback) : fallback;
+    if (typeof fromEnv === 'string' && fromEnv.trim() !== '')
+        return fromEnv;
+    if (typeof process !== 'undefined') {
+        const raw = process.env?.[key];
+        if (typeof raw === 'string' && raw.trim() !== '')
+            return raw;
+    }
+    return fromEnv ?? '';
+};
+const readWorkersEnvString = (key) => {
+    const workerValue = Cloudflare.getWorkersVar(key);
+    if (workerValue !== null && workerValue.trim() !== '')
+        return workerValue;
+    return '';
+};
+const readWorkersFallbackString = (workersKey, fallbackKey) => {
+    const workerValue = readWorkersEnvString(workersKey);
+    if (workerValue.trim() !== '')
+        return workerValue;
+    // Also check if the fallback key is present in the Workers bindings (e.g. DB_PASSWORD)
+    const fallbackWorkerValue = readWorkersEnvString(fallbackKey);
+    if (fallbackWorkerValue.trim() !== '')
+        return fallbackWorkerValue;
+    return readEnvString(fallbackKey, '');
+};
+const readWorkersFallbackInt = (workersKey, fallbackKey, fallback) => {
+    const raw = readWorkersFallbackString(workersKey, fallbackKey);
+    if (raw.trim() === '')
+        return fallback;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) ? parsed : fallback;
+};
+const isExplicitEnvValue = (key) => {
+    if (!isNodeProcess())
+        return false;
+    const direct = Env[key];
+    if (typeof direct === 'string' && direct.trim() !== '')
+        return true;
+    const raw = process.env[key] ?? Env.get(key, '');
+    return typeof raw === 'string' && raw.trim() !== '';
+};
+const looksLikeSqliteFilePath = (value) => {
+    const v = String(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 Env.SERVICE_NAME === 'string' && Env.SERVICE_NAME.trim() !== ''
+        ? Env.SERVICE_NAME
+        : readEnvString('SERVICE_NAME', '');
+    if (service.trim() !== '')
+        return toSafeDbBasename(service);
+    const app = typeof Env.APP_NAME === 'string' && Env.APP_NAME.trim() !== ''
+        ? Env.APP_NAME
+        : readEnvString('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 normalizeReadHosts = (primaryHost, hosts) => {
+    if (hosts === undefined || hosts.length === 0)
+        return undefined;
+    const primary = String(primaryHost ?? '').trim();
+    const filtered = hosts.filter((host) => host !== '' && host !== primary);
+    return filtered.length > 0 ? filtered : undefined;
+};
+const getDefaultConnection = (connections) => {
+    const envSelectedRaw = Env.get('DB_CONNECTION', '');
+    const value = String(envSelectedRaw ?? '').trim();
+    if (value.length > 0 && hasOwn(connections, value))
+        return value;
+    if (envSelectedRaw.trim().length > 0) {
+        throw ErrorFactory.createConfigError(`Database connection not configured: ${value}`);
+    }
+    return hasOwn(connections, 'sqlite') ? 'sqlite' : (Object.keys(connections)[0] ?? 'sqlite');
+};
+const getDatabaseConnection = (config) => {
+    const connName = config.default;
+    const resolved = config.connections[connName];
+    if (resolved !== undefined)
+        return resolved;
+    // Backwards-compatible fallback.
+    const sqliteFallback = config.connections['sqlite'];
+    if (sqliteFallback !== undefined)
+        return sqliteFallback;
+    const first = Object.values(config.connections)[0];
+    if (first !== undefined)
+        return first;
+    throw ErrorFactory.createConfigError(`No database connections are configured (default='${connName}').`);
+};
+const connections = {
+    sqlite: {
+        driver: 'sqlite',
+        database: resolveDefaultSqliteDatabasePath(),
+        migrations: 'database/migrations',
+    },
+    d1: {
+        driver: 'd1',
+    },
+    'd1-remote': {
+        driver: 'd1-remote',
+    },
+    postgresql: {
+        driver: 'postgresql',
+        host: readWorkersFallbackString('WORKERS_PG_HOST', 'DB_HOST') || Env.DB_HOST,
+        port: readWorkersFallbackInt('WORKERS_PG_PORT', 'DB_PORT_POSTGRESQL', Env.DB_PORT_POSTGRESQL),
+        database: readWorkersFallbackString('WORKERS_PG_DATABASE', 'DB_DATABASE_POSTGRESQL') ||
+            Env.DB_DATABASE_POSTGRESQL,
+        username: readWorkersFallbackString('WORKERS_PG_USER', 'DB_USERNAME_POSTGRESQL') ||
+            Env.DB_USERNAME_POSTGRESQL,
+        password: readWorkersFallbackString('WORKERS_PG_PASSWORD', 'DB_PASSWORD_POSTGRESQL') ||
+            Env.DB_PASSWORD_POSTGRESQL,
+        ssl: Env.getBool('DB_SSL', false),
+        readHosts: normalizeReadHosts(readWorkersFallbackString('WORKERS_PG_HOST', 'DB_HOST') || Env.DB_HOST, parseReadHosts(readWorkersFallbackString('WORKERS_PG_READ_HOSTS', 'DB_READ_HOSTS_POSTGRESQL') ||
+            Env.DB_READ_HOSTS_POSTGRESQL)),
+        pooling: {
+            enabled: Env.getBool('DB_POOLING', true),
+            min: Env.getInt('DB_POOL_MIN', 5),
+            max: Env.getInt('DB_POOL_MAX', 20),
+            idleTimeout: Env.getInt('DB_IDLE_TIMEOUT', 30000),
+            connectionTimeout: Env.getInt('DB_CONNECTION_TIMEOUT', 10000),
+        },
+    },
+    mysql: {
+        driver: 'mysql',
+        host: readWorkersFallbackString('WORKERS_MYSQL_HOST', 'DB_HOST') || Env.DB_HOST,
+        port: readWorkersFallbackInt('WORKERS_MYSQL_PORT', 'DB_PORT', Env.DB_PORT),
+        database: readWorkersFallbackString('WORKERS_MYSQL_DATABASE', 'DB_DATABASE') || Env.DB_DATABASE,
+        username: readWorkersFallbackString('WORKERS_MYSQL_USER', 'DB_USERNAME') || Env.DB_USERNAME,
+        password: readWorkersFallbackString('WORKERS_MYSQL_PASSWORD', 'DB_PASSWORD') || Env.DB_PASSWORD,
+        readHosts: normalizeReadHosts(readWorkersFallbackString('WORKERS_MYSQL_HOST', 'DB_HOST') || Env.DB_HOST, parseReadHosts(readWorkersFallbackString('WORKERS_MYSQL_READ_HOSTS', 'DB_READ_HOSTS') || 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),
+        },
+    },
+    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: normalizeReadHosts(Env.DB_HOST_MSSQL, parseReadHosts(Env.DB_READ_HOSTS_MSSQL)),
+    },
+};
+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'),
+    };
+    const baseMigrations = {
+        directory: 'database/migrations',
+        extension: Env.get('DB_MIGRATION_EXT', '.ts'),
+    };
+    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 = 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

@@ -0,0 +1,227 @@
+/**
+ * Environment Configuration
+ * Type-safe access to environment variables
+ *
+ * Sealed namespace pattern - all exports through Env namespace
+ * Safe for both Node.js and serverless runtimes (Cloudflare Workers, Deno, Lambda)
+ */
+import type { ProcessLike } from './type';
+export type EnvSource = Record<string, unknown> | (() => Record<string, unknown>);
+export declare const getProcessLike: () => ProcessLike | undefined;
+export declare const dirnameFromExecPath: (execPath: string, platform?: string) => string;
+export declare const get: (key: string, defaultValue?: string) => string;
+export declare const getInt: (key: string, defaultValue: number) => number;
+export declare const getFloat: (key: string, defaultValue?: number) => number;
+export declare const getBool: (key: string, defaultValue?: boolean) => boolean;
+export declare const set: (key: string, value: string) => void;
+export declare const unset: (key: string) => void;
+export declare const setSource: (source: EnvSource | null) => void;
+export declare const snapshot: () => Record<string, string>;
+export declare const getDefaultLogLevel: () => "debug" | "info" | "warn" | "error";
+export declare const ZT_PROXY_TIMEOUT_MS: number;
+export declare const Env: Readonly<{
+    get: (key: string, defaultValue?: string) => string;
+    getInt: (key: string, defaultValue: number) => number;
+    getBool: (key: string, defaultValue?: boolean) => boolean;
+    getFloat: (key: string, defaultValue?: number) => number;
+    set: (key: string, value: string) => void;
+    unset: (key: string) => void;
+    setSource: (source: EnvSource | null) => void;
+    snapshot: () => Record<string, string>;
+    NODE_ENV: NodeJS.ProcessEnv["NODE_ENV"];
+    PORT: number;
+    HOST: string;
+    BASE_URL: string;
+    APP_NAME: string;
+    APP_KEY: string;
+    APP_PREVIOUS_KEYS: string;
+    DB_CONNECTION: string;
+    DB_HOST: string;
+    DB_PORT: number;
+    DB_DATABASE: string;
+    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;
+    D1_REMOTE_KEY_ID: string;
+    D1_REMOTE_SECRET: string;
+    D1_REMOTE_MODE: string;
+    MYSQL_PROXY_URL: string;
+    MYSQL_PROXY_HOST: string;
+    MYSQL_PROXY_PORT: number;
+    MYSQL_PROXY_MAX_BODY_BYTES: number;
+    MYSQL_PROXY_POOL_LIMIT: number;
+    MYSQL_PROXY_KEY_ID: string;
+    MYSQL_PROXY_SECRET: string;
+    MYSQL_PROXY_TIMEOUT_MS: number;
+    MYSQL_PROXY_REQUIRE_SIGNING: boolean;
+    MYSQL_PROXY_SIGNING_WINDOW_MS: number;
+    POSTGRES_PROXY_URL: string;
+    POSTGRES_PROXY_HOST: string;
+    POSTGRES_PROXY_PORT: number;
+    POSTGRES_PROXY_MAX_BODY_BYTES: number;
+    POSTGRES_PROXY_POOL_LIMIT: number;
+    POSTGRES_PROXY_KEY_ID: string;
+    POSTGRES_PROXY_SECRET: string;
+    POSTGRES_PROXY_TIMEOUT_MS: number;
+    POSTGRES_PROXY_REQUIRE_SIGNING: boolean;
+    POSTGRES_PROXY_SIGNING_WINDOW_MS: number;
+    REDIS_PROXY_URL: string;
+    REDIS_PROXY_HOST: string;
+    REDIS_PROXY_PORT: number;
+    REDIS_PROXY_MAX_BODY_BYTES: number;
+    REDIS_PROXY_KEY_ID: string;
+    REDIS_PROXY_SECRET: string;
+    REDIS_PROXY_TIMEOUT_MS: number;
+    REDIS_PROXY_REQUIRE_SIGNING: boolean;
+    REDIS_PROXY_SIGNING_WINDOW_MS: number;
+    USE_REDIS_PROXY: boolean;
+    SMTP_PROXY_URL: string;
+    SMTP_PROXY_HOST: string;
+    SMTP_PROXY_PORT: number;
+    SMTP_PROXY_MAX_BODY_BYTES: number;
+    SMTP_PROXY_KEY_ID: string;
+    SMTP_PROXY_SECRET: string;
+    SMTP_PROXY_TIMEOUT_MS: number;
+    SMTP_PROXY_REQUIRE_SIGNING: boolean;
+    SMTP_PROXY_SIGNING_WINDOW_MS: number;
+    USE_SMTP_PROXY: boolean;
+    MONGODB_PROXY_URL: string;
+    MONGODB_PROXY_HOST: string;
+    MONGODB_PROXY_PORT: number;
+    MONGODB_PROXY_MAX_BODY_BYTES: number;
+    MONGODB_PROXY_KEY_ID: string;
+    MONGODB_PROXY_SECRET: string;
+    MONGODB_PROXY_TIMEOUT_MS: number;
+    MONGODB_PROXY_REQUIRE_SIGNING: boolean;
+    MONGODB_PROXY_SIGNING_WINDOW_MS: number;
+    USE_MONGODB_PROXY: boolean;
+    SQLSERVER_PROXY_URL: string;
+    SQLSERVER_PROXY_HOST: string;
+    SQLSERVER_PROXY_PORT: number;
+    SQLSERVER_PROXY_MAX_BODY_BYTES: number;
+    SQLSERVER_PROXY_POOL_LIMIT: number;
+    SQLSERVER_PROXY_KEY_ID: string;
+    SQLSERVER_PROXY_SECRET: string;
+    SQLSERVER_PROXY_TIMEOUT_MS: number;
+    SQLSERVER_PROXY_REQUIRE_SIGNING: boolean;
+    SQLSERVER_PROXY_SIGNING_WINDOW_MS: number;
+    USE_SQLSERVER_PROXY: boolean;
+    KV_REMOTE_URL: string;
+    KV_REMOTE_KEY_ID: string;
+    KV_REMOTE_SECRET: string;
+    KV_REMOTE_NAMESPACE: string;
+    ZT_PROXY_SIGNING_WINDOW_MS: number;
+    ZT_PROXY_TIMEOUT_MS: number;
+    CACHE_DRIVER: string;
+    REDIS_HOST: string;
+    REDIS_PORT: number;
+    REDIS_PASSWORD: string;
+    REDIS_DB: number;
+    REDIS_URL: string;
+    MONGO_URI: string;
+    MONGO_DB: string;
+    QUEUE_CONNECTION: string;
+    QUEUE_DRIVER: string;
+    QUEUE_HTTP_PROXY_ENABLED: boolean;
+    QUEUE_HTTP_PROXY_GATEWAY_ENABLED: boolean;
+    QUEUE_HTTP_PROXY_URL: string;
+    QUEUE_HTTP_PROXY_PATH: string;
+    QUEUE_HTTP_PROXY_KEY_ID: string;
+    QUEUE_HTTP_PROXY_KEY: string;
+    QUEUE_HTTP_PROXY_TIMEOUT_MS: number;
+    QUEUE_HTTP_PROXY_MAX_SKEW_MS: number;
+    QUEUE_HTTP_PROXY_NONCE_TTL_MS: number;
+    QUEUE_HTTP_PROXY_MIDDLEWARE: string;
+    RATE_LIMIT_STORE: string;
+    RATE_LIMIT_DRIVER: string;
+    RATE_LIMIT_KEY_PREFIX: string;
+    NOTIFICATION_DRIVER: string;
+    TERMII_API_KEY: string;
+    TERMII_SENDER: string;
+    AWS_REGION: string;
+    AWS_LAMBDA_FUNCTION_NAME: string;
+    AWS_LAMBDA_FUNCTION_VERSION: string;
+    AWS_EXECUTION_ENV: string;
+    LAMBDA_TASK_ROOT: string;
+    MICROSERVICES: string;
+    SERVICES: string;
+    MICROSERVICES_TRACING: boolean;
+    MICROSERVICES_TRACING_RATE: number;
+    DATABASE_ISOLATION: string;
+    SERVICE_API_KEY: string;
+    SERVICE_JWT_SECRET: string;
+    DEBUG: boolean;
+    ENABLE_MICROSERVICES: boolean;
+    TOKEN_TTL: number;
+    TOKEN_LENGTH: number;
+    CSRF_STORE: string;
+    CSRF_DRIVER: string;
+    CSRF_REDIS_DB: number;
+    JWT_REVOCATION_DRIVER: string;
+    JWT_REVOCATION_DB_CONNECTION: string;
+    JWT_REVOCATION_DB_TABLE: string;
+    JWT_REVOCATION_REDIS_DB: number;
+    JWT_REVOCATION_REDIS_PREFIX: string;
+    JWT_REVOCATION_KV_BINDING: string;
+    JWT_REVOCATION_KV_PREFIX: string;
+    ENCRYPTION_CIPHER: string;
+    ENVIRONMENT: string;
+    REQUEST_TIMEOUT: number;
+    APP_TIMEZONE: string;
+    MAX_BODY_SIZE: number;
+    SHUTDOWN_TIMEOUT: number;
+    SSE_HEARTBEAT_INTERVAL: number;
+    SSE_SNAPSHOT_INTERVAL: number;
+    LOG_LEVEL: "debug" | "info" | "warn" | "error";
+    LOG_FORMAT: string;
+    LOG_CHANNEL: string;
+    DISABLE_LOGGING: boolean;
+    LOG_HTTP_REQUEST: boolean;
+    LOG_TO_FILE: boolean;
+    LOG_ROTATION_SIZE: number;
+    LOG_ROTATION_DAYS: number;
+    CLOUDFLARE_WORKER: boolean;
+    WORKER_ENABLED: boolean;
+    DOCKER_WORKER: boolean;
+    ZINTRUST_PROJECT_ROOT: string;
+    ZINTRUST_ALLOW_POSTINSTALL: string;
+    ZINTRUST_ENV_FILE: string;
+    ZINTRUST_SECRETS_MANIFEST: string;
+    ZINTRUST_ENV_IN_FILE: string;
+    ZINTRUST_SECRETS_PROVIDER: string;
+    ZINTRUST_ALLOW_AUTO_INSTALL: string;
+    WORKER_SHUTDOWN_ON_APP_EXIT: boolean;
+    CLOUDFLARE_ACCOUNT_ID: string;
+    CLOUDFLARE_API_TOKEN: string;
+    CLOUDFLARE_KV_NAMESPACE_ID: string;
+    AWS_DEFAULT_REGION: string;
+    AWS_ACCESS_KEY_ID: string;
+    AWS_SECRET_ACCESS_KEY: string;
+    AWS_SESSION_TOKEN: string;
+    CI: string;
+    HOME: string;
+    USERPROFILE: string;
+    TEMPLATE_COPYRIGHT: string;
+    SERVICE_NAME: string;
+    APP_MODE: string;
+    APP_PORT: number;
+    RUNTIME: string;
+    NODE_BIN_DIR: string;
+    SAFE_PATH: string;
+}>;
+export declare const buildRedisUrl: () => string;
+//# sourceMappingURL=env.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../src/config/env.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAsClF,eAAO,MAAM,cAAc,QAAO,WAAW,GAAG,SAAwB,CAAC;AAEzE,eAAO,MAAM,mBAAmB,GAAI,UAAU,MAAM,EAAE,WAAW,MAAM,KAAG,MAKzE,CAAC;AAGF,eAAO,MAAM,GAAG,GAAI,KAAK,MAAM,EAAE,eAAe,MAAM,KAAG,MAIxD,CAAC;AAEF,eAAO,MAAM,MAAM,GAAI,KAAK,MAAM,EAAE,cAAc,MAAM,KAAG,MAI1D,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,EAAE,eAAe,MAAM,KAAG,MAI7D,CAAC;AAEF,eAAO,MAAM,OAAO,GAAI,KAAK,MAAM,EAAE,eAAe,OAAO,KAAG,OAI7D,CAAC;AAEF,eAAO,MAAM,GAAG,GAAI,KAAK,MAAM,EAAE,OAAO,MAAM,KAAG,IAGhD,CAAC;AAEF,eAAO,MAAM,KAAK,GAAI,KAAK,MAAM,KAAG,IAInC,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,QAAQ,SAAS,GAAG,IAAI,KAAG,IAEpD,CAAC;AAEF,eAAO,MAAM,QAAQ,QAAO,MAAM,CAAC,MAAM,EAAE,MAAM,CAOhD,CAAC;AAEF,eAAO,MAAM,kBAAkB,QAAO,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAKjE,CAAC;AACF,eAAO,MAAM,mBAAmB,QAAuC,CAAC;AAKxE,eAAO,MAAM,GAAG;eA3DS,MAAM,iBAAiB,MAAM,KAAG,MAAM;kBAMnC,MAAM,gBAAgB,MAAM,KAAG,MAAM;mBAYpC,MAAM,iBAAiB,OAAO,KAAG,OAAO;oBANvC,MAAM,iBAAiB,MAAM,KAAG,MAAM;eAY3C,MAAM,SAAS,MAAM,KAAG,IAAI;iBAK1B,MAAM,KAAG,IAAI;wBAMN,SAAS,GAAG,IAAI,KAAG,IAAI;oBAI7B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;cAgCJ,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAgOpB,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoFxF,CAAC;AAEH,eAAO,MAAM,aAAa,QAAO,MAchC,CAAC"}