@zintrust/workers 0.1.27

package/dist/http/middleware/CustomValidation.d.ts

@@ -0,0 +1,92 @@
+import { type IRequest, type IResponse } from '@zintrust/core';
+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;
+        };
+    };
+};

package/dist/http/middleware/CustomValidation.js

@@ -0,0 +1,270 @@
+import { Logger } from '@zintrust/core';
+/**
+ * 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', 'redis', 'memory', ''],
+            optional: true,
+        },
+        search: {
+            type: 'string',
+            maxLength: 100,
+            optional: true,
+        },
+    },
+};

package/dist/http/middleware/DatacenterValidator.d.ts

@@ -0,0 +1,3 @@
+import { type IRequest, type IResponse } from '@zintrust/core';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+export declare const withDatacenterValidation: (handler: RouteHandler) => RouteHandler;

package/dist/http/middleware/DatacenterValidator.js

@@ -0,0 +1,94 @@
+import { Logger } from '@zintrust/core';
+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/dist/http/middleware/EditWorkerValidation.d.ts

@@ -0,0 +1,7 @@
+import { type IRequest, type IResponse } from '@zintrust/core';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+/**
+ * Composite middleware for worker edit validation
+ * Maps processorPath to processor for validation and validates all editable fields
+ */
+export declare const withEditWorkerValidation: (handler: RouteHandler) => RouteHandler;

package/dist/http/middleware/EditWorkerValidation.js

@@ -0,0 +1,55 @@
+import { Logger } from '@zintrust/core';
+// Import individual validators
+import { withDatacenterValidation } from './DatacenterValidator';
+import { withFeaturesValidation } from './FeaturesValidator';
+import { withInfrastructureValidation } from './InfrastructureValidator';
+import { withStrictPayloadKeys } from './PayloadSanitizer';
+import { withProcessorPathValidation } from './ProcessorPathSanitizer';
+import { withQueueNameValidation } from './QueueNameSanitizer';
+import { withVersionValidation } from './VersionSanitizer';
+import { withWorkerNameValidation } from './WorkerNameSanitizer';
+/**
+ * Composite middleware for worker edit validation
+ * Maps processorPath 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 processorPath to processor for validation if processorPath exists
+            let mappedBody = { ...currentBody };
+            if (data['processorPath'] && !data['processor']) {
+                mappedBody = {
+                    ...mappedBody,
+                    processor: data['processorPath'], // Map for validation
+                };
+            }
+            // 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 processorPath)
+                'processorPath', // Original field
+                'version',
+                'options', // Skip strict validation for editing
+                'infrastructure',
+                'features',
+                'datacenter',
+                'concurrency', // Original field
+                'region',
+                'autoStart',
+                '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/dist/http/middleware/FeaturesValidator.d.ts

@@ -0,0 +1,3 @@
+import { type IRequest, type IResponse } from '@zintrust/core';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+export declare const withFeaturesValidation: (handler: RouteHandler) => RouteHandler;

package/dist/http/middleware/FeaturesValidator.js

@@ -0,0 +1,60 @@
+import { Logger } from '@zintrust/core';
+const VALID_FEATURES = new Set([
+    'clustering',
+    'metrics',
+    'autoScaling',
+    'circuitBreaker',
+    'deadLetterQueue',
+    'resourceMonitoring',
+    'compliance',
+    'observability',
+    'plugins',
+    'versioning',
+    'datacenterOrchestration',
+]);
+export const withFeaturesValidation = (handler) => {
+    return async (req, res) => {
+        try {
+            const data = req.data();
+            const features = data['features'];
+            if (!features) {
+                return handler(req, res); // Skip validation if features is not provided
+            }
+            // Check if features is an object
+            if (typeof features !== 'object' || features === null || Array.isArray(features)) {
+                return res.setStatus(400).json({
+                    error: 'Invalid features configuration',
+                    message: 'Features must be an object',
+                    code: 'INVALID_FEATURES_TYPE',
+                });
+            }
+            // Validate each feature key and value
+            const featureKeys = Object.keys(features);
+            for (const key of featureKeys) {
+                if (!VALID_FEATURES.has(key)) {
+                    return res.setStatus(400).json({
+                        error: 'Invalid feature',
+                        message: `Unknown feature: ${key}. Valid features are: ${Array.from(VALID_FEATURES).join(', ')}`,
+                        code: 'INVALID_FEATURE',
+                    });
+                }
+                const value = features[key];
+                if (typeof value !== 'boolean') {
+                    return res.setStatus(400).json({
+                        error: 'Invalid feature value',
+                        message: `Feature ${key} must be a boolean (true or false)`,
+                        code: 'INVALID_FEATURE_VALUE',
+                    });
+                }
+            }
+            return handler(req, res);
+        }
+        catch (error) {
+            Logger.error('Features validation failed', error);
+            return res.setStatus(500).json({
+                error: 'Internal validation error',
+                code: 'VALIDATION_ERROR',
+            });
+        }
+    };
+};

package/dist/http/middleware/InfrastructureValidator.d.ts

@@ -0,0 +1,31 @@
+import { type IRequest, type IResponse } from '@zintrust/core';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+export interface InfrastructureConfig {
+    persistence: {
+        driver: string;
+    };
+    redis: {
+        env: boolean;
+        host: string;
+        port: string;
+        db: string;
+        password: string;
+    };
+    deadLetterQueue: {
+        policy: string;
+    };
+    compliance: {
+        config: {
+            retentionDays: number;
+        };
+    };
+    observability: {
+        enabled: boolean;
+    };
+    autoScaler: {
+        enabled: boolean;
+        minWorkers: number;
+        maxWorkers: number;
+    };
+}
+export declare const withInfrastructureValidation: (handler: RouteHandler) => RouteHandler;