@zintrust/core 0.1.28 → 0.1.29

package/src/config/microservices.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Microservices Configuration
+ * Microservices architecture and service discovery settings
+ * Sealed namespace for immutability
+ */
+export declare const microservicesConfig: Readonly<{
+    /**
+     * Enable microservices mode
+     */
+    readonly enabled: boolean;
+    /**
+     * Enabled services (comma-separated)
+     */
+    readonly services: string[];
+    /**
+     * Service discovery
+     */
+    readonly discovery: {
+        readonly type: "filesystem" | "consul" | "etcd";
+        readonly servicesPath: string;
+        readonly refreshInterval: number;
+    };
+    /**
+     * Service Registry
+     */
+    readonly registry: {
+        readonly host: string;
+        readonly port: number;
+        readonly deregisterCriticalServiceAfter: string;
+    };
+    /**
+     * Service Authentication
+     */
+    readonly auth: {
+        readonly strategy: "api-key" | "jwt" | "none" | "custom";
+        readonly apiKey: string;
+        readonly jwtSecret: string;
+    };
+    /**
+     * Request Tracing
+     */
+    readonly tracing: {
+        readonly enabled: boolean;
+        readonly samplingRate: number;
+        readonly exportInterval: number;
+        readonly jaegerEndpoint: string;
+    };
+    /**
+     * Database Isolation
+     */
+    readonly database: {
+        readonly isolation: "shared" | "isolated";
+        readonly schema: string;
+    };
+    /**
+     * Service Health Check
+     */
+    readonly healthCheck: {
+        readonly enabled: boolean;
+        readonly interval: number;
+        readonly timeout: number;
+        readonly unhealthyThreshold: number;
+        readonly healthyThreshold: number;
+    };
+    /**
+     * Service Communication
+     */
+    readonly communication: {
+        readonly timeout: number;
+        readonly retries: number;
+        readonly retryDelay: number;
+        readonly circuitBreaker: {
+            readonly enabled: boolean;
+            readonly threshold: number;
+            readonly timeout: number;
+        };
+    };
+    /**
+     * Service Mesh (Istio/Linkerd support)
+     */
+    readonly mesh: {
+        readonly enabled: boolean;
+        readonly type: "istio" | "linkerd";
+        readonly namespace: string;
+    };
+}>;
+export type MicroservicesConfig = typeof microservicesConfig;
+//# sourceMappingURL=microservices.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"microservices.d.ts","sourceRoot":"","sources":["../../../src/config/microservices.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAiGH,eAAO,MAAM,mBAAmB;IA5F9B;;OAEG;;IAGH;;OAEG;;IAKH;;OAEG;;uBAEwD,YAAY,GAAG,QAAQ,GAAG,MAAM;;;;IAK3F;;OAEG;;;;;;IAOH;;OAEG;;2BAEqD,SAAS,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ;;;;IAK7F;;OAEG;;;;;;;IAQH;;OAEG;;4BAEqD,QAAQ,GAAG,UAAU;;;IAI7E;;OAEG;;;;;;;;IASH;;OAEG;;;;;;;;;;;IAYH;;OAEG;;;uBAG8C,OAAO,GAAG,SAAS;;;EAKE,CAAC;AAEzE,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC"}

package/src/config/microservices.js

