@zintrust/core 0.1.0 → 0.1.2

package/src/config/SecretsManager.js

@@ -6,6 +6,22 @@
 import { Logger } from './logger';
 import { ErrorFactory } from '../exceptions/ZintrustError';
 let instance;
+function pruneCache(cache, maxEntries) {
+    if (cache.size <= maxEntries)
+        return;
+    const now = Date.now();
+    for (const [key, entry] of cache.entries()) {
+        if (entry.expiresAt <= now)
+            cache.delete(key);
+    }
+    // If still large, drop oldest entries (Map preserves insertion order)
+    while (cache.size > maxEntries) {
+        const next = cache.keys().next();
+        if (next.done === true)
+            break;
+        cache.delete(next.value);
+    }
+}
 /**
  * Get secret value from appropriate backend
  */
@@ -15,6 +31,8 @@ async function runGetSecret(config, cache, key, options) {
     if (cached !== undefined && cached.expiresAt > Date.now()) {
         return cached.value;
     }
+    // Opportunistic cleanup if cache has grown
+    pruneCache(cache, 500);
     let value;
     switch (config.platform) {
         case 'aws':
@@ -36,6 +54,7 @@ async function runGetSecret(config, cache, key, options) {
         value,
         expiresAt: Date.now() + ttl,
     });
+    pruneCache(cache, 500);
     return value;
 }
 /**
@@ -109,6 +128,7 @@ const SecretsManagerImpl = {
             /**
              * Rotate secret (trigger new secret generation)
              */
