@zintrust/core 0.1.0

package/src/config/cache.js

@@ -0,0 +1,62 @@
+/**
+ * Cache Configuration
+ * Caching drivers and settings
+ * Sealed namespace for immutability
+ */
+import { Env } from './env';
+const getCacheDriver = (config) => {
+    const defaultDriver = config.default;
+    if (Object.prototype.hasOwnProperty.call(config.drivers, defaultDriver)) {
+        const driverName = defaultDriver;
+        return config.drivers[driverName];
+    }
+    return config.drivers.memory;
+};
+const cacheConfigObj = {
+    /**
+     * Default cache driver
+     */
+    default: Env.get('CACHE_DRIVER', 'memory'),
+    /**
+     * Cache drivers
+     */
+    drivers: {
+        memory: {
+            driver: 'memory',
+            ttl: Env.getInt('CACHE_MEMORY_TTL', 3600),
+        },
+        redis: {
+            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),
+        },
+        file: {
+            driver: 'file',
+            path: Env.get('CACHE_FILE_PATH', 'storage/cache'),
+            ttl: Env.getInt('CACHE_FILE_TTL', 3600),
+        },
+    },
+    /**
+     * Get cache driver config
+     */
+    getDriver() {
+        return getCacheDriver(this);
+    },
+    /**
+     * 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);

package/src/config/constants.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Framework Constants
+ * Centralized string literals to prevent duplication (SonarQube S1192)
+ * Sealed namespace for immutability
+ */
+declare const HTTP_HEADERS: {
+    readonly CONTENT_TYPE: "Content-Type";
+    readonly ACCEPT: "Accept";
+    readonly AUTHORIZATION: "Authorization";
+    readonly X_TRACE_ID: "X-Trace-Id";
+    readonly X_SERVICE_CALL: "X-Service-Call";
+    readonly X_POWERED_BY: "X-Powered-By";
+    readonly X_CONTENT_TYPE_OPTIONS: "X-Content-Type-Options";
+    readonly X_FRAME_OPTIONS: "X-Frame-Options";
+    readonly X_XSS_PROTECTION: "X-XSS-Protection";
+    readonly REFERRER_POLICY: "Referrer-Policy";
+    readonly CONTENT_SECURITY_POLICY: "Content-Security-Policy";
+};
+declare const MIME_TYPES: {
+    readonly JSON: "application/json";
+    readonly HTML: "text/html";
+    readonly TEXT: "text/plain";
+    readonly JS: "text/javascript";
+    readonly CSS: "text/css";
+    readonly PNG: "image/png";
+    readonly JPG: "image/jpg";
+    readonly GIF: "image/gif";
+    readonly SVG: "image/svg+xml";
+    readonly WAV: "audio/wav";
+    readonly MP4: "video/mp4";
+    readonly WOFF: "application/font-woff";
+    readonly TTF: "application/font-ttf";
+    readonly EOT: "application/vnd.ms-fontobject";
+    readonly OTF: "application/font-otf";
+    readonly WASM: "application/wasm";
+};
+declare const ENV_KEYS: {
+    readonly NODE_ENV: "NODE_ENV";
+    readonly PORT: "PORT";
+    readonly HOST: "HOST";
+    readonly APP_NAME: "APP_NAME";
+    readonly DB_CONNECTION: "DB_CONNECTION";
+    readonly DB_HOST: "DB_HOST";
+    readonly DB_PORT: "DB_PORT";
+    readonly DB_DATABASE: "DB_DATABASE";
+    readonly DB_USERNAME: "DB_USERNAME";
+    readonly DB_PASSWORD: "DB_PASSWORD";
+};
+declare const DEFAULTS: {
+    readonly CONNECTION: "default";
+    readonly DOMAIN: "default";
+    readonly NAMESPACE: "default";
+};
+/**
+ * Constants namespace - sealed for immutability
+ */
+export declare const Constants: Readonly<{
+    HTTP_HEADERS: {
+        readonly CONTENT_TYPE: "Content-Type";
+        readonly ACCEPT: "Accept";
+        readonly AUTHORIZATION: "Authorization";
+        readonly X_TRACE_ID: "X-Trace-Id";
+        readonly X_SERVICE_CALL: "X-Service-Call";
+        readonly X_POWERED_BY: "X-Powered-By";
+        readonly X_CONTENT_TYPE_OPTIONS: "X-Content-Type-Options";
+        readonly X_FRAME_OPTIONS: "X-Frame-Options";
+        readonly X_XSS_PROTECTION: "X-XSS-Protection";
+        readonly REFERRER_POLICY: "Referrer-Policy";
+        readonly CONTENT_SECURITY_POLICY: "Content-Security-Policy";
+    };
+    MIME_TYPES: {
+        readonly JSON: "application/json";
+        readonly HTML: "text/html";
+        readonly TEXT: "text/plain";
+        readonly JS: "text/javascript";
+        readonly CSS: "text/css";
+        readonly PNG: "image/png";
+        readonly JPG: "image/jpg";
+        readonly GIF: "image/gif";
+        readonly SVG: "image/svg+xml";
+        readonly WAV: "audio/wav";
+        readonly MP4: "video/mp4";
+        readonly WOFF: "application/font-woff";
+        readonly TTF: "application/font-ttf";
+        readonly EOT: "application/vnd.ms-fontobject";
+        readonly OTF: "application/font-otf";
+        readonly WASM: "application/wasm";
+    };
+    ENV_KEYS: {
+        readonly NODE_ENV: "NODE_ENV";
+        readonly PORT: "PORT";
+        readonly HOST: "HOST";
+        readonly APP_NAME: "APP_NAME";
+        readonly DB_CONNECTION: "DB_CONNECTION";
+        readonly DB_HOST: "DB_HOST";
+        readonly DB_PORT: "DB_PORT";
+        readonly DB_DATABASE: "DB_DATABASE";
+        readonly DB_USERNAME: "DB_USERNAME";
+        readonly DB_PASSWORD: "DB_PASSWORD";
+    };
+    DEFAULTS: {
+        readonly CONNECTION: "default";
+        readonly DOMAIN: "default";
+        readonly NAMESPACE: "default";
+    };
+}>;
+export { DEFAULTS, ENV_KEYS, HTTP_HEADERS, MIME_TYPES };
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/config/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;CAYR,CAAC;AAEX,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;CAiBN,CAAC;AAEX,QAAA,MAAM,QAAQ;;;;;;;;;;;CAWJ,CAAC;AAEX,QAAA,MAAM,QAAQ;;;;CAIJ,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKpB,CAAC;AAGH,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,UAAU,EAAE,CAAC"}