@@ -0,0 +1,90 @@
+/**
+ * Microservices Configuration
+ * Microservices architecture and service discovery settings
+ * Sealed namespace for immutability
+ */
+import { Env } from './env.js';
+const microservicesConfigObj = {
+    /**
+     * Enable microservices mode
+     */
+    enabled: Env.getBool('MICROSERVICES', false),
+    /**
+     * Enabled services (comma-separated)
+     */
+    services: Env.get('SERVICES', '')
+        .split(',')
+        .filter((s) => s.trim()),
+    /**
+     * Service discovery
+     */
+    discovery: {
+        type: Env.get('SERVICE_DISCOVERY_TYPE', 'filesystem'),
+        servicesPath: Env.get('SERVICES_PATH', 'services'),
+        refreshInterval: Env.getInt('SERVICE_DISCOVERY_REFRESH_INTERVAL', 30000),
+    },
+    /**
+     * Service Registry
+     */
+    registry: {
+        host: Env.get('SERVICE_REGISTRY_HOST', 'localhost'),
+        port: Env.getInt('SERVICE_REGISTRY_PORT', 8500),
+        deregisterCriticalServiceAfter: Env.get('SERVICE_DEREGISTER_CRITICAL_AFTER', '30s'),
+    },
+    /**
+     * Service Authentication
+     */
+    auth: {
+        strategy: Env.get('SERVICE_AUTH_STRATEGY', 'none'),
+        apiKey: Env.get('SERVICE_API_KEY'),
+        jwtSecret: Env.get('SERVICE_JWT_SECRET'),
+    },
+    /**
+     * Request Tracing
+     */
+    tracing: {
+        enabled: Env.getBool('MICROSERVICES_TRACING', false),
+        samplingRate: Env.getInt('MICROSERVICES_TRACING_RATE', 100) / 100,
+        exportInterval: Env.getInt('TRACING_EXPORT_INTERVAL', 10000),
+        jaegerEndpoint: Env.get('JAEGER_AGENT_HOST', 'localhost'),
+    },
+    /**
+     * Database Isolation
+     */
+    database: {
+        isolation: Env.get('DATABASE_ISOLATION', 'shared'),
+        schema: Env.get('DATABASE_SCHEMA_PREFIX', 'microservice'),
+    },
+    /**
+     * Service Health Check
+     */
+    healthCheck: {
+        enabled: Env.getBool('SERVICE_HEALTH_CHECK_ENABLED', true),
+        interval: Env.getInt('SERVICE_HEALTH_CHECK_INTERVAL', 30000),
+        timeout: Env.getInt('SERVICE_HEALTH_CHECK_TIMEOUT', 5000),
+        unhealthyThreshold: Env.getInt('SERVICE_UNHEALTHY_THRESHOLD', 3),
+        healthyThreshold: Env.getInt('SERVICE_HEALTHY_THRESHOLD', 2),
+    },
+    /**
+     * Service Communication
+     */
+    communication: {
+        timeout: Env.getInt('SERVICE_CALL_TIMEOUT', 30000),
+        retries: Env.getInt('SERVICE_CALL_RETRIES', 3),
+        retryDelay: Env.getInt('SERVICE_CALL_RETRY_DELAY', 1000),
+        circuitBreaker: {
+            enabled: Env.getBool('CIRCUIT_BREAKER_ENABLED', true),
+            threshold: Env.getInt('CIRCUIT_BREAKER_THRESHOLD', 5),
+            timeout: Env.getInt('CIRCUIT_BREAKER_TIMEOUT', 60000),
+        },
+    },
+    /**
+     * Service Mesh (Istio/Linkerd support)
+     */
+    mesh: {
+        enabled: Env.getBool('SERVICE_MESH_ENABLED', false),
+        type: Env.get('SERVICE_MESH_TYPE', 'istio'),
+        namespace: Env.get('SERVICE_MESH_NAMESPACE', 'default'),
+    },
+};
+export const microservicesConfig = Object.freeze(microservicesConfigObj);

package/src/config/middleware.d.ts

@@ -0,0 +1,48 @@
+import type { MiddlewareConfigType } from './type';
+export declare const MiddlewareBody: {
+    readonly email: "email";
+    readonly password: "password";
+    readonly name: "name";
+    readonly count: "count";
+};
+export type MiddlewaresType = {
+    skipPaths: string[];
+    fillRateLimit: {
+        windowMs: number;
+        max: number;
+        message: string;
+    };
+    authRateLimit: {
+        windowMs: number;
+        max: number;
+        message: string;
+    };
+    userMutationRateLimit: {
+        windowMs: number;
+        max: number;
+        message: string;
+    };
+};
+export declare const MiddlewareKeys: Readonly<{
+    log: true;
+    error: true;
+    security: true;
+    rateLimit: true;
+    sanitizeBody: true;
+    fillRateLimit: true;
+    authRateLimit: true;
+    userMutationRateLimit: true;
+    csrf: true;
+    auth: true;
+    jwt: true;
+    validateLogin: true;
+    validateRegister: true;
+    validateUserStore: true;
+    validateUserUpdate: true;
+    validateUserFill: true;
+}>;
+export type MiddlewareKey = keyof typeof MiddlewareKeys;
+export declare function createMiddlewareConfig(): MiddlewareConfigType;
+export declare const middlewareConfig: MiddlewareConfigType;
+export default middlewareConfig;
+//# sourceMappingURL=middleware.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../../src/config/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AA+DzD,eAAO,MAAM,cAAc;;;;;CAKjB,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,aAAa,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAClE,aAAa,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAClE,qBAAqB,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3E,CAAC;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;EAiBuB,CAAC;AAEnD,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,cAAc,CAAC;AA0MxD,wBAAgB,sBAAsB,IAAI,oBAAoB,CAqB7D;AA0BD,eAAO,MAAM,gBAAgB,EAAE,oBAY7B,CAAC;AAEH,eAAe,gBAAgB,CAAC"}

