@zintrust/core 0.1.41 → 0.1.43

package/packages/workers/src/http/WorkerMonitoringService.d.ts

@@ -0,0 +1,12 @@
+type SnapshotData = {
+    type: string;
+    ts: string;
+    monitoring: unknown;
+    workers: unknown;
+};
+export declare const WorkerMonitoringService: Readonly<{
+    subscribe(callback: (data: SnapshotData) => void): void;
+    unsubscribe(callback: (data: SnapshotData) => void): void;
+}>;
+export {};
+//# sourceMappingURL=WorkerMonitoringService.d.ts.map

package/packages/workers/src/http/WorkerMonitoringService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerMonitoringService.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/src/http/WorkerMonitoringService.ts"],"names":[],"mappings":"AAIA,KAAK,YAAY,GAAG;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAoFF,eAAO,MAAM,uBAAuB;wBACd,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,GAAG,IAAI;0BAQjC,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,GAAG,IAAI;EAOzD,CAAC"}

package/packages/workers/src/http/WorkerMonitoringService.js

@@ -0,0 +1,89 @@
+import { Logger, NodeSingletons, workersConfig } from '../../../../src/index.js';
+import { HealthMonitor } from '../HealthMonitor.js';
+import { getWorkers } from '../dashboard/workers-api.js';
+const createFallbackEmitter = () => {
+    const listeners = new Map();
+    return {
+        on(event, listener) {
+            const set = listeners.get(event) ?? new Set();
+            set.add(listener);
+            listeners.set(event, set);
+        },
+        off(event, listener) {
+            const set = listeners.get(event);
+            if (!set)
+                return;
+            set.delete(listener);
+            if (set.size === 0)
+                listeners.delete(event);
+        },
+        emit(event, payload) {
+            const set = listeners.get(event);
+            if (!set)
+                return false;
+            for (const listener of set)
+                listener(payload);
+            return true;
+        },
+    };
+};
+// Internal state
+const EventEmitterCtor = NodeSingletons?.EventEmitter;
+const emitter = typeof EventEmitterCtor === 'function' ? new EventEmitterCtor() : createFallbackEmitter();
+emitter.setMaxListeners?.(Infinity);
+let interval = null;
+let subscribers = 0;
+const INTERVAL_MS = workersConfig?.intervalMs || 5000;
+const broadcastSnapshot = async () => {
+    try {
+        if (subscribers <= 0)
+            return;
+        const monitoring = await HealthMonitor.getSummary();
+        // Fetch full workers listing optimized for dashboard
+        const workersPayload = await getWorkers({ page: 1, limit: 200 });
+        const payload = {
+            type: 'snapshot',
+            ts: new Date().toISOString(),
+            monitoring,
+            workers: workersPayload,
+        };
+        emitter.emit('snapshot', payload);
+    }
+    catch (err) {
+        Logger.error('WorkerMonitoringService.broadcastSnapshot failed', err);
+        emitter.emit('error', err);
+    }
+};
+const startPolling = () => {
+    if (interval)
+        return;
+    Logger.debug('Starting WorkerMonitoringService polling');
+    // Initial fetch
+    void broadcastSnapshot();
+    interval = setInterval(() => {
+        void broadcastSnapshot();
+    }, INTERVAL_MS);
+};
+const stopPolling = () => {
+    if (interval) {
+        Logger.debug('Stopping WorkerMonitoringService polling');
+        clearInterval(interval);
+        interval = null;
+    }
+};
+export const WorkerMonitoringService = Object.freeze({
+    subscribe(callback) {
+        emitter.on('snapshot', callback);
+        subscribers++;
+        if (subscribers === 1) {
+            startPolling();
+        }
+    },
+    unsubscribe(callback) {
+        emitter.off('snapshot', callback);
+        subscribers--;
+        if (subscribers <= 0) {
+            stopPolling();
+        }
+    },
+});

package/packages/workers/src/http/middleware/CustomValidation.d.ts