package/src/config/constants.js

@@ -0,0 +1,64 @@
+/**
+ * Framework Constants
+ * Centralized string literals to prevent duplication (SonarQube S1192)
+ * Sealed namespace for immutability
+ */
+const HTTP_HEADERS = {
+    CONTENT_TYPE: 'Content-Type',
+    ACCEPT: 'Accept',
+    AUTHORIZATION: 'Authorization',
+    X_TRACE_ID: 'X-Trace-Id',
+    X_SERVICE_CALL: 'X-Service-Call',
+    X_POWERED_BY: 'X-Powered-By',
+    X_CONTENT_TYPE_OPTIONS: 'X-Content-Type-Options',
+    X_FRAME_OPTIONS: 'X-Frame-Options',
+    X_XSS_PROTECTION: 'X-XSS-Protection',
+    REFERRER_POLICY: 'Referrer-Policy',
+    CONTENT_SECURITY_POLICY: 'Content-Security-Policy',
+};
+const MIME_TYPES = {
+    JSON: 'application/json',
+    HTML: 'text/html',
+    TEXT: 'text/plain',
+    JS: 'text/javascript',
+    CSS: 'text/css',
+    PNG: 'image/png',
+    JPG: 'image/jpg',
+    GIF: 'image/gif',
+    SVG: 'image/svg+xml',
+    WAV: 'audio/wav',
+    MP4: 'video/mp4',
+    WOFF: 'application/font-woff',
+    TTF: 'application/font-ttf',
+    EOT: 'application/vnd.ms-fontobject',
+    OTF: 'application/font-otf',
+    WASM: 'application/wasm',
+};
+const ENV_KEYS = {
+    NODE_ENV: 'NODE_ENV',
+    PORT: 'PORT',
+    HOST: 'HOST',
+    APP_NAME: 'APP_NAME',
+    DB_CONNECTION: 'DB_CONNECTION',
+    DB_HOST: 'DB_HOST',
+    DB_PORT: 'DB_PORT',
+    DB_DATABASE: 'DB_DATABASE',
+    DB_USERNAME: 'DB_USERNAME',
+    DB_PASSWORD: 'DB_PASSWORD', // NOSONARQUBE
+};
+const DEFAULTS = {
+    CONNECTION: 'default',
+    DOMAIN: 'default',
+    NAMESPACE: 'default',
+};
+/**
+ * Constants namespace - sealed for immutability
+ */
+export const Constants = Object.freeze({
+    HTTP_HEADERS,
+    MIME_TYPES,
+    ENV_KEYS,
+    DEFAULTS,
+});
+// Re-export for backward compatibility
+export { DEFAULTS, ENV_KEYS, HTTP_HEADERS, MIME_TYPES };