package/src/config/middleware.js

@@ -0,0 +1,205 @@
+import { bodyParsingMiddleware } from '../http/middleware/BodyParsingMiddleware.js';
+import { fileUploadMiddleware } from '../http/middleware/FileUploadMiddleware.js';
+import { AuthMiddleware } from '../middleware/AuthMiddleware.js';
+import { CsrfMiddleware } from '../middleware/CsrfMiddleware.js';
+import { ErrorHandlerMiddleware } from '../middleware/ErrorHandlerMiddleware.js';
+import { JwtAuthMiddleware } from '../middleware/JwtAuthMiddleware.js';
+import { LoggingMiddleware } from '../middleware/LoggingMiddleware.js';
+import { RateLimiter } from '../middleware/RateLimiter.js';
+import { SanitizeBodyMiddleware } from '../middleware/SanitizeBodyMiddleware.js';
+import { SecurityMiddleware } from '../middleware/SecurityMiddleware.js';
+import { ValidationMiddleware } from '../middleware/ValidationMiddleware.js';
+import { StartupConfigFile, StartupConfigFileRegistry } from '../runtime/StartupConfigFileRegistry.js';
+import { Sanitizer } from '../security/Sanitizer.js';
+import { Schema } from '../validation/Validator.js';
+export const MiddlewareBody = {
+    email: 'email',
+    password: 'password',
+    name: 'name',
+    count: 'count',
+};
+export const MiddlewareKeys = Object.freeze({
+    log: true,
+    error: true,
+    security: true,
+    rateLimit: true,
+    sanitizeBody: true,
+    fillRateLimit: true,
+    authRateLimit: true,
+    userMutationRateLimit: true,
+    csrf: true,
+    auth: true,
+    jwt: true,
+    validateLogin: true,
+    validateRegister: true,
+    validateUserStore: true,
+    validateUserUpdate: true,
+    validateUserFill: true,
+});
+// Ensure `ValidationMiddleware` is strongly typed here to avoid `error`-typed values
+// triggering `@typescript-eslint/no-unsafe-*` rules.
+const Validation = ValidationMiddleware;
+const resolveFillRateLimit = (loadMiddlewareConfig) => {
+    return {
+        windowMs: loadMiddlewareConfig.fillRateLimit?.windowMs ?? 60_000,
+        max: loadMiddlewareConfig.fillRateLimit?.max ?? 5,
+        message: loadMiddlewareConfig.fillRateLimit?.message ??
+            'Too many requests, please try again after 1 minute.',
+    };
+};
+const resolveAuthRateLimit = (loadMiddlewareConfig) => {
+    return {
+        windowMs: loadMiddlewareConfig.authRateLimit?.windowMs ?? 60_000,
+        max: loadMiddlewareConfig.authRateLimit?.max ?? 10,
+        message: loadMiddlewareConfig.authRateLimit?.message ??
+            'Too many login attempts, please try again after 1 minute.',
+    };
+};
+const resolveUserMutationRateLimit = (loadMiddlewareConfig) => {
+    return {
+        windowMs: loadMiddlewareConfig.userMutationRateLimit?.windowMs ?? 60_000,
+        max: loadMiddlewareConfig.userMutationRateLimit?.max ?? 20,
+        message: loadMiddlewareConfig.userMutationRateLimit?.message ??
+            'Too many user requests, please try again after 1 minute.',
+    };
+};
+function createRateLimitMiddlewares(loadMiddlewareConfig) {
+    const fillRateLimit = RateLimiter.create(resolveFillRateLimit(loadMiddlewareConfig));
+    const authRateLimit = RateLimiter.create(resolveAuthRateLimit(loadMiddlewareConfig));
+    const userMutationRateLimit = RateLimiter.create(resolveUserMutationRateLimit(loadMiddlewareConfig));
+    return Object.freeze({
+        rateLimit: RateLimiter.create(),
+        fillRateLimit,
+        authRateLimit,
+        userMutationRateLimit,
+    });
+}
+function createAuthValidationMiddlewares() {
+    return {
+        validateLogin: Validation.createBodyWithSanitization(Schema.typed()
+            .required(MiddlewareBody.email)
+            .email(MiddlewareBody.email)
+            .required(MiddlewareBody.password)
+            .string(MiddlewareBody.password), {
+            email: (v) => Sanitizer.email(v).trim().toLowerCase(),
+            password: (v) => Sanitizer.safePasswordChars(v),
+        }),
+        validateRegister: Validation.createBodyWithSanitization(Schema.typed()
+            .required(MiddlewareBody.name)
+            .string(MiddlewareBody.name)
+            .minLength(MiddlewareBody.name, 1)
+            .required(MiddlewareBody.email)
+            .email(MiddlewareBody.email)
+            .required(MiddlewareBody.password)
+            .string(MiddlewareBody.password)
+            .minLength(MiddlewareBody.password, 8), {
+            name: (v) => Sanitizer.nameText(v).trim(),
+            email: (v) => Sanitizer.email(v).trim().toLowerCase(),
+            password: (v) => Sanitizer.safePasswordChars(v),
+        }),
+    };
+}
+function createUserValidationMiddlewares() {
+    return {
+        validateUserStore: Validation.createBodyWithSanitization(Schema.typed()
+            .required(MiddlewareBody.name)
+            .string(MiddlewareBody.name)
+            .minLength(MiddlewareBody.name, 1)
+            .required(MiddlewareBody.email)
+            .email(MiddlewareBody.email)
+            .required(MiddlewareBody.password)
+            .string(MiddlewareBody.password)
+            .minLength(MiddlewareBody.password, 8), {
+            name: (v) => Sanitizer.nameText(v).trim(),
+            email: (v) => Sanitizer.email(v).trim().toLowerCase(),
+            password: (v) => Sanitizer.safePasswordChars(v),
+        }),
+        validateUserUpdate: Validation.createBodyWithSanitization(Schema.typed()
+            .custom(MiddlewareBody.name, (v) => v === undefined || typeof v === 'string', MiddlewareBody.name + ' must be a string')
+            .minLength(MiddlewareBody.name, 1)
+            .custom(MiddlewareBody.email, (v) => v === undefined || typeof v === 'string', MiddlewareBody.email + ' must be a string')
+            .custom(MiddlewareBody.password, (v) => v === undefined || typeof v === 'string', MiddlewareBody.password + ' must be a string')
+            .minLength(MiddlewareBody.password, 8), {
+            name: (v) => Sanitizer.nameText(v).trim(),
+            email: (v) => Sanitizer.email(v).trim().toLowerCase(),
+            password: (v) => Sanitizer.safePasswordChars(v),
+        }),
+        validateUserFill: Validation.createBodyWithSanitization(Schema.typed()
+            .custom(MiddlewareBody.count, (v) => v === undefined || (typeof v === 'number' && Number.isFinite(v)), MiddlewareBody.count + ' must be a number')
+            .min(MiddlewareBody.count, 1)
+            .max(MiddlewareBody.count, 100)),
+    };
+}
+function createValidationMiddlewares() {
+    return Object.freeze({
+        ...createAuthValidationMiddlewares(),
+        ...createUserValidationMiddlewares(),
+    });
+}
+function createSharedMiddlewares(loadMiddlewareConfig) {
+    const rateLimits = createRateLimitMiddlewares(loadMiddlewareConfig);
+    const validations = createValidationMiddlewares();
+    return Object.freeze({
+        log: LoggingMiddleware.create(),
+        error: ErrorHandlerMiddleware.create(),
+        security: SecurityMiddleware.create(),
+        sanitizeBody: SanitizeBodyMiddleware.create(),
+        ...rateLimits,
+        csrf: CsrfMiddleware.create({
+            skipPaths: loadMiddlewareConfig?.skipPaths ?? [],
+        }),
+        auth: AuthMiddleware.create(),
+        jwt: JwtAuthMiddleware.create(),
+        ...validations,
+    });
+}
+export function createMiddlewareConfig() {
+    const loadMiddlewareConfig = StartupConfigFileRegistry.get(StartupConfigFile.Middleware) ?? {};
+    const shared = createSharedMiddlewares(loadMiddlewareConfig);
+    const middlewareConfigObj = {
+        global: [
+            shared.log,
+            shared.error,
+            shared.security,
+            shared.rateLimit,
+            fileUploadMiddleware,
+            bodyParsingMiddleware,
+            shared.csrf,
+            shared.sanitizeBody,
+        ],
+        route: shared,
+    };
+    return Object.freeze(middlewareConfigObj);
+}
+let cached = null;
+// Proxy target must satisfy JS Proxy invariants.
+// When we lazily create a frozen config object (with non-configurable properties),
+// we mirror its property descriptors onto this target so reflective operations
+// like Object.getOwnPropertyDescriptor() do not throw.
+const proxyTarget = {};
+function ensureMiddlewareConfig() {
+    if (cached)
+        return cached;
+    cached = createMiddlewareConfig();
+    try {
+        Object.defineProperties(proxyTarget, Object.getOwnPropertyDescriptors(cached));
+    }
+    catch {
+        // best-effort; proxy still functions via `get` trap even if reflection fails
+    }
+    return cached;
+}
+export const middlewareConfig = new Proxy(proxyTarget, {
+    get(_target, prop) {
+        return ensureMiddlewareConfig()[prop];
+    },
+    ownKeys() {
+        ensureMiddlewareConfig();
+        return Reflect.ownKeys(proxyTarget);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+        ensureMiddlewareConfig();
+        return Object.getOwnPropertyDescriptor(proxyTarget, prop);
+    },
+});
+export default middlewareConfig;

