@zintrust/core 2.3.1 → 2.4.1

package/src/config/microservices.d.ts

@@ -1,88 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,90 +0,0 @@
-/**
- * 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

@@ -1,83 +0,0 @@
-import type { MiddlewareConfigType } from './type';
-import type { MiddlewareFailureResponder } from '../middleware/MiddlewareFailureResponder';
-import type { Middleware } from '../middleware/MiddlewareStack';
-type SharedMiddlewares = {
-    log: Middleware;
-    error: Middleware;
-    security: Middleware;
-    rateLimit: Middleware;
-    sanitizeBody: Middleware;
-    fillRateLimit: Middleware;
-    authRateLimit: Middleware;
-    userMutationRateLimit: Middleware;
-    csrf: Middleware;
-    auth: Middleware;
-    jwt: Middleware;
-    bulletproof: Middleware;
-    validateLogin: Middleware;
-    validateRegister: Middleware;
-    validateUserStore: Middleware;
-    validateUserUpdate: Middleware;
-    validateUserFill: Middleware;
-};
-type MiddlewareResponderKey = keyof SharedMiddlewares;
-type MiddlewareResponderConfig = Partial<Record<MiddlewareResponderKey, MiddlewareFailureResponder>>;
-export declare const MiddlewareBody: {
-    readonly email: "email";
-    readonly password: "password";
-    readonly name: "name";
-    readonly count: "count";
-};
-export type MiddlewaresType = {
-    skipPaths: ReadonlyArray<string>;
-    fillRateLimit: {
-        windowMs: number;
-        maxRequests: number;
-        message: string;
-    };
-    authRateLimit: {
-        windowMs: number;
-        maxRequests: number;
-        message: string;
-    };
-    userMutationRateLimit: {
-        windowMs: number;
-        maxRequests: number;
-        message: string;
-    };
-    responders?: MiddlewareResponderConfig;
-    global?: ReadonlyArray<Middleware>;
-    route?: Record<string, Middleware>;
-};
-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;
-    bulletproof: true;
-    validateLogin: true;
-    validateRegister: true;
-    validateUserStore: true;
-    validateUserUpdate: true;
-    validateUserFill: true;
-}>;
-export type ParameterizedRateLimitMiddlewareKey = `rateLimit:${number}:${number}`;
-type StaticMiddlewareKey = keyof typeof MiddlewareKeys;
-export type MiddlewareKey = StaticMiddlewareKey | ParameterizedRateLimitMiddlewareKey;
-export declare const isKnownMiddlewareName: (value: string) => value is MiddlewareKey;
-export declare function createMiddlewareConfig(): MiddlewareConfigType;
-/**
- * Clear the middleware configuration cache
- * This ensures fresh config loading in watch mode
- */
-export declare const clearMiddlewareConfigCache: () => void;
-export declare const middlewareConfig: MiddlewareConfigType;
-export default middlewareConfig;
-//# sourceMappingURL=middleware.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../../src/config/middleware.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAUzD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,wCAAwC,CAAC;AACzF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAoC9D,KAAK,iBAAiB,GAAG;IACvB,GAAG,EAAE,UAAU,CAAC;IAChB,KAAK,EAAE,UAAU,CAAC;IAClB,QAAQ,EAAE,UAAU,CAAC;IACrB,SAAS,EAAE,UAAU,CAAC;IACtB,YAAY,EAAE,UAAU,CAAC;IACzB,aAAa,EAAE,UAAU,CAAC;IAC1B,aAAa,EAAE,UAAU,CAAC;IAC1B,qBAAqB,EAAE,UAAU,CAAC;IAClC,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,UAAU,CAAC;IACjB,GAAG,EAAE,UAAU,CAAC;IAChB,WAAW,EAAE,UAAU,CAAC;IACxB,aAAa,EAAE,UAAU,CAAC;IAC1B,gBAAgB,EAAE,UAAU,CAAC;IAC7B,iBAAiB,EAAE,UAAU,CAAC;IAC9B,kBAAkB,EAAE,UAAU,CAAC;IAC/B,gBAAgB,EAAE,UAAU,CAAC;CAC9B,CAAC;AAEF,KAAK,sBAAsB,GAAG,MAAM,iBAAiB,CAAC;AACtD,KAAK,yBAAyB,GAAG,OAAO,CACtC,MAAM,CAAC,sBAAsB,EAAE,0BAA0B,CAAC,CAC3D,CAAC;AAEF,eAAO,MAAM,cAAc;;;;;CAKjB,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACjC,aAAa,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1E,aAAa,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1E,qBAAqB,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAClF,UAAU,CAAC,EAAE,yBAAyB,CAAC;IACvC,MAAM,CAAC,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACpC,CAAC;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;EAkBuB,CAAC;AAEnD,MAAM,MAAM,mCAAmC,GAAG,aAAa,MAAM,IAAI,MAAM,EAAE,CAAC;AAElF,KAAK,mBAAmB,GAAG,MAAM,OAAO,cAAc,CAAC;AAEvD,MAAM,MAAM,aAAa,GAAG,mBAAmB,GAAG,mCAAmC,CAAC;AAyBtF,eAAO,MAAM,qBAAqB,GAAI,OAAO,MAAM,KAAG,KAAK,IAAI,aAI9D,CAAC;AAsUF,wBAAgB,sBAAsB,IAAI,oBAAoB,CAoE7D;AAID;;;GAGG;AACH,eAAO,MAAM,0BAA0B,QAAO,IAE7C,CAAC;AAwBF,eAAO,MAAM,gBAAgB,EAAE,oBAY7B,CAAC;AAEH,eAAe,gBAAgB,CAAC"}