+            // eslint-disable-next-line @typescript-eslint/require-await
             async rotateSecret(_key) {
                 if (config.platform === 'aws') {
                     // AWS Secrets Manager supports automatic rotation
@@ -148,6 +168,7 @@ const SecretsManagerImpl = {
 /**
  * AWS Secrets Manager integration
  */
+// eslint-disable-next-line @typescript-eslint/require-await
 async function getFromAWSSecretsManager(key) {
     try {
         Logger.debug(`[AWS] Getting secret: ${key}`);
@@ -157,14 +178,17 @@ async function getFromAWSSecretsManager(key) {
         throw ErrorFactory.createTryCatchError(`Failed to retrieve secret from AWS: ${error.message}`, error);
     }
 }
+// eslint-disable-next-line @typescript-eslint/require-await
 async function setInAWSSecretsManager(key, _value, _options) {
     Logger.info(`[AWS] Setting secret: ${key}`);
     throw ErrorFactory.createConfigError('AWS SDK not available in core - use wrapper module');
 }
+// eslint-disable-next-line @typescript-eslint/require-await
 async function deleteFromAWSSecretsManager(key) {
     Logger.info(`[AWS] Deleting secret: ${key}`);
     throw ErrorFactory.createConfigError('AWS SDK not available in core - use wrapper module');
 }
+// eslint-disable-next-line @typescript-eslint/require-await
 async function listFromAWSSecretsManager(pattern) {
     Logger.info(`[AWS] Listing secrets with pattern: ${pattern ?? '*'}`);
     return [];
@@ -205,6 +229,7 @@ async function listFromCloudflareKV(config, pattern) {
 /**
  * Deno environment integration
  */
+// eslint-disable-next-line @typescript-eslint/require-await
 async function getFromDenoEnv(key) {
     const value = globalThis['Deno']?.env?.get?.(key);
     if (value === undefined || value === null || value === '') {
@@ -215,6 +240,7 @@ async function getFromDenoEnv(key) {
 /**
  * Local environment variables (Node.js)
  */
+// eslint-disable-next-line @typescript-eslint/require-await
 async function getFromEnv(key) {
     const value = process.env[key];
     if (value === undefined || value === null || value === '') {

package/src/config/StartupConfigValidator.d.ts

@@ -0,0 +1,15 @@
+export type StartupConfigValidationError = {
+    key: string;
+    value: unknown;
+    message: string;
+};
+export type StartupConfigValidationResult = {
+    valid: boolean;
+    errors: StartupConfigValidationError[];
+};
+export declare const StartupConfigValidator: Readonly<{
+    validate(): StartupConfigValidationResult;
+    assertValid(): void;
+}>;
+export default StartupConfigValidator;
+//# sourceMappingURL=StartupConfigValidator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StartupConfigValidator.d.ts","sourceRoot":"","sources":["../../../src/config/StartupConfigValidator.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,4BAA4B,GAAG;IACzC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG;IAC1C,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,4BAA4B,EAAE,CAAC;CACxC,CAAC;AAwFF,eAAO,MAAM,sBAAsB;gBACrB,6BAA6B;mBAuC1B,IAAI;EAQnB,CAAC;AAEH,eAAe,sBAAsB,CAAC"}

package/src/config/StartupConfigValidator.js

@@ -0,0 +1,86 @@
+import { appConfig } from './app';
+import { ErrorFactory } from '../exceptions/ZintrustError';
+const isSensitiveKey = (key) => {
+    const normalized = key.toLowerCase();
+    return (normalized.includes('password') ||
+        normalized.includes('secret') ||
+        normalized.includes('token') ||
+        normalized.includes('key') ||
+        normalized.includes('authorization'));
+};
+const redactValue = (key, value) => {
+    return isSensitiveKey(key) ? '<redacted>' : value;
+};
+const pushError = (errors, key, value, message) => {
+    errors.push({ key, value: redactValue(key, value), message });
+};
+const validateEnum = (errors, key, value, allowed) => {
+    if (!allowed.includes(value)) {
+        pushError(errors, key, value, `${key} must be one of: ${allowed.join(', ')}`);
+    }
+};
+const validateIntRange = (errors, key, value, min, max) => {
+    if (Number.isNaN(value)) {
+        pushError(errors, key, value, `${key} must be a valid integer`);
+        return;
+    }
+    if (value < min || value > max) {
+        pushError(errors, key, value, `${key} must be between ${min} and ${max}`);
+    }
+};
+const validatePositiveInt = (errors, key, value) => {
+    if (Number.isNaN(value)) {
+        pushError(errors, key, value, `${key} must be a valid integer`);
+        return;
+    }
+    if (value <= 0) {
+        pushError(errors, key, value, `${key} must be greater than 0`);
+    }
+};
+const getProcessLike = () => {
+    return typeof process === 'undefined' ? undefined : process;
+};
+const getEnvString = (key, defaultValue) => {
+    const proc = getProcessLike();
+    const env = proc?.env ?? {};
+    return env[key] ?? defaultValue;
+};
+const getEnvInt = (key, defaultValue) => {
+    const raw = getEnvString(key, String(defaultValue));
+    return Number.parseInt(raw, 10);
+};
+export const StartupConfigValidator = Object.freeze({
+    validate() {
+        const errors = [];
+        const nodeEnv = getEnvString('NODE_ENV', 'development');
+        validateEnum(errors, 'NODE_ENV', nodeEnv, ['development', 'production', 'testing', 'test']);
+        const appPort = getEnvInt('APP_PORT', 3000);
+        validateIntRange(errors, 'APP_PORT', appPort, 1, 65535);
+        const logFormat = getEnvString('LOG_FORMAT', 'text');
+        validateEnum(errors, 'LOG_FORMAT', logFormat, ['text', 'json']);
+        const logLevel = getEnvString('LOG_LEVEL', 'debug');
+        validateEnum(errors, 'LOG_LEVEL', logLevel, ['debug', 'info', 'warn', 'error']);
+        const logRotationSize = getEnvInt('LOG_ROTATION_SIZE', 10485760);
+        validatePositiveInt(errors, 'LOG_ROTATION_SIZE', logRotationSize);
+        const logRotationDays = getEnvInt('LOG_ROTATION_DAYS', 7);
+        validatePositiveInt(errors, 'LOG_ROTATION_DAYS', logRotationDays);
+        const startupHealthTimeoutMs = getEnvInt('STARTUP_HEALTH_TIMEOUT_MS', 2500);
+        validatePositiveInt(errors, 'STARTUP_HEALTH_TIMEOUT_MS', startupHealthTimeoutMs);
+        if (appConfig.isProduction()) {
+            const appKey = getEnvString('APP_KEY', '');
+            if (appKey.trim().length < 16) {
+                pushError(errors, 'APP_KEY', appKey, 'APP_KEY must be set and at least 16 characters in production');
+            }
+        }
+        return { valid: errors.length === 0, errors };
+    },
+    assertValid() {
+        const result = StartupConfigValidator.validate();
+        if (result.valid)
+            return;
+        throw ErrorFactory.createConfigError('Invalid startup configuration', {
+            errors: result.errors,
+        });
+    },
+});
+export default StartupConfigValidator;

package/src/config/app.d.ts

@@ -3,6 +3,7 @@
  * Core application settings
  * Sealed namespace for immutability
  */
+type StartMode = 'development' | 'production' | 'testing';
 declare const getSafeEnv: () => NodeJS.ProcessEnv;
 export declare const appConfig: Readonly<{
     /**
@@ -12,7 +13,7 @@ export declare const appConfig: Readonly<{
     /**
      * Application environment
      */
-    readonly environment: "development" | "production" | "testing";
+    readonly environment: StartMode;
     /**
      * Application port
      */

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

@@ -1 +1 @@
-{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../../src/config/app.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,QAAA,MAAM,UAAU,QAAO,MAAM,CAAC,UAkB7B,CAAC;AAmEF,eAAO,MAAM,SAAS;IAhEpB;;OAEG;;IAGH;;OAEG;0BAC0B,aAAa,GAAG,YAAY,GAAG,SAAS;IAErE;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;kCACc,OAAO;IAIxB;;OAEG;iCACa,OAAO;IAIvB;;OAEG;8BACU,OAAO;IAIpB;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;+BA/EkB,MAAM,CAAC,UAAU;EAqFY,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,CAAC;AAEtB,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC"}
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../../src/config/app.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,KAAK,SAAS,GAAG,aAAa,GAAG,YAAY,GAAG,SAAS,CAAC;AAsC1D,QAAA,MAAM,UAAU,QAAO,MAAM,CAAC,UAuB7B,CAAC;AA0FF,eAAO,MAAM,SAAS;IA5EpB;;OAEG;;IAMH;;OAEG;;IAGH;;OAEG;;IAMH;;OAEG;;IAMH;;OAEG;kCACc,OAAO;IAIxB;;OAEG;iCACa,OAAO;IAIvB;;OAEG;8BACU,OAAO;IAIpB;;OAEG;;IAMH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;+BA3GkB,MAAM,CAAC,UAAU;EAiHY,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,CAAC;AAEtB,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC"}

package/src/config/app.js

@@ -4,39 +4,87 @@
  * Sealed namespace for immutability
  */
 import { Env } from './env';
+const getProcessLike = () => {
+    return typeof process === 'undefined' ? undefined : process;
+};
+const readEnvString = (key, defaultValue = '') => {
+    const anyEnv = Env;
+    if (typeof anyEnv.get === 'function') {
+        return anyEnv.get(key, defaultValue);
+    }
+    const proc = getProcessLike();
+    const raw = proc?.env?.[key];
+    return raw ?? defaultValue;
+};
+const readEnvInt = (key, defaultValue) => {
+    const anyEnv = Env;
+    if (typeof anyEnv.getInt === 'function') {
+        return anyEnv.getInt(key, defaultValue);
+    }
+    const raw = readEnvString(key, String(defaultValue));
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isNaN(parsed) ? defaultValue : parsed;
+};
+const readEnvBool = (key, defaultValue) => {
+    const anyEnv = Env;
+    if (typeof anyEnv.getBool === 'function') {
+        return anyEnv.getBool(key, defaultValue);
+    }
+    const raw = readEnvString(key, defaultValue ? 'true' : 'false');
+    return raw.toLowerCase() === 'true' || raw === '1';
+};
 const getSafeEnv = () => {
     const baseEnv = typeof process === 'undefined' ? {} : process.env;
     return {
         ...baseEnv,
         // Ensure required keys exist (env.d.ts augments ProcessEnv with required fields)
-        NODE_ENV: baseEnv.NODE_ENV ?? Env.NODE_ENV,
-        USE_RAW_QRY: baseEnv.USE_RAW_QRY ?? (Env.get('USE_RAW_QRY') || undefined),
-        SERVICE_API_KEY: baseEnv.SERVICE_API_KEY ?? Env.get('SERVICE_API_KEY', ''),
-        SERVICE_JWT_SECRET: baseEnv.SERVICE_JWT_SECRET ?? Env.get('SERVICE_JWT_SECRET', ''),
-        BASE_URL: baseEnv.BASE_URL ?? Env.get('BASE_URL', ''),
-        MODE: baseEnv.MODE ?? Env.get('MODE', ''),
+        NODE_ENV: baseEnv.NODE_ENV ??
+            readEnvString('NODE_ENV', 'development'),
+        USE_RAW_QRY: baseEnv.USE_RAW_QRY ?? (readEnvString('USE_RAW_QRY', '') || undefined),
+        SERVICE_API_KEY: baseEnv.SERVICE_API_KEY ?? readEnvString('SERVICE_API_KEY', ''),
+        SERVICE_JWT_SECRET: baseEnv.SERVICE_JWT_SECRET ?? readEnvString('SERVICE_JWT_SECRET', ''),
+        BASE_URL: baseEnv['BASE_URL'] ?? readEnvString('BASE_URL', ''),
+        MODE: baseEnv['MODE'] ?? readEnvString('MODE', ''),
         // Hardening for child-process usage
-        PATH: Env.SAFE_PATH,
+        PATH: typeof Env.SAFE_PATH === 'string'
+            ? Env.SAFE_PATH
+            : (baseEnv['PATH'] ?? ''),
         npm_config_scripts_prepend_node_path: 'true',
     };
 };
+const normalizeMode = () => {
+    const value = (typeof Env.NODE_ENV === 'string'
+        ? Env.NODE_ENV
+        : readEnvString('NODE_ENV', 'development'));
+    if (value === 'production' || value === 'pro' || value === 'prod')
+        return 'production';
+    if (value === 'testing' || value === 'test')
+        return 'testing';
+    return 'development';
+};
 const appConfigObj = {
     /**
      * Application name
      */
-    name: Env.APP_NAME,
+    name: typeof Env.APP_NAME === 'string'
+        ? Env.APP_NAME
+        : readEnvString('APP_NAME', 'ZinTrust'),
     /**
      * Application environment
      */
-    environment: Env.NODE_ENV,
+    environment: normalizeMode(),
     /**
      * Application port
      */
-    port: Env.PORT,
+    port: typeof Env.PORT === 'number'
+        ? Env.PORT
+        : readEnvInt('APP_PORT', 3000),
     /**
      * Application host
      */
-    host: Env.HOST,
+    host: typeof Env.HOST === 'string'
+        ? Env.HOST
+        : readEnvString('HOST', 'localhost'),
     /**
      * Is development environment
      */
@@ -58,19 +106,21 @@ const appConfigObj = {
     /**
      * Application debug mode
      */
-    debug: Env.DEBUG,
+    debug: typeof Env.DEBUG === 'boolean'
+        ? Env.DEBUG
+        : readEnvBool('DEBUG', false),
     /**
      * Application timezone
      */
-    timezone: Env.get('APP_TIMEZONE', 'UTC'),
+    timezone: readEnvString('APP_TIMEZONE', 'UTC'),
     /**
      * Request timeout (milliseconds)
      */
-    requestTimeout: Env.getInt('REQUEST_TIMEOUT', 30000),
+    requestTimeout: readEnvInt('REQUEST_TIMEOUT', 30000),
     /**
      * Max request body size
      */
-    maxBodySize: Env.get('MAX_BODY_SIZE', '10mb'),
+    maxBodySize: readEnvString('MAX_BODY_SIZE', '10mb'),
     getSafeEnv,
 };
 export const appConfig = Object.freeze(appConfigObj);

package/src/config/broadcast.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Broadcast Configuration
+ *
+ * Centralizes broadcast driver selection and provider env mappings.
+ * Driver selection must be dynamic (tests may mutate process.env).
+ */
+export type KnownBroadcastDriverName = 'inmemory' | 'pusher' | 'redis' | 'redishttps';
+export type InMemoryBroadcastDriverConfig = {
+    driver: 'inmemory';
+};
+export type PusherBroadcastDriverConfig = {
+    driver: 'pusher';
+    appId: string;
+    key: string;
+    secret: string;
+    cluster: string;
+    useTLS: boolean;
+};
+export type RedisBroadcastDriverConfig = {
+    driver: 'redis';
+    host: string;
+    port: number;
+    password: string;
+    channelPrefix: string;
+};
+export type RedisHttpsBroadcastDriverConfig = {
+    driver: 'redishttps';
+    endpoint: string;
+    token: string;
+    channelPrefix: string;
+};
+export type KnownBroadcastDriverConfig = InMemoryBroadcastDriverConfig | PusherBroadcastDriverConfig | RedisBroadcastDriverConfig | RedisHttpsBroadcastDriverConfig;
+declare const _default: Readonly<{
+    /**
+     * Normalized broadcast driver name.
+     *
+     * NOTE: Allows custom driver names (project-specific drivers), so returns string.
+     */
+    readonly getDriverName: () => string;
+    /**
+     * Get a config object for the currently selected driver.
+     * Defaults to inmemory for unknown/unsupported names.
+     */
+    readonly getDriverConfig: () => KnownBroadcastDriverConfig;
+}>;
+export default _default;
+//# sourceMappingURL=broadcast.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"broadcast.d.ts","sourceRoot":"","sources":["../../../src/config/broadcast.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,MAAM,wBAAwB,GAAG,UAAU,GAAG,QAAQ,GAAG,OAAO,GAAG,YAAY,CAAC;AAEtF,MAAM,MAAM,6BAA6B,GAAG;IAC1C,MAAM,EAAE,UAAU,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,MAAM,EAAE,QAAQ,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG;IAC5C,MAAM,EAAE,YAAY,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAClC,6BAA6B,GAC7B,2BAA2B,GAC3B,0BAA0B,GAC1B,+BAA+B,CAAC;;IA6BlC;;;;OAIG;kCACc,MAAM;IAIvB;;;OAGG;oCACgB,0BAA0B;;AAW/C,wBAAiD"}

package/src/config/broadcast.js

@@ -0,0 +1,54 @@
+/**
+ * Broadcast Configuration
+ *
+ * Centralizes broadcast driver selection and provider env mappings.
+ * Driver selection must be dynamic (tests may mutate process.env).
+ */
+import { Env } from './env';
+const normalizeDriverName = (value) => value.trim().toLowerCase();
+const getPusherConfig = () => ({
+    driver: 'pusher',
+    appId: Env.get('PUSHER_APP_ID', ''),
+    key: Env.get('PUSHER_APP_KEY', ''),
+    secret: Env.get('PUSHER_APP_SECRET', ''),
+    cluster: Env.get('PUSHER_APP_CLUSTER', ''),
+    useTLS: Env.getBool('PUSHER_USE_TLS', true),
+});
+const getRedisConfig = () => ({
+    driver: 'redis',
+    host: Env.get('BROADCAST_REDIS_HOST', Env.get('REDIS_HOST', 'localhost')),
+    port: Env.getInt('BROADCAST_REDIS_PORT', Env.getInt('REDIS_PORT', 6379)),
+    password: Env.get('BROADCAST_REDIS_PASSWORD', Env.get('REDIS_PASSWORD', '')),
+    channelPrefix: Env.get('BROADCAST_CHANNEL_PREFIX', 'broadcast:'),
+});
+const getRedisHttpsConfig = () => ({
+    driver: 'redishttps',
+    endpoint: Env.get('REDIS_HTTPS_ENDPOINT', ''),
+    token: Env.get('REDIS_HTTPS_TOKEN', ''),
+    channelPrefix: Env.get('BROADCAST_CHANNEL_PREFIX', 'broadcast:'),
+});
+const broadcastConfigObj = {
+    /**
+     * Normalized broadcast driver name.
+     *
+     * NOTE: Allows custom driver names (project-specific drivers), so returns string.
+     */
+    getDriverName() {
+        return normalizeDriverName(Env.get('BROADCAST_DRIVER', 'inmemory'));
+    },
+    /**
+     * Get a config object for the currently selected driver.
+     * Defaults to inmemory for unknown/unsupported names.
+     */
+    getDriverConfig() {
+        const driver = this.getDriverName();
+        if (driver === 'pusher')
+            return getPusherConfig();
+        if (driver === 'redis')
+            return getRedisConfig();
+        if (driver === 'redishttps')
+            return getRedisHttpsConfig();
+        return { driver: 'inmemory' };
+    },
+};
+export default Object.freeze(broadcastConfigObj);

package/src/config/cache.d.ts

@@ -11,21 +11,19 @@ type RedisCacheDriverConfig = {
     driver: 'redis';
     host: string;
     port: number;
-    password: string | undefined;
-    database: number;
     ttl: number;
 };
-type MemcachedCacheDriverConfig = {
-    driver: 'memcached';
-    servers: string[];
+type MongoCacheDriverConfig = {
+    driver: 'mongodb';
+    uri: string;
+    db: string;
     ttl: number;
 };
-type FileCacheDriverConfig = {
-    driver: 'file';
-    path: string;
+type KvCacheDriverConfig = {
+    driver: 'kv';
     ttl: number;
 };
-type CacheDriverConfig = MemoryCacheDriverConfig | RedisCacheDriverConfig | MemcachedCacheDriverConfig | FileCacheDriverConfig;
+type CacheDriverConfig = MemoryCacheDriverConfig | RedisCacheDriverConfig | MongoCacheDriverConfig | KvCacheDriverConfig;
 export declare const cacheConfig: Readonly<{
     /**
      * Default cache driver
@@ -43,18 +41,16 @@ export declare const cacheConfig: Readonly<{
             driver: "redis";
             host: string;
             port: number;
-            password: string;
-            database: number;
             ttl: number;
         };
-        memcached: {
-            driver: "memcached";
-            servers: string[];
+        mongodb: {
+            driver: "mongodb";
+            uri: string;
+            db: string;
             ttl: number;
         };
-        file: {
-            driver: "file";
-            path: string;
+        kv: {
+            driver: "kv";
             ttl: number;
         };
     };

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

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/config/cache.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,KAAK,uBAAuB,GAAG;IAC7B,MAAM,EAAE,QAAQ,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAChC,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,KAAK,iBAAiB,GAClB,uBAAuB,GACvB,sBAAsB,GACtB,0BAA0B,GAC1B,qBAAqB,CAAC;AA6E1B,eAAO,MAAM,WAAW;IAnDtB;;OAEG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;IA0BH;;OAEG;iBACU,iBAAiB;IAI9B;;OAEG;;IAGH;;OAEG;;EAImD,CAAC;AACzD,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/config/cache.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,KAAK,uBAAuB,GAAG;IAC7B,MAAM,EAAE,QAAQ,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,MAAM,EAAE,SAAS,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,KAAK,mBAAmB,GAAG;IACzB,MAAM,EAAE,IAAI,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,KAAK,iBAAiB,GAClB,uBAAuB,GACvB,sBAAsB,GACtB,sBAAsB,GACtB,mBAAmB,CAAC;AA2ExB,eAAO,MAAM,WAAW;IAjDtB;;OAEG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;IAwBH;;OAEG;iBACU,iBAAiB;IAI9B;;OAEG;;IAGH;;OAEG;;EAImD,CAAC;AACzD,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC"}

package/src/config/cache.js

@@ -6,7 +6,7 @@
 import { Env } from './env';
 const getCacheDriver = (config) => {
     const defaultDriver = config.default;
-    if (Object.prototype.hasOwnProperty.call(config.drivers, defaultDriver)) {
+    if (Object.hasOwn(config.drivers, defaultDriver)) {
         const driverName = defaultDriver;
         return config.drivers[driverName];
     }
@@ -29,19 +29,17 @@ const cacheConfigObj = {
             driver: 'redis',
             host: Env.get('REDIS_HOST', 'localhost'),
             port: Env.getInt('REDIS_PORT', 6379),
-            password: Env.get('REDIS_PASSWORD'),
-            database: Env.getInt('REDIS_DB', 0),
             ttl: Env.getInt('CACHE_REDIS_TTL', 3600),
         },
-        memcached: {
-            driver: 'memcached',
-            servers: Env.get('MEMCACHED_SERVERS', 'localhost:11211').split(','),
-            ttl: Env.getInt('CACHE_MEMCACHED_TTL', 3600),
+        mongodb: {
+            driver: 'mongodb',
+            uri: Env.get('MONGO_URI'),
+            db: Env.get('MONGO_DB', 'zintrust_cache'),
+            ttl: Env.getInt('CACHE_MONGO_TTL', 3600),
         },
-        file: {
-            driver: 'file',
-            path: Env.get('CACHE_FILE_PATH', 'storage/cache'),
-            ttl: Env.getInt('CACHE_FILE_TTL', 3600),
+        kv: {
+            driver: 'kv',
+            ttl: Env.getInt('CACHE_KV_TTL', 3600),
         },
     },
     /**

package/src/config/cloudflare.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Cloudflare Workers Environment Access
+ *
+ * Centralizes access to Workers bindings via globalThis.env.
+ * This keeps runtime-specific globals out of adapters/drivers.
+ */
+import type { DatabaseConfig, ID1Database } from '../orm/DatabaseAdapter';
+export type WorkersEnv = Record<string, unknown>;
+type KVNamespace = {
+    get(key: string, options?: {
+        type: 'text' | 'json' | 'arrayBuffer' | 'stream';
+    }): Promise<unknown>;
+    put(key: string, value: string | ReadableStream | ArrayBuffer | FormData, options?: {
+        expiration?: number;
+        expirationTtl?: number;
+        metadata?: unknown;
+    }): Promise<void>;
+    delete(key: string): Promise<void>;
+};
+export declare const Cloudflare: Readonly<{
+    getWorkersEnv: () => WorkersEnv | null;
+    getD1Binding: (config: DatabaseConfig) => ID1Database | null;
+    getKVBinding: (bindingName?: string) => KVNamespace | null;
+}>;
+export {};
+//# sourceMappingURL=cloudflare.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../../../src/config/cloudflare.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExE,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEjD,KAAK,WAAW,GAAG;IACjB,GAAG,CACD,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,aAAa,GAAG,QAAQ,CAAA;KAAE,GAC7D,OAAO,CAAC,OAAO,CAAC,CAAC;IACpB,GAAG,CACD,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,WAAW,GAAG,QAAQ,EACvD,OAAO,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GAC5E,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpC,CAAC;AA8BF,eAAO,MAAM,UAAU;yBA5BG,UAAU,GAAG,IAAI;2BAOb,cAAc,KAAG,WAAW,GAAG,IAAI;4CAanB,WAAW,GAAG,IAAI;EAY9D,CAAC"}

package/src/config/cloudflare.js

@@ -0,0 +1,38 @@
+/**
+ * Cloudflare Workers Environment Access
+ *
+ * Centralizes access to Workers bindings via globalThis.env.
+ * This keeps runtime-specific globals out of adapters/drivers.
+ */
+const getWorkersEnv = () => {
+    const env = globalThis.env;
+    if (env === undefined || env === null)
+        return null;
+    if (typeof env !== 'object')
+        return null;
+    return env;
+};
+const getD1Binding = (config) => {
+    if (config.d1 !== undefined && config.d1 !== null)
+        return config.d1;
+    const env = getWorkersEnv();
+    const envDb = env === null ? undefined : env['DB'];
+    if (envDb !== undefined)
+        return envDb;
+    const globalDb = globalThis.DB;
+    if (globalDb !== undefined)
+        return globalDb;
+    return null;
+};
+const getKVBinding = (bindingName = 'CACHE') => {
+    const env = getWorkersEnv();
+    if (env === null)
+        return null;
+    const kv = env[bindingName];
+    return kv ?? null;
+};
+export const Cloudflare = Object.freeze({
+    getWorkersEnv,
+    getD1Binding,
+    getKVBinding,
+});

package/src/config/env.d.ts

@@ -48,8 +48,14 @@ export declare const Env: Readonly<{
     ENVIRONMENT: string;
     REQUEST_TIMEOUT: number;
     MAX_BODY_SIZE: number;
+    SHUTDOWN_TIMEOUT: number;
     LOG_LEVEL: "debug" | "info" | "warn" | "error";
+    LOG_FORMAT: string;
     DISABLE_LOGGING: boolean;
+    LOG_HTTP_REQUEST: boolean;
+    LOG_TO_FILE: boolean;
+    LOG_ROTATION_SIZE: number;
+    LOG_ROTATION_DAYS: number;
     NODE_BIN_DIR: string;
     SAFE_PATH: 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;AAkDH,eAAO,MAAM,GAAG;eA9BE,MAAM,iBAAiB,MAAM,KAAG,MAAM;kBAMnC,MAAM,iBAAiB,MAAM,KAAG,MAAM;mBAQrC,MAAM,iBAAiB,OAAO,KAAG,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA8EP,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO;;;;EA6BxF,CAAC"}
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../src/config/env.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAkDH,eAAO,MAAM,GAAG;eA9BE,MAAM,iBAAiB,MAAM,KAAG,MAAM;kBAMnC,MAAM,iBAAiB,MAAM,KAAG,MAAM;mBAQrC,MAAM,iBAAiB,OAAO,KAAG,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA+EP,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO;;;;;;;;;EAkCxF,CAAC"}

package/src/config/env.js

@@ -98,9 +98,15 @@ export const Env = Object.freeze({
     ENVIRONMENT: get('ENVIRONMENT', 'development'),
     REQUEST_TIMEOUT: getInt('REQUEST_TIMEOUT', 30000),
     MAX_BODY_SIZE: getInt('MAX_BODY_SIZE', 10485760),
+    SHUTDOWN_TIMEOUT: getInt('SHUTDOWN_TIMEOUT', 10000),
     // Logging
     LOG_LEVEL: get('LOG_LEVEL', getDefaultLogLevel()),
+    LOG_FORMAT: get('LOG_FORMAT', 'text'),
     DISABLE_LOGGING: getBool('DISABLE_LOGGING', false),
+    LOG_HTTP_REQUEST: getBool('LOG_HTTP_REQUEST', false),
+    LOG_TO_FILE: getBool('LOG_TO_FILE', false),
+    LOG_ROTATION_SIZE: getInt('LOG_ROTATION_SIZE', 10485760),
+    LOG_ROTATION_DAYS: getInt('LOG_ROTATION_DAYS', 7),
     // Paths (safely constructed for Node.js environments)
     NODE_BIN_DIR: (() => {
         try {