@@ -0,0 +1,93 @@
+import { type IRequest, type IResponse } from '../../../../../src/index.js';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+export interface ValidationSchema {
+    [key: string]: {
+        required?: boolean;
+        default?: unknown;
+        type?: 'string' | 'number' | 'boolean' | 'object' | 'array';
+        minLength?: number;
+        maxLength?: number;
+        min?: number;
+        max?: number;
+        pattern?: RegExp;
+        allowedValues?: unknown[];
+        custom?: (value: unknown) => string | null;
+    };
+}
+export declare const withCustomValidation: (schema: ValidationSchema, handler: RouteHandler) => RouteHandler;
+/**
+ * Predefined validation schemas for common use cases
+ */
+export declare const ValidationSchemas: {
+    /**
+     * Schema for pagination parameters
+     */
+    pagination: {
+        page: {
+            type: "number";
+            min: number;
+            default: number;
+        };
+        limit: {
+            type: "number";
+            min: number;
+            max: number;
+            default: number;
+        };
+    };
+    /**
+     * Schema for date range filtering
+     */
+    dateRange: {
+        startDate: {
+            type: "string";
+            pattern: RegExp;
+        };
+        endDate: {
+            type: "string";
+            pattern: RegExp;
+        };
+    };
+    /**
+     * Schema for sorting parameters
+     */
+    sorting: {
+        sortBy: {
+            type: "string";
+            allowedValues: string[];
+            default: string;
+        };
+        sortOrder: {
+            type: "string";
+            allowedValues: string[];
+            default: string;
+        };
+    };
+    /**
+     * Schema for worker filtering
+     */
+    workerFilter: {
+        status: {
+            type: "string";
+            allowedValues: string[];
+            optional: boolean;
+        };
+        queueName: {
+            type: "string";
+            minLength: number;
+            maxLength: number;
+            optional: boolean;
+        };
+        driver: {
+            type: "string";
+            allowedValues: string[];
+            optional: boolean;
+        };
+        search: {
+            type: "string";
+            maxLength: number;
+            optional: boolean;
+        };
+    };
+};
+//# sourceMappingURL=CustomValidation.d.ts.map

package/packages/workers/src/http/middleware/CustomValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CustomValidation.d.ts","sourceRoot":"","sources":["../../../../../../packages/workers/src/http/middleware/CustomValidation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEvE,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEnF,MAAM,WAAW,gBAAgB;IAC/B,CAAC,GAAG,EAAE,MAAM,GAAG;QACb,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,IAAI,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAC;QAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,aAAa,CAAC,EAAE,OAAO,EAAE,CAAC;QAC1B,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,GAAG,IAAI,CAAC;KAC5C,CAAC;CACH;AAsND,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,gBAAgB,EACxB,SAAS,YAAY,KACpB,YA8CF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB;IAC5B;;OAEG;;;;;;;;;;;;;;IAeH;;OAEG;;;;;;;;;;;IAYH;;OAEG;;;;;;;;;;;;;IAcH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;CAwBJ,CAAC"}

package/packages/workers/src/http/middleware/CustomValidation.js