package/src/config/middleware.js

@@ -1,351 +0,0 @@
-import { Env } from './env.js';
-import { securityConfig } from './security.js';
-import { isArray, isObject } from '../helper/index.js';
-import { bodyParsingMiddleware } from '../http/middleware/BodyParsingMiddleware.js';
-import { fileUploadMiddleware } from '../http/middleware/FileUploadMiddleware.js';
-import { AuthMiddleware } from '../middleware/AuthMiddleware.js';
-import { BulletproofAuthMiddleware } from '../middleware/BulletproofAuthMiddleware.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', //NOSONAR
-    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,
-    bulletproof: true,
-    validateLogin: true,
-    validateRegister: true,
-    validateUserStore: true,
-    validateUserUpdate: true,
-    validateUserFill: true,
-});
-const parseParameterizedRateLimitKey = (value) => {
-    const match = /^rateLimit:(\d+):(\d+(?:\.\d+)?)$/.exec(value.trim());
-    if (!match)
-        return undefined;
-    const maxRequests = Number.parseInt(match[1] ?? '', 10);
-    const windowMinutes = Number.parseFloat(match[2] ?? '');
-    if (!Number.isInteger(maxRequests) || maxRequests < 1)
-        return undefined;
-    if (!Number.isFinite(windowMinutes) || windowMinutes <= 0)
-        return undefined;
-    const windowMs = Math.round(windowMinutes * 60_000);
-    if (!Number.isFinite(windowMs) || windowMs < 1)
-        return undefined;
-    return Object.freeze({ maxRequests, windowMs });
-};
-export const isKnownMiddlewareName = (value) => {
-    return (Object.hasOwn(MiddlewareKeys, value) || parseParameterizedRateLimitKey(value) !== undefined);
-};
-// 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,
-        maxRequests: loadMiddlewareConfig.fillRateLimit?.maxRequests ?? 5,
-        message: loadMiddlewareConfig.fillRateLimit?.message ??
-            'Too many requests, please try again after 1 minute.',
-    };
-};
-const resolveAuthRateLimit = (loadMiddlewareConfig) => {
-    return {
-        windowMs: loadMiddlewareConfig.authRateLimit?.windowMs ?? 60_000,
-        maxRequests: loadMiddlewareConfig.authRateLimit?.maxRequests ?? 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,
-        maxRequests: loadMiddlewareConfig.userMutationRateLimit?.maxRequests ?? 20,
-        message: loadMiddlewareConfig.userMutationRateLimit?.message ??
-            'Too many user requests, please try again after 1 minute.',
-    };
-};
-function createRateLimitMiddlewares(loadMiddlewareConfig, responders) {
-    const fillRateLimit = RateLimiter.create({
-        ...resolveFillRateLimit(loadMiddlewareConfig),
-        onFailure: responders.fillRateLimit,
-    });
-    const authRateLimit = RateLimiter.create({
-        ...resolveAuthRateLimit(loadMiddlewareConfig),
-        onFailure: responders.authRateLimit,
-    });
-    const userMutationRateLimit = RateLimiter.create({
-        ...resolveUserMutationRateLimit(loadMiddlewareConfig),
-        onFailure: responders.userMutationRateLimit,
-    });
-    return Object.freeze({
-        rateLimit: RateLimiter.create({
-            onFailure: responders.rateLimit,
-            ...securityConfig.rateLimit,
-        }),
-        fillRateLimit,
-        authRateLimit,
-        userMutationRateLimit,
-    });
-}
-function createAuthValidationMiddlewares(responders) {
-    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),
-        }, { onFailure: responders.validateLogin, middlewareKey: 'validateLogin' }),
-        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),
-        }, { onFailure: responders.validateRegister, middlewareKey: 'validateRegister' }),
-    };
-}
-function createUserValidationMiddlewares(responders) {
-    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),
-        }, { onFailure: responders.validateUserStore, middlewareKey: 'validateUserStore' }),
-        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),
-        }, { onFailure: responders.validateUserUpdate, middlewareKey: 'validateUserUpdate' }),
-        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), undefined, { onFailure: responders.validateUserFill, middlewareKey: 'validateUserFill' }),
-    };
-}
-function createValidationMiddlewares(responders) {
-    return Object.freeze({
-        ...createAuthValidationMiddlewares(responders),
-        ...createUserValidationMiddlewares(responders),
-    });
-}
-const resolveMiddlewareResponders = (loadMiddlewareConfig) => {
-    if (!isObject(loadMiddlewareConfig.responders))
-        return {};
-    const entries = Object.entries(loadMiddlewareConfig.responders).filter((entry) => {
-        const [name, responder] = entry;
-        return typeof name === 'string' && name.trim() !== '' && typeof responder === 'function';
-    });
-    return Object.freeze(Object.fromEntries(entries));
-};
-function createSharedMiddlewares(loadMiddlewareConfig, responders) {
-    const rateLimits = createRateLimitMiddlewares(loadMiddlewareConfig, responders);
-    const validations = createValidationMiddlewares(responders);
-    return Object.freeze({
-        log: LoggingMiddleware.create(),
-        error: ErrorHandlerMiddleware.create({ onFailure: responders.error }),
-        security: SecurityMiddleware.create(),
-        sanitizeBody: SanitizeBodyMiddleware.create(),
-        ...rateLimits,
-        csrf: CsrfMiddleware.create({
-            skipPaths: loadMiddlewareConfig?.skipPaths ?? [],
-            onFailure: responders.csrf,
-        }),
-        auth: AuthMiddleware.create({ onUnauthorized: responders.auth }),
-        jwt: JwtAuthMiddleware.create({ onUnauthorized: responders.jwt }),
-        bulletproof: BulletproofAuthMiddleware.create({ onUnauthorized: responders.bulletproof }),
-        ...validations,
-    });
-}
-const resolveProjectGlobalMiddlewares = (loadMiddlewareConfig) => {
-    if (!isArray(loadMiddlewareConfig.global))
-        return [];
-    return loadMiddlewareConfig.global.filter((middleware) => {
-        return typeof middleware === 'function';
-    });
-};
-const resolveProjectRouteMiddlewares = (loadMiddlewareConfig) => {
-    if (!isObject(loadMiddlewareConfig.route))
-        return {};
-    const entries = Object.entries(loadMiddlewareConfig.route).filter((entry) => {
-        const [name, middleware] = entry;
-        return typeof name === 'string' && name.trim() !== '' && typeof middleware === 'function';
-    });
-    return Object.fromEntries(entries);
-};
-const applySharedMiddlewareOverrides = (shared, projectRoute) => {
-    const overridden = { ...shared };
-    for (const key of Object.keys(MiddlewareKeys)) {
-        const candidate = projectRoute[key];
-        if (typeof candidate === 'function') {
-            overridden[key] = candidate;
-        }
-    }
-    return Object.freeze(overridden);
-};
-const createRouteMiddlewareRegistry = (resolvedShared, projectRoute, responders) => {
-    const target = Object.freeze({
-        ...resolvedShared,
-        ...projectRoute,
-    });
-    const dynamicRateLimits = new Map();
-    return new Proxy(target, {
-        get(currentTarget, prop, receiver) {
-            if (typeof prop !== 'string') {
-                return Reflect.get(currentTarget, prop, receiver);
-            }
-            const resolved = currentTarget[prop];
-            if (typeof resolved === 'function')
-                return resolved;
-            const cached = dynamicRateLimits.get(prop);
-            if (cached !== undefined)
-                return cached;
-            const parsed = parseParameterizedRateLimitKey(prop);
-            if (parsed === undefined)
-                return undefined;
-            const middleware = RateLimiter.create({
-                maxRequests: parsed.maxRequests,
-                windowMs: parsed.windowMs,
-                onFailure: responders.rateLimit,
-            });
-            dynamicRateLimits.set(prop, middleware);
-            return middleware;
-        },
-        ownKeys(currentTarget) {
-            return Reflect.ownKeys(currentTarget);
-        },
-        getOwnPropertyDescriptor(currentTarget, prop) {
-            return Reflect.getOwnPropertyDescriptor(currentTarget, prop);
-        },
-    });
-};
-export function createMiddlewareConfig() {
-    const loadMiddlewareConfig = StartupConfigFileRegistry.get(StartupConfigFile.Middleware) ?? {};
-    const defaultCsrfSkipPaths = ['/broadcasting/auth', '/apps/*/events'];
-    const mergeCsrfSkipPaths = (...groups) => {
-        const merged = new Set();
-        for (const group of groups) {
-            for (const path of group) {
-                const normalized = path.trim();
-                if (normalized !== '') {
-                    merged.add(normalized);
-                }
-            }
-        }
-        return [...merged];
-    };
-    const skipPathsFromEnv = Env.get('CSRF_SKIP_PATHS', '')
-        .split(',')
-        .map((path) => path.trim())
-        .filter((path) => path.length > 0);
-    const configuredSkipPaths = Array.isArray(loadMiddlewareConfig.skipPaths)
-        ? loadMiddlewareConfig.skipPaths
-        : [];
-    const effectiveSkipPaths = mergeCsrfSkipPaths(defaultCsrfSkipPaths, configuredSkipPaths, skipPathsFromEnv);
-    const effectiveMiddlewareConfig = {
-        ...loadMiddlewareConfig,
-        skipPaths: effectiveSkipPaths,
-    };
-    const responders = resolveMiddlewareResponders(effectiveMiddlewareConfig);
-    const shared = createSharedMiddlewares(effectiveMiddlewareConfig, responders);
-    const projectGlobal = resolveProjectGlobalMiddlewares(effectiveMiddlewareConfig);
-    const projectRoute = resolveProjectRouteMiddlewares(effectiveMiddlewareConfig);
-    const resolvedShared = applySharedMiddlewareOverrides(shared, projectRoute);
-    const routeMiddlewareRegistry = createRouteMiddlewareRegistry(resolvedShared, projectRoute, responders);
-    const middlewareConfigObj = {
-        global: [
-            resolvedShared.log,
-            resolvedShared.error,
-            resolvedShared.security,
-            resolvedShared.rateLimit,
-            fileUploadMiddleware,
-            bodyParsingMiddleware,
-            resolvedShared.csrf,
-            resolvedShared.sanitizeBody,
-            ...projectGlobal,
-        ],
-        route: routeMiddlewareRegistry,
-    };
-    return Object.freeze(middlewareConfigObj);
-}
-let cached = null;
-/**
- * Clear the middleware configuration cache
- * This ensures fresh config loading in watch mode
- */
-export const clearMiddlewareConfigCache = () => {
-    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

@@ -1,24 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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"}