@zintrust/core 0.4.17 → 0.4.18

package/src/config/middleware.d.ts

@@ -0,0 +1,57 @@
+import type { MiddlewareConfigType } from './type';
+import type { Middleware } from '../middleware/MiddlewareStack';
+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;
+        max: number;
+        message: string;
+    };
+    authRateLimit: {
+        windowMs: number;
+        max: number;
+        message: string;
+    };
+    userMutationRateLimit: {
+        windowMs: number;
+        max: number;
+        message: string;
+    };
+    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 MiddlewareKey = keyof typeof MiddlewareKeys;
+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

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../../src/config/middleware.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAUzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAwD9D,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,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;IAC1E,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,aAAa,GAAG,MAAM,OAAO,cAAc,CAAC;AAoOxD,wBAAgB,sBAAsB,IAAI,oBAAoB,CAwC7D;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

@@ -0,0 +1,249 @@
+import { Env } from './env.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',
+    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,
+});
+// 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(),
+        bulletproof: BulletproofAuthMiddleware.create(),
+        ...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);
+};
+export function createMiddlewareConfig() {
+    const loadMiddlewareConfig = StartupConfigFileRegistry.get(StartupConfigFile.Middleware) ?? {};
+    const skipPathsFromEnv = Env.get('CSRF_SKIP_PATHS', '')
+        .split(',')
+        .map((path) => path.trim())
+        .filter((path) => path.length > 0);
+    const effectiveMiddlewareConfig = {
+        ...loadMiddlewareConfig,
+        skipPaths: Array.isArray(loadMiddlewareConfig.skipPaths) && loadMiddlewareConfig.skipPaths.length > 0
+            ? loadMiddlewareConfig.skipPaths
+            : skipPathsFromEnv,
+    };
+    const shared = createSharedMiddlewares(effectiveMiddlewareConfig);
+    const projectGlobal = resolveProjectGlobalMiddlewares(effectiveMiddlewareConfig);
+    const projectRoute = resolveProjectRouteMiddlewares(effectiveMiddlewareConfig);
+    const middlewareConfigObj = {
+        global: [
+            shared.log,
+            shared.error,
+            shared.security,
+            shared.rateLimit,
+            fileUploadMiddleware,
+            bodyParsingMiddleware,
+            shared.csrf,
+            shared.sanitizeBody,
+            ...projectGlobal,
+        ],
+        route: {
+            ...shared,
+            ...projectRoute,
+        },
+    };
+    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

@@ -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: (driverConfig: 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;AASH,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;AA+EH;;GAEG;AACH,eAAO,MAAM,iBAAiB,QAAO,kBA4DnC,CAAC;AA8CH,QAAA,MAAM,iBAAiB,QAAO;IAC5B,OAAO,EAAE,eAAe,CAAC;IACzB,OAAO,EAAE,kBAAkB,CAAC;IAC5B,SAAS,EAAE,CAAC,YAAY,EAAE,sBAAsB,KAAK,kBAAkB,CAAC,eAAe,CAAC,CAAC;IACzF,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"}