@@ -0,0 +1,270 @@
+import { Logger } from '../../../../../src/index.js';
+/**
+ * Custom validation middleware that accepts a validation schema
+ * Provides flexible validation for any request data structure
+ */
+const validateRequiredField = (fieldName, value, fieldSchema) => {
+    if (fieldSchema.required && (value === undefined || value === null)) {
+        return {
+            field: fieldName,
+            message: `${fieldName} is required`,
+            code: 'MISSING_REQUIRED_FIELD',
+        };
+    }
+    return null;
+};
+const validateFieldType = (fieldName, value, fieldSchema) => {
+    if (!fieldSchema.type)
+        return null;
+    const actualType = Array.isArray(value) ? 'array' : typeof value;
+    if (actualType !== fieldSchema.type) {
+        return {
+            field: fieldName,
+            message: `${fieldName} must be of type ${fieldSchema.type}`,
+            code: 'INVALID_TYPE',
+        };
+    }
+    return null;
+};
+const validateStringField = (fieldName, value, fieldSchema) => {
+    const errors = [];
+    if (fieldSchema.minLength !== undefined && value.length < fieldSchema.minLength) {
+        errors.push({
+            field: fieldName,
+            message: `${fieldName} must be at least ${fieldSchema.minLength} characters long`,
+            code: 'STRING_TOO_SHORT',
+        });
+    }
+    if (fieldSchema.maxLength !== undefined && value.length > fieldSchema.maxLength) {
+        errors.push({
+            field: fieldName,
+            message: `${fieldName} must be at most ${fieldSchema.maxLength} characters long`,
+            code: 'STRING_TOO_LONG',
+        });
+    }
+    if (fieldSchema.pattern && !fieldSchema.pattern.test(value)) {
+        errors.push({
+            field: fieldName,
+            message: `${fieldName} format is invalid`,
+            code: 'INVALID_FORMAT',
+        });
+    }
+    return errors;
+};
+const validateNumberField = (fieldName, value, fieldSchema) => {
+    const errors = [];
+    if (fieldSchema.min !== undefined && value < fieldSchema.min) {
+        errors.push({
+            field: fieldName,
+            message: `${fieldName} must be at least ${fieldSchema.min}`,
+            code: 'NUMBER_TOO_SMALL',
+        });
+    }
+    if (fieldSchema.max !== undefined && value > fieldSchema.max) {
+        errors.push({
+            field: fieldName,
+            message: `${fieldName} must be at most ${fieldSchema.max}`,
+            code: 'NUMBER_TOO_LARGE',
+        });
+    }
+    return errors;
+};
+const validateArrayField = (fieldName, value, fieldSchema) => {
+    const errors = [];
+    if (fieldSchema.minLength !== undefined && value.length < fieldSchema.minLength) {
+        errors.push({
+            field: fieldName,
+            message: `${fieldName} must contain at least ${fieldSchema.minLength} items`,
+            code: 'ARRAY_TOO_SHORT',
+        });
+    }
+    if (fieldSchema.maxLength !== undefined && value.length > fieldSchema.maxLength) {
+        errors.push({
+            field: fieldName,
+            message: `${fieldName} must contain at most ${fieldSchema.maxLength} items`,
+            code: 'ARRAY_TOO_LONG',
+        });
+    }
+    return errors;
+};
+const validateAllowedValues = (fieldName, value, fieldSchema) => {
+    if (fieldSchema.allowedValues && !fieldSchema.allowedValues.includes(value)) {
+        return {
+            field: fieldName,
+            message: `${fieldName} must be one of: ${fieldSchema.allowedValues.join(', ')}`,
+            code: 'INVALID_VALUE',
+        };
+    }
+    return null;
+};
+const validateCustomRule = (fieldName, value, fieldSchema) => {
+    if (fieldSchema.custom) {
+        const customError = fieldSchema.custom(value);
+        if (customError) {
+            return {
+                field: fieldName,
+                message: customError,
+                code: 'CUSTOM_VALIDATION_FAILED',
+            };
+        }
+    }
+    return null;
+};
+const validateField = (fieldName, value, fieldSchema) => {
+    const errors = [];
+    // Check required field
+    const requiredError = validateRequiredField(fieldName, value, fieldSchema);
+    if (requiredError) {
+        errors.push(requiredError);
+        return errors; // Skip other validations for missing required field
+    }
+    // Skip validation if field is not provided and not required
+    if (value === undefined || value === null) {
+        return errors;
+    }
+    // Type validation
+    const typeError = validateFieldType(fieldName, value, fieldSchema);
+    if (typeError) {
+        errors.push(typeError);
+        return errors; // Skip other validations for wrong type
+    }
+    // String validations
+    if (typeof value === 'string') {
+        errors.push(...validateStringField(fieldName, value, fieldSchema));
+    }
+    // Number validations
+    if (typeof value === 'number') {
+        errors.push(...validateNumberField(fieldName, value, fieldSchema));
+    }
+    // Array validations
+    if (Array.isArray(value)) {
+        errors.push(...validateArrayField(fieldName, value, fieldSchema));
+    }
+    // Allowed values validation
+    const allowedValuesError = validateAllowedValues(fieldName, value, fieldSchema);
+    if (allowedValuesError) {
+        errors.push(allowedValuesError);
+    }
+    // Custom validation
+    const customError = validateCustomRule(fieldName, value, fieldSchema);
+    if (customError) {
+        errors.push(customError);
+    }
+    return errors;
+};
+export const withCustomValidation = (schema, handler) => {
+    return async (req, res) => {
+        try {
+            const currentBody = req.getBody();
+            const data = { ...req.data() };
+            // Apply defaults from schema into request body when missing
+            for (const [fieldName, fieldSchema] of Object.entries(schema)) {
+                if ((data[fieldName] === undefined || data[fieldName] === null) &&
+                    fieldSchema.default !== undefined) {
+                    data[fieldName] = fieldSchema.default;
+                }
+            }
+            // Persist defaults back into request body so downstream handlers see them
+            req.setBody({ ...currentBody, ...data });
+            const errors = [];
+            // Validate each field in the schema
+            for (const [fieldName, fieldSchema] of Object.entries(schema)) {
+                const value = data[fieldName];
+                const fieldErrors = validateField(fieldName, value, fieldSchema);
+                errors.push(...fieldErrors);
+            }
+            // Return errors if any validation failed
+            if (errors.length > 0) {
+                return res.setStatus(400).json({
+                    error: 'Validation failed',
+                    message: 'Request data validation failed',
+                    code: 'VALIDATION_FAILED',
+                    details: errors,
+                });
+            }
+            return handler(req, res);
+        }
+        catch (error) {
+            Logger.error('Custom validation failed', error);
+            return res.setStatus(500).json({
+                error: 'Internal validation error',
+                code: 'VALIDATION_ERROR',
+            });
+        }
+    };
+};
+/**
+ * Predefined validation schemas for common use cases
+ */
+export const ValidationSchemas = {
+    /**
+     * Schema for pagination parameters
+     */
+    pagination: {
+        page: {
+            type: 'number',
+            min: 1,
+            default: 1,
+        },
+        limit: {
+            type: 'number',
+            min: 1,
+            max: 100,
+            default: 20,
+        },
+    },
+    /**
+     * Schema for date range filtering
+     */
+    dateRange: {
+        startDate: {
+            type: 'string',
+            pattern: /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/,
+        },
+        endDate: {
+            type: 'string',
+            pattern: /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/,
+        },
+    },
+    /**
+     * Schema for sorting parameters
+     */
+    sorting: {
+        sortBy: {
+            type: 'string',
+            allowedValues: ['name', 'status', 'createdAt', 'updatedAt', 'queueName'],
+            default: 'createdAt',
+        },
+        sortOrder: {
+            type: 'string',
+            allowedValues: ['asc', 'desc'],
+            default: 'desc',
+        },
+    },
+    /**
+     * Schema for worker filtering
+     */
+    workerFilter: {
+        status: {
+            type: 'string',
+            allowedValues: ['running', 'stopped', 'failed', 'paused', ''],
+            optional: true,
+        },
+        queueName: {
+            type: 'string',
+            minLength: 3,
+            maxLength: 50,
+            optional: true,
+        },
+        driver: {
+            type: 'string',
+            allowedValues: ['db', 'database', 'redis', 'memory', ''],
+            optional: true,
+        },
+        search: {
+            type: 'string',
+            maxLength: 100,
+            optional: true,
+        },
+    },
+};