package/src/config/notification.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Notification Configuration
+ *
+ * Config-first mapping of notification providers/channels.
+ * Driver selection must be dynamic (tests may mutate process.env).
+ */
+import type { KnownNotificationDriverConfig, NotificationDrivers, NotificationProviders } from './type';
+export type NotificationConfigOverrides = Partial<{
+    default: string;
+    drivers: NotificationDrivers;
+    providers: NotificationProviders;
+}>;
+type NotificationRuntimeConfig = {
+    default: string;
+    drivers: NotificationDrivers;
+    providers: NotificationProviders;
+    getDriverName: () => string;
+    getDriverConfig: (name?: string) => KnownNotificationDriverConfig;
+};
+declare const createNotificationConfig: () => NotificationRuntimeConfig;
+export type NotificationConfig = ReturnType<typeof createNotificationConfig>;
+export declare const notificationConfig: NotificationConfig;
+export default notificationConfig;
+//# sourceMappingURL=notification.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"notification.d.ts","sourceRoot":"","sources":["../../../src/config/notification.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EACV,6BAA6B,EAE7B,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,cAAc,CAAC;AAItB,MAAM,MAAM,2BAA2B,GAAG,OAAO,CAAC;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,mBAAmB,CAAC;IAC7B,SAAS,EAAE,qBAAqB,CAAC;CAClC,CAAC,CAAC;AAEH,KAAK,yBAAyB,GAAG;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,mBAAmB,CAAC;IAC7B,SAAS,EAAE,qBAAqB,CAAC;IACjC,aAAa,EAAE,MAAM,MAAM,CAAC;IAC5B,eAAe,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,KAAK,6BAA6B,CAAC;CACnE,CAAC;AA2EF,QAAA,MAAM,wBAAwB,QAAO,yBA+DpC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAqB7E,eAAO,MAAM,kBAAkB,EAAE,kBAY/B,CAAC;AAEH,eAAe,kBAAkB,CAAC"}

