@zintrust/core 0.1.49 → 0.1.51

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1 +0,0 @@
-{"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;AAgBnF,eAAO,MAAM,sBAAsB,GAAI,SAAS,YAAY,KAAG,YAoD9D,CAAC"}