package/packages/workers/src/http/middleware/DatacenterValidator.d.ts

@@ -0,0 +1,4 @@
+import { type IRequest, type IResponse } from '../../../../../src/index.js';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+export declare const withDatacenterValidation: (handler: RouteHandler) => RouteHandler;
+//# sourceMappingURL=DatacenterValidator.d.ts.map

package/packages/workers/src/http/middleware/DatacenterValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatacenterValidator.d.ts","sourceRoot":"","sources":["../../../../../../packages/workers/src/http/middleware/DatacenterValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEvE,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAqEnF,eAAO,MAAM,wBAAwB,GAAI,SAAS,YAAY,KAAG,YAoDhE,CAAC"}

package/packages/workers/src/http/middleware/DatacenterValidator.js

@@ -0,0 +1,94 @@
+import { Logger } from '../../../../../src/index.js';
+const validateRegion = (region) => {
+    // Allow custom region names but validate format
+    return /^[a-z0-9-]+$/.test(region) && region.length >= 3 && region.length <= 20;
+};
+const validatePrimaryRegion = (primaryRegion) => {
+    if (!primaryRegion) {
+        return 'Primary region is required';
+    }
+    if (!validateRegion(primaryRegion)) {
+        return 'Primary region must be 3-20 characters, lowercase letters, numbers, and hyphens only';
+    }
+    return null;
+};
+const validateSecondaryRegions = (secondaryRegions) => {
+    if (!Array.isArray(secondaryRegions)) {
+        return 'Secondary regions must be an array';
+    }
+    for (const region of secondaryRegions) {
+        if (!validateRegion(region)) {
+            return `Secondary region '${region}' must be 3-20 characters, lowercase letters, numbers, and hyphens only`;
+        }
+    }
+    return null;
+};
+const validateAffinityRules = (affinityRules) => {
+    if (!affinityRules) {
+        return 'Affinity rules are required';
+    }
+    if (typeof affinityRules.preferLocal !== 'boolean') {
+        return 'Affinity rule preferLocal must be a boolean';
+    }
+    if (typeof affinityRules.maxLatency !== 'number' || affinityRules.maxLatency < 0) {
+        return 'Affinity rule maxLatency must be a non-negative number';
+    }
+    if (!Array.isArray(affinityRules.avoidRegions)) {
+        return 'Affinity rule avoidRegions must be an array';
+    }
+    for (const region of affinityRules.avoidRegions) {
+        if (!validateRegion(region)) {
+            return `Avoid region '${region}' must be 3-20 characters, lowercase letters, numbers, and hyphens only`;
+        }
+    }
+    return null;
+};
+export const withDatacenterValidation = (handler) => {
+    return async (req, res) => {
+        try {
+            const data = req.data();
+            const datacenter = data['datacenter'];
+            if (!datacenter) {
+                return res.setStatus(400).json({
+                    error: 'Datacenter configuration is required',
+                    code: 'MISSING_DATACENTER',
+                });
+            }
+            // Validate primary region
+            const primaryRegionError = validatePrimaryRegion(datacenter.primaryRegion);
+            if (primaryRegionError) {
+                return res.setStatus(400).json({
+                    error: 'Invalid primary region',
+                    message: primaryRegionError,
+                    code: 'INVALID_PRIMARY_REGION',
+                });
+            }
+            // Validate secondary regions
+            const secondaryRegionsError = validateSecondaryRegions(datacenter.secondaryRegions);
+            if (secondaryRegionsError) {
+                return res.setStatus(400).json({
+                    error: 'Invalid secondary regions',
+                    message: secondaryRegionsError,
+                    code: 'INVALID_SECONDARY_REGIONS',
+                });
+            }
+            // Validate affinity rules
+            const affinityRulesError = validateAffinityRules(datacenter.affinityRules);
+            if (affinityRulesError) {
+                return res.setStatus(400).json({
+                    error: 'Invalid affinity rules',
+                    message: affinityRulesError,
+                    code: 'INVALID_AFFINITY_RULES',
+                });
+            }
+            return handler(req, res);
+        }
+        catch (error) {
+            Logger.error('Datacenter validation failed', error);
+            return res.setStatus(500).json({
+                error: 'Internal validation error',
+                code: 'VALIDATION_ERROR',
+            });
+        }
+    };
+};