package/src/config/notification.js

@@ -0,0 +1,149 @@
+/**
+ * Notification Configuration
+ *
+ * Config-first mapping of notification providers/channels.
+ * Driver selection must be dynamic (tests may mutate process.env).
+ */
+import { Env } from './env.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import { StartupConfigFile, StartupConfigFileRegistry } from '../runtime/StartupConfigFileRegistry.js';
+const normalizeName = (value) => value.trim().toLowerCase();
+const hasOwn = (obj, key) => {
+    return Object.hasOwn(obj, key);
+};
+const getDefaultChannel = (drivers) => {
+    const envSelectedRaw = Env.get('NOTIFICATION_CONNECTION', Env.get('NOTIFICATION_DRIVER', 'console'));
+    const value = normalizeName(envSelectedRaw ?? 'console');
+    if (value.length > 0 && hasOwn(drivers, value))
+        return value;
+    if (envSelectedRaw.trim().length > 0) {
+        throw ErrorFactory.createConfigError(`Notification channel not configured: ${value}`);
+    }
+    return hasOwn(drivers, 'console') ? 'console' : (Object.keys(drivers)[0] ?? 'console');
+};
+const getNotificationDriver = (config, name) => {
+    const selected = normalizeName(String(name ?? config.default));
+    const channelName = selected === 'default' ? normalizeName(config.default) : selected;
+    const isExplicitSelection = name !== undefined &&
+        String(name).trim().length > 0 &&
+        normalizeName(String(name)) !== 'default';
+    if (channelName.length > 0 && hasOwn(config.drivers, channelName)) {
+        const resolved = config.drivers[channelName];
+        if (resolved !== undefined)
+            return resolved;
+    }
+    if (Object.keys(config.drivers ?? {}).length === 0) {
+        throw ErrorFactory.createConfigError('No notification channels are configured');
+    }
+    if (isExplicitSelection) {
+        throw ErrorFactory.createConfigError(`Notification channel not configured: ${channelName}`);
+    }
+    // Default selection is strict: if `default` points at an unconfigured channel, throw.
+    throw ErrorFactory.createConfigError(`Notification channel not configured: ${channelName}`);
+};
+const getBaseProviders = () => {
+    return {
+        console: { driver: 'console' },
+        termii: {
+            driver: 'termii',
+            apiKey: Env.get('TERMII_API_KEY', ''),
+            sender: Env.get('TERMII_SENDER', 'ZinTrust'),
+            endpoint: Env.get('TERMII_ENDPOINT', 'https://api.termii.com/sms/send'),
+        },
+        twilio: {
+            driver: 'twilio',
+            accountSid: Env.get('TWILIO_ACCOUNT_SID', ''),
+            authToken: Env.get('TWILIO_AUTH_TOKEN', ''),
+            fromNumber: Env.get('TWILIO_FROM_NUMBER', ''),
+        },
+        slack: {
+            driver: 'slack',
+            webhookUrl: Env.get('SLACK_WEBHOOK_URL', ''),
+        },
+    };
+};
+const createNotificationConfig = () => {
+    const overrides = StartupConfigFileRegistry.get(StartupConfigFile.Notification) ??
+        {};
+    const notificationConfigObj = {
+        /**
+         * Default notification channel name (normalized).
+         */
+        get default() {
+            const overrideDefault = overrides.default;
+            if (typeof overrideDefault === 'string' && overrideDefault.trim().length > 0) {
+                const value = normalizeName(overrideDefault);
+                if (value.length > 0 && hasOwn(this.drivers, value))
+                    return value;
+                throw ErrorFactory.createConfigError(`Notification channel not configured: ${value}`);
+            }
+            return getDefaultChannel(this.drivers);
+        },
+        /**
+         * Notification channels.
+         *
+         * You may add custom named channels (e.g. `opsSlack`, `smsMarketing`) that
+         * point to any known driver config.
+         */
+        get drivers() {
+            // Return a record of channels; can be extended by app-level config.
+            return {
+                ...getBaseProviders(),
+                ...overrides.providers,
+                ...overrides.drivers,
+            };
+        },
+        /**
+         * Legacy provider configs (kept for backwards compatibility with wrappers).
+         */
+        get providers() {
+            return {
+                ...getBaseProviders(),
+                ...overrides.providers,
+            };
+        },
+        /**
+         * Normalized notification channel name.
+         */
+        getDriverName() {
+            return normalizeName(this.default);
+        },
+        /**
+         * Resolve a channel config.
+         * - Unknown names throw when explicitly selected.
+         * - `default` is a reserved alias of the configured default.
+         */
+        getDriverConfig(name) {
+            return getNotificationDriver(this, name);
+        },
+    };
+    return Object.freeze(notificationConfigObj);
+};
+let cached = null;
+const proxyTarget = {};
+const ensureNotificationConfig = () => {
+    if (cached)
+        return cached;
+    cached = createNotificationConfig();
+    try {
+        Object.defineProperties(proxyTarget, Object.getOwnPropertyDescriptors(cached));
+    }
+    catch {
+        // best-effort
+    }
+    return cached;
+};
+export const notificationConfig = new Proxy(proxyTarget, {
+    get(_target, prop) {
+        return ensureNotificationConfig()[prop];
+    },
+    ownKeys() {
+        ensureNotificationConfig();
+        return Reflect.ownKeys(proxyTarget);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+        ensureNotificationConfig();
+        return Object.getOwnPropertyDescriptor(proxyTarget, prop);
+    },
+});
+export default notificationConfig;

