@zintrust/workers 0.1.27

package/src/http/middleware/CustomValidation.ts

@@ -0,0 +1,360 @@
+import { Logger, 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; // Returns error message or null
+  };
+}
+
+/**
+ * Custom validation middleware that accepts a validation schema
+ * Provides flexible validation for any request data structure
+ */
+const validateRequiredField = (
+  fieldName: string,
+  value: unknown,
+  fieldSchema: ValidationSchema[string]
+): { field: string; message: string; code: string } | null => {
+  if (fieldSchema.required && (value === undefined || value === null)) {
+    return {
+      field: fieldName,
+      message: `${fieldName} is required`,
+      code: 'MISSING_REQUIRED_FIELD',
+    };
+  }
+  return null;
+};
+
+const validateFieldType = (
+  fieldName: string,
+  value: unknown,
+  fieldSchema: ValidationSchema[string]
+): { field: string; message: string; code: string } | null => {
+  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: string,
+  value: string,
+  fieldSchema: ValidationSchema[string]
+): { field: string; message: string; code: string }[] => {
+  const errors: { field: string; message: string; code: string }[] = [];
+
+  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: string,
+  value: number,
+  fieldSchema: ValidationSchema[string]
+): { field: string; message: string; code: string }[] => {
+  const errors: { field: string; message: string; code: string }[] = [];
+
+  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: string,
+  value: unknown[],
+  fieldSchema: ValidationSchema[string]
+): { field: string; message: string; code: string }[] => {
+  const errors: { field: string; message: string; code: string }[] = [];
+
+  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: string,
+  value: unknown,
+  fieldSchema: ValidationSchema[string]
+): { field: string; message: string; code: string } | null => {
+  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: string,
+  value: unknown,
+  fieldSchema: ValidationSchema[string]
+): { field: string; message: string; code: string } | null => {
+  if (fieldSchema.custom) {
+    const customError = fieldSchema.custom(value);
+    if (customError) {
+      return {
+        field: fieldName,
+        message: customError,
+        code: 'CUSTOM_VALIDATION_FAILED',
+      };
+    }
+  }
+  return null;
+};
+
+const validateField = (
+  fieldName: string,
+  value: unknown,
+  fieldSchema: ValidationSchema[string]
+): { field: string; message: string; code: string }[] => {
+  const errors: { field: string; message: string; code: string }[] = [];
+
+  // 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: ValidationSchema,
+  handler: RouteHandler
+): RouteHandler => {
+  return async (req: IRequest, res: IResponse): Promise<void> => {
+    try {
+      const currentBody = req.getBody() as Record<string, unknown>;
+      const data = { ...req.data() } as Record<string, unknown>;
+
+      // 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: Array<{ field: string; message: string; code: string }> = [];
+
+      // 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' as const,
+      min: 1,
+      default: 1,
+    },
+    limit: {
+      type: 'number' as const,
+      min: 1,
+      max: 100,
+      default: 20,
+    },
+  },
+
+  /**
+   * Schema for date range filtering
+   */
+  dateRange: {
+    startDate: {
+      type: 'string' as const,
+      pattern: /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/,
+    },
+    endDate: {
+      type: 'string' as const,
+      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' as const,
+      allowedValues: ['name', 'status', 'createdAt', 'updatedAt', 'queueName'],
+      default: 'createdAt',
+    },
+    sortOrder: {
+      type: 'string' as const,
+      allowedValues: ['asc', 'desc'],
+      default: 'desc',
+    },
+  },
+
+  /**
+   * Schema for worker filtering
+   */
+  workerFilter: {
+    status: {
+      type: 'string' as const,
+      allowedValues: ['running', 'stopped', 'failed', 'paused', ''],
+      optional: true,
+    },
+    queueName: {
+      type: 'string' as const,
+      minLength: 3,
+      maxLength: 50,
+      optional: true,
+    },
+    driver: {
+      type: 'string' as const,
+      allowedValues: ['db', 'redis', 'memory', ''],
+      optional: true,
+    },
+    search: {
+      type: 'string' as const,
+      maxLength: 100,
+      optional: true,
+    },
+  },
+};

package/src/http/middleware/DatacenterValidator.ts

@@ -0,0 +1,124 @@
+import { Logger, type IRequest, type IResponse } from '@zintrust/core';
+
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+
+interface DatacenterConfig {
+  primaryRegion: string;
+  secondaryRegions: string[];
+  affinityRules: {
+    preferLocal: boolean;
+    maxLatency: number;
+    avoidRegions: string[];
+  };
+}
+
+const validateRegion = (region: string): boolean => {
+  // Allow custom region names but validate format
+  return /^[a-z0-9-]+$/.test(region) && region.length >= 3 && region.length <= 20;
+};
+
+const validatePrimaryRegion = (primaryRegion: string): string | null => {
+  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: string[]): string | null => {
+  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: DatacenterConfig['affinityRules']): string | null => {
+  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: RouteHandler): RouteHandler => {
+  return async (req: IRequest, res: IResponse): Promise<void> => {
+    try {
+      const data = req.data();
+      const datacenter = data['datacenter'] as DatacenterConfig;
+
+      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/src/http/middleware/EditWorkerValidation.ts

@@ -0,0 +1,74 @@
+import { Logger, type IRequest, type IResponse } from '@zintrust/core';
+
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+
+// 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: RouteHandler): RouteHandler => {
+  return async (req: IRequest, res: IResponse): Promise<void> => {
+    try {
+      const data = req.data();
+      const currentBody = req.getBody() as Record<string, unknown>;
+
+      // 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/src/http/middleware/FeaturesValidator.ts

@@ -0,0 +1,82 @@
+import { Logger, type IRequest, type IResponse } from '@zintrust/core';
+
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+
+interface FeaturesConfig {
+  clustering: boolean;
+  metrics: boolean;
+  autoScaling: boolean;
+  circuitBreaker: boolean;
+  deadLetterQueue: boolean;
+  resourceMonitoring: boolean;
+  compliance: boolean;
+  observability: boolean;
+  plugins: boolean;
+  versioning: boolean;
+  datacenterOrchestration: boolean;
+}
+
+const VALID_FEATURES = new Set([
+  'clustering',
+  'metrics',
+  'autoScaling',
+  'circuitBreaker',
+  'deadLetterQueue',
+  'resourceMonitoring',
+  'compliance',
+  'observability',
+  'plugins',
+  'versioning',
+  'datacenterOrchestration',
+]);
+
+export const withFeaturesValidation = (handler: RouteHandler): RouteHandler => {
+  return async (req: IRequest, res: IResponse): Promise<void> => {
+    try {
+      const data = req.data();
+      const features = data['features'] as FeaturesConfig;
+
+      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 as keyof FeaturesConfig];
+        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',
+      });
+    }
+  };
+};