package/packages/workers/src/http/middleware/EditWorkerValidation.d.ts

@@ -0,0 +1,8 @@
+import { type IRequest, type IResponse } from '../../../../../src/index.js';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+/**
+ * Composite middleware for worker edit validation
+ * Maps processorSpec to processor for validation and validates all editable fields
+ */
+export declare const withEditWorkerValidation: (handler: RouteHandler) => RouteHandler;
+//# sourceMappingURL=EditWorkerValidation.d.ts.map

package/packages/workers/src/http/middleware/EditWorkerValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EditWorkerValidation.d.ts","sourceRoot":"","sources":["../../../../../../packages/workers/src/http/middleware/EditWorkerValidation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEvE,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAYnF;;;GAGG;AACH,eAAO,MAAM,wBAAwB,GAAI,SAAS,YAAY,KAAG,YAwDhE,CAAC"}

package/packages/workers/src/http/middleware/EditWorkerValidation.js

@@ -0,0 +1,56 @@
+import { Logger } from '../../../../../src/index.js';
+// Import individual validators
+import { withDatacenterValidation } from './DatacenterValidator.js';
+import { withFeaturesValidation } from './FeaturesValidator.js';
+import { withInfrastructureValidation } from './InfrastructureValidator.js';
+import { withStrictPayloadKeys } from './PayloadSanitizer.js';
+import { withProcessorPathValidation } from './ProcessorPathSanitizer.js';
+import { withQueueNameValidation } from './QueueNameSanitizer.js';
+import { withVersionValidation } from './VersionSanitizer.js';
+import { withWorkerNameValidation } from './WorkerNameSanitizer.js';
+/**
+ * Composite middleware for worker edit validation
+ * Maps processorSpec to processor for validation and validates all editable fields
+ */
+export const withEditWorkerValidation = (handler) => {
+    return async (req, res) => {
+        try {
+            const data = req.data();
+            const currentBody = req.getBody();
+            // Map processorSpec/processorSpec to processor for validation if provided
+            let mappedBody = { ...currentBody };
+            if (data['processorSpec'] && !data['processor']) {
+                mappedBody = {
+                    ...mappedBody,
+                    processor: data['processorSpec'],
+                };
+            }
+            // Update the request body with mapped fields
+            req.setBody(mappedBody);
+            // Apply validation with mapped fields, skipping options validation for editing
+            return withStrictPayloadKeys([
+                'name',
+                'queueName',
+                'processor', // Validated field (mapped from processorSpec)
+                'processorSpec',
+                'version',
+                'options', // Skip strict validation for editing
+                'infrastructure',
+                'features',
+                'datacenter',
+                'concurrency', // Original field
+                'region',
+                'autoStart',
+                'activeStatus',
+                'status',
+            ], withProcessorPathValidation(withWorkerNameValidation(withQueueNameValidation(withVersionValidation(withInfrastructureValidation(withFeaturesValidation(withDatacenterValidation(handler))))))))(req, res);
+        }
+        catch (error) {
+            Logger.error('Edit worker validation failed', error);
+            return res.setStatus(500).json({
+                error: 'Internal validation error',
+                code: 'VALIDATION_ERROR',
+            });
+        }
+    };
+};

package/packages/workers/src/http/middleware/FeaturesValidator.d.ts

@@ -0,0 +1,4 @@
+import { type IRequest, type IResponse } from '../../../../../src/index.js';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+export declare const withFeaturesValidation: (handler: RouteHandler) => RouteHandler;
+//# sourceMappingURL=FeaturesValidator.d.ts.map

package/packages/workers/src/http/middleware/FeaturesValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeaturesValidator.d.ts","sourceRoot":"","sources":["../../../../../../packages/workers/src/http/middleware/FeaturesValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEvE,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AA8BnF,eAAO,MAAM,sBAAsB,GAAI,SAAS,YAAY,KAAG,YAiD9D,CAAC"}