package/src/config/queue.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Queue Configuration
+ * Background job and message queue settings
+ * Sealed namespace for immutability
+ */
+import type { QueueConfigWithDrivers, QueueDriverName, QueueDriversConfig } from './type';
+export type QueueConfigOverrides = Partial<{
+    default: QueueDriverName;
+    drivers: Partial<QueueDriversConfig>;
+    failed: {
+        database: string;
+        table: string;
+    };
+    processing: {
+        timeout: number;
+        retries: number;
+        backoff: number;
+        workers: number;
+    };
+    monitor: {
+        enabled: boolean;
+        basePath: string;
+        middleware: ReadonlyArray<string>;
+        autoRefresh: boolean;
+        refreshIntervalMs: number;
+    };
+}>;
+/**
+ * Helper: Create base driver configurations from environment
+ */
+export declare const createBaseDrivers: () => QueueDriversConfig;
+declare const createQueueConfig: () => {
+    default: QueueDriverName;
+    drivers: QueueDriversConfig;
+    getDriver: (this: QueueConfigWithDrivers) => QueueDriversConfig[QueueDriverName];
+    failed: {
+        database: string;
+        table: string;
+    };
+    processing: {
+        timeout: number;
+        retries: number;
+        backoff: number;
+        workers: number;
+    };
+    monitor: {
+        enabled: boolean;
+        basePath: string;
+        middleware: ReadonlyArray<string>;
+        autoRefresh: boolean;
+        refreshIntervalMs: number;
+    };
+};
+export type QueueConfig = ReturnType<typeof createQueueConfig>;
+export declare const queueConfig: QueueConfig;
+export {};
+//# sourceMappingURL=queue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../../src/config/queue.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAGhG,MAAM,MAAM,oBAAoB,GAAG,OAAO,CAAC;IACzC,OAAO,EAAE,eAAe,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACrC,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5C,UAAU,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IACnF,OAAO,EAAE;QACP,OAAO,EAAE,OAAO,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;QAClC,WAAW,EAAE,OAAO,CAAC;QACrB,iBAAiB,EAAE,MAAM,CAAC;KAC3B,CAAC;CACH,CAAC,CAAC;AAOH;;GAEG;AACH,eAAO,MAAM,iBAAiB,QAAO,kBA+BnC,CAAC;AAsBH,QAAA,MAAM,iBAAiB,QAAO;IAC5B,OAAO,EAAE,eAAe,CAAC;IACzB,OAAO,EAAE,kBAAkB,CAAC;IAC5B,SAAS,EAAE,CAAC,IAAI,EAAE,sBAAsB,KAAK,kBAAkB,CAAC,eAAe,CAAC,CAAC;IACjF,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5C,UAAU,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IACnF,OAAO,EAAE;QACP,OAAO,EAAE,OAAO,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;QAClC,WAAW,EAAE,OAAO,CAAC;QACrB,iBAAiB,EAAE,MAAM,CAAC;KAC3B,CAAC;CAuEH,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAqB/D,eAAO,MAAM,WAAW,EAAE,WAYxB,CAAC"}