package/src/config/database.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Database Configuration
+ * Database connections and pooling settings
+ * Sealed namespace for immutability
+ */
+type SqliteConnectionConfig = {
+    driver: 'sqlite';
+    database: string;
+    migrations: string;
+};
+type PostgresqlConnectionConfig = {
+    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;
+    };
+};
+type MysqlConnectionConfig = {
+    driver: 'mysql';
+    host: string;
+    port: number;
+    database: string;
+    username: string;
+    password: string;
+    pooling: {
+        enabled: boolean;
+        min: number;
+        max: number;
+    };
+};
+type DatabaseConnections = {
+    sqlite: SqliteConnectionConfig;
+    postgresql: PostgresqlConnectionConfig;
+    mysql: MysqlConnectionConfig;
+};
+type DatabaseConnectionName = keyof DatabaseConnections;
+type DatabaseConnectionConfig = DatabaseConnections[DatabaseConnectionName];
+type DatabaseConfigShape = {
+    default: DatabaseConnectionName;
+    connections: DatabaseConnections;
+};
+export declare const databaseConfig: Readonly<{
+    /**
+     * Default database connection
+     */
+    default: keyof DatabaseConnections;
+    /**
+     * Database connections
+     */
+    connections: {
+        sqlite: {
+            driver: "sqlite";
+            database: string;
+            migrations: string;
+        };
+        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
+     */
+    logging: {
+        enabled: boolean;
+        level: string;
+    };
+    /**
+     * Migration settings
+     */
+    migrations: {
+        directory: string;
+        extension: string;
+    };
+    /**
+     * Seeding settings
+     */
+    seeders: {
+        directory: string;
+    };
+}>;
+export type DatabaseConfig = typeof databaseConfig;
+export {};
+//# sourceMappingURL=database.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../src/config/database.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,KAAK,sBAAsB,GAAG;IAC5B,MAAM,EAAE,QAAQ,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAChC,MAAM,EAAE,YAAY,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,OAAO,CAAC;IACb,OAAO,EAAE;QACP,OAAO,EAAE,OAAO,CAAC;QACjB,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,WAAW,EAAE,MAAM,CAAC;QACpB,iBAAiB,EAAE,MAAM,CAAC;KAC3B,CAAC;CACH,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE;QACP,OAAO,EAAE,OAAO,CAAC;QACjB,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;KACb,CAAC;CACH,CAAC;AAEF,KAAK,mBAAmB,GAAG;IACzB,MAAM,EAAE,sBAAsB,CAAC;IAC/B,UAAU,EAAE,0BAA0B,CAAC;IACvC,KAAK,EAAE,qBAAqB,CAAC;CAC9B,CAAC;AAEF,KAAK,sBAAsB,GAAG,MAAM,mBAAmB,CAAC;AACxD,KAAK,wBAAwB,GAAG,mBAAmB,CAAC,sBAAsB,CAAC,CAAC;AAE5E,KAAK,mBAAmB,GAAG;IACzB,OAAO,EAAE,sBAAsB,CAAC;IAChC,WAAW,EAAE,mBAAmB,CAAC;CAClC,CAAC;AA6FF,eAAO,MAAM,cAAc;IA5EzB;;OAEG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsCH;;OAEG;wBACiB,mBAAmB,GAAG,wBAAwB;IAIlE;;OAEG;;;;;IAMH;;OAEG;;;;;IAMH;;OAEG;;;;EAMyD,CAAC;AAC/D,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC"}

package/src/config/database.js

@@ -0,0 +1,89 @@
+/**
+ * Database Configuration
+ * Database connections and pooling settings
+ * Sealed namespace for immutability
+ */
+import { Env } from './env';
+const isDatabaseConnectionName = (value) => {
+    return value === 'sqlite' || value === 'postgresql' || value === 'mysql';
+};
+const getDefaultConnection = () => {
+    const value = Env.DB_CONNECTION;
+    return isDatabaseConnectionName(value) ? value : 'sqlite';
+};
+const getDatabaseConnection = (config) => {
+    const connName = config.default;
+    return config.connections[connName];
+};
+const databaseConfigObj = {
+    /**
+     * Default database connection
+     */
+    default: getDefaultConnection(),
+    /**
+     * Database connections
+     */
+    connections: {
+        sqlite: {
+            driver: 'sqlite',
+            database: Env.DB_DATABASE,
+            migrations: 'database/migrations',
+        },
+        postgresql: {
+            driver: 'postgresql',
+            host: Env.DB_HOST,
+            port: Env.DB_PORT,
+            database: Env.DB_DATABASE,
+            username: Env.DB_USERNAME,
+            password: Env.DB_PASSWORD,
+            ssl: Env.getBool('DB_SSL', false),
+            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: Env.DB_HOST,
+            port: Env.DB_PORT,
+            database: Env.DB_DATABASE,
+            username: Env.DB_USERNAME,
+            password: Env.DB_PASSWORD,
+            pooling: {
+                enabled: Env.getBool('DB_POOLING', true),
+                min: Env.getInt('DB_POOL_MIN', 5),
+                max: Env.getInt('DB_POOL_MAX', 20),
+            },
+        },
+    },
+    /**
+     * Get current connection config
+     */
+    getConnection() {
+        return getDatabaseConnection(this);
+    },
+    /**
+     * Enable query logging
+     */
+    logging: {
+        enabled: Env.DEBUG,
+        level: Env.get('DB_LOG_LEVEL', 'debug'),
+    },
+    /**
+     * Migration settings
+     */
+    migrations: {
+        directory: 'database/migrations',
+        extension: Env.get('DB_MIGRATION_EXT', '.ts'),
+    },
+    /**
+     * Seeding settings
+     */
+    seeders: {
+        directory: 'database/seeders',
+    },
+};
+export const databaseConfig = Object.freeze(databaseConfigObj);

package/src/config/env.d.ts

@@ -0,0 +1,56 @@
+/**
+ * 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)
+ */
+export declare const Env: Readonly<{
+    get: (key: string, defaultValue?: string) => string;
+    getInt: (key: string, defaultValue?: number) => number;
+    getBool: (key: string, defaultValue?: boolean) => boolean;
+    NODE_ENV: string;
+    PORT: number;
+    HOST: string;
+    APP_NAME: string;
+    APP_KEY: string;
+    DB_CONNECTION: string;
+    DB_HOST: string;
+    DB_PORT: number;
+    DB_DATABASE: string;
+    DB_USERNAME: string;
+    DB_PASSWORD: string;
+    DB_READ_HOSTS: string;
+    D1_DATABASE_ID: string;
+    KV_NAMESPACE_ID: string;
+    CACHE_DRIVER: string;
+    REDIS_HOST: string;
+    REDIS_PORT: number;
+    REDIS_PASSWORD: string;
+    MONGO_URI: string;
+    MONGO_DB: 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;
+    ENVIRONMENT: string;
+    REQUEST_TIMEOUT: number;
+    MAX_BODY_SIZE: number;
+    LOG_LEVEL: "debug" | "info" | "warn" | "error";
+    DISABLE_LOGGING: boolean;
+    NODE_BIN_DIR: string;
+    SAFE_PATH: 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;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"}

package/src/config/env.js

@@ -0,0 +1,133 @@
+/**
+ * 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)
+ */
+const getProcessLike = () => {
+    return typeof process === 'undefined' ? undefined : process;
+};
+const dirnameFromExecPath = (execPath, platform) => {
+    const separator = platform === 'win32' ? '\\' : '/';
+    const lastSep = execPath.lastIndexOf(separator);
+    if (lastSep <= 0)
+        return '';
+    return execPath.slice(0, lastSep);
+};
+// Private helper functions
+const get = (key, defaultValue) => {
+    const proc = getProcessLike();
+    const env = proc?.env ?? {};
+    return env[key] ?? defaultValue ?? '';
+};
+const getInt = (key, defaultValue) => {
+    const proc = getProcessLike();
+    const env = proc?.env ?? {};
+    const value = env[key];
+    if (value === undefined || value === null)
+        return defaultValue ?? 0;
+    return Number.parseInt(value, 10);
+};
+const getBool = (key, defaultValue) => {
+    const proc = getProcessLike();
+    const env = proc?.env ?? {};
+    const value = env[key];
+    if (value === undefined || value === null)
+        return defaultValue ?? false;
+    return value.toLowerCase() === 'true' || value === '1';
+};
+const getDefaultLogLevel = () => {
+    const NODE_ENV_VALUE = get('NODE_ENV', 'development');
+    if (NODE_ENV_VALUE === 'production')
+        return 'info';
+    if (NODE_ENV_VALUE === 'testing')
+        return 'error';
+    return 'debug';
+};
+// Sealed namespace with all environment configuration
+export const Env = Object.freeze({
+    // Helper functions
+    get,
+    getInt,
+    getBool,
+    // Core
+    NODE_ENV: get('NODE_ENV', 'development'),
+    PORT: getInt('APP_PORT', 3000),
+    HOST: get('HOST', 'localhost'),
+    APP_NAME: get('APP_NAME', 'ZinTrust'),
+    APP_KEY: get('APP_KEY', ''),
+    // Database
+    DB_CONNECTION: get('DB_CONNECTION', 'sqlite'),
+    DB_HOST: get('DB_HOST', 'localhost'),
+    DB_PORT: getInt('DB_PORT', 5432),
+    DB_DATABASE: get('DB_DATABASE', 'zintrust'),
+    DB_USERNAME: get('DB_USERNAME', 'postgres'),
+    DB_PASSWORD: get('DB_PASSWORD', ''),
+    DB_READ_HOSTS: get('DB_READ_HOSTS', ''),
+    // Cloudflare
+    D1_DATABASE_ID: get('D1_DATABASE_ID'),
+    KV_NAMESPACE_ID: get('KV_NAMESPACE_ID'),
+    // Cache
+    CACHE_DRIVER: get('CACHE_DRIVER', 'memory'),
+    REDIS_HOST: get('REDIS_HOST', 'localhost'),
+    REDIS_PORT: getInt('REDIS_PORT', 6379),
+    REDIS_PASSWORD: get('REDIS_PASSWORD', ''),
+    MONGO_URI: get('MONGO_URI'),
+    MONGO_DB: get('MONGO_DB', 'zintrust_cache'),
+    // AWS
+    AWS_REGION: get('AWS_REGION', 'us-east-1'),
+    AWS_LAMBDA_FUNCTION_NAME: get('AWS_LAMBDA_FUNCTION_NAME'),
+    AWS_LAMBDA_FUNCTION_VERSION: get('AWS_LAMBDA_FUNCTION_VERSION'),
+    AWS_EXECUTION_ENV: get('AWS_EXECUTION_ENV'),
+    LAMBDA_TASK_ROOT: get('LAMBDA_TASK_ROOT'),
+    // Microservices
+    MICROSERVICES: get('MICROSERVICES'),
+    SERVICES: get('SERVICES'),
+    MICROSERVICES_TRACING: getBool('MICROSERVICES_TRACING'),
+    MICROSERVICES_TRACING_RATE: Number.parseFloat(get('MICROSERVICES_TRACING_RATE', '1.0')),
+    DATABASE_ISOLATION: get('DATABASE_ISOLATION', 'shared'),
+    SERVICE_API_KEY: get('SERVICE_API_KEY'),
+    SERVICE_JWT_SECRET: get('SERVICE_JWT_SECRET'),
+    // Security
+    DEBUG: getBool('DEBUG', false),
+    ENABLE_MICROSERVICES: getBool('ENABLE_MICROSERVICES', false),
+    TOKEN_TTL: getInt('TOKEN_TTL', 3600000),
+    TOKEN_LENGTH: getInt('TOKEN_LENGTH', 32),
+    // Deployment
+    ENVIRONMENT: get('ENVIRONMENT', 'development'),
+    REQUEST_TIMEOUT: getInt('REQUEST_TIMEOUT', 30000),
+    MAX_BODY_SIZE: getInt('MAX_BODY_SIZE', 10485760),
+    // Logging
+    LOG_LEVEL: get('LOG_LEVEL', getDefaultLogLevel()),
+    DISABLE_LOGGING: getBool('DISABLE_LOGGING', false),
+    // Paths (safely constructed for Node.js environments)
+    NODE_BIN_DIR: (() => {
+        try {
+            const proc = getProcessLike();
+            if (proc?.execPath === null || proc?.execPath === undefined)
+                return '';
+            return dirnameFromExecPath(proc.execPath, proc.platform);
+        }
+        catch {
+            // Fallback for non-Node environments
+            return '';
+        }
+    })(),
+    SAFE_PATH: (() => {
+        try {
+            const proc = getProcessLike();
+            if (proc?.execPath === null || proc?.execPath === undefined)
+                return '';
+            const binDir = dirnameFromExecPath(proc.execPath, proc.platform);
+            if (proc.platform === 'win32') {
+                return [String.raw `C:\Windows\System32`, String.raw `C:\Windows`, binDir].join(';');
+            }
+            return ['/usr/bin', '/bin', '/usr/sbin', '/sbin', binDir].join(':');
+        }
+        catch {
+            // Fallback for non-Node environments
+            return '';
+        }
+    })(),
+});

package/src/config/features.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Feature Flags - Controls access to advanced/experimental features
+ * Sealed namespace for immutability
+ */
+export declare const FeatureFlags: Readonly<{
+    /**
+     * Initialize all feature flags from environment
+     * Called once during application bootstrap
+     */
+    initialize(): void;
+    /**
+     * Check if raw queries are enabled
+     * Returns cached flag value (no environment lookup)
+     */
+    isRawQueryEnabled(): boolean;
+    /**
+     * Reset flags (primarily for testing)
+     */
+    reset(): void;
+    /**
+     * Set raw query enabled state
+     * Primarily for testing to avoid 'as any' type casting
+     */
+    setRawQueryEnabled(enabled: boolean): void;
+}>;
+export default FeatureFlags;
+//# sourceMappingURL=features.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../../../src/config/features.ts"],"names":[],"mappings":"AASA;;;GAGG;AACH,eAAO,MAAM,YAAY;IACvB;;;OAGG;kBACW,IAAI;IAclB;;;OAGG;yBACkB,OAAO;IAI5B;;OAEG;aACM,IAAI;IAIb;;;OAGG;gCACyB,OAAO,GAAG,IAAI;EAG1C,CAAC;AAEH,eAAe,YAAY,CAAC"}