@zintrust/workers 0.1.27

package/src/http/middleware/InfrastructureValidator.ts

@@ -0,0 +1,295 @@
+import { Logger, type IRequest, type IResponse } from '@zintrust/core';
+
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+
+const VALID_DRIVERS = new Set(['database', 'redis', 'memory']);
+const VALID_DEAD_LETTER_POLICIES = new Set(['expire', 'retry', 'dead-letter']);
+
+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;
+  };
+}
+
+const validatePersistence = (persistence: InfrastructureConfig['persistence']): string | null => {
+  if (!persistence) return 'Persistence configuration is required';
+
+  // Validate persistence driver
+  if (!persistence.driver) {
+    return 'Persistence driver is required';
+  }
+
+  if (!VALID_DRIVERS.has(persistence.driver)) {
+    return 'Persistence driver must be one of: database, redis, memory';
+  }
+
+  return null;
+};
+
+const validateRedis = (redis: InfrastructureConfig['redis']): string | null => {
+  if (!redis) return 'Redis configuration is required';
+
+  // Validate env flag
+  if (typeof redis.env !== 'boolean') {
+    return 'Redis env flag must be a boolean';
+  }
+
+  // Validate required fields when not using env
+  if (!redis.env) {
+    const requiredFieldsError = validateRequiredRedisFields(redis);
+    if (requiredFieldsError) return requiredFieldsError;
+  }
+
+  // Validate string fields
+  return validateRedisStringFields(redis);
+};
+
+const validateRequiredRedisFields = (redis: InfrastructureConfig['redis']): string | null => {
+  if (!redis.host || typeof redis.host !== 'string') {
+    return 'Redis host is required when env is false';
+  }
+  if (redis.port === undefined || redis.port === null) {
+    return 'Redis port is required when env is false';
+  }
+  if (typeof redis.port !== 'string' && typeof redis.port !== 'number') {
+    return 'Redis port must be a string or number';
+  }
+  if (!redis.db || typeof redis.db !== 'string') {
+    return 'Redis db is required when env is false';
+  }
+  return null;
+};
+
+const validateRedisStringFields = (redis: InfrastructureConfig['redis']): string | null => {
+  if (redis.host && typeof redis.host !== 'string') {
+    return 'Redis host must be a string';
+  }
+  if (redis.port && typeof redis.port !== 'string' && typeof redis.port !== 'number') {
+    return 'Redis port must be a string or number';
+  }
+  if (redis.db && typeof redis.db !== 'string') {
+    return 'Redis db must be a string';
+  }
+  if (redis.password && typeof redis.password !== 'string') {
+    return 'Redis password must be a string';
+  }
+  return null;
+};
+
+const validateDeadLetterQueue = (
+  deadLetterQueue: InfrastructureConfig['deadLetterQueue']
+): string | null => {
+  if (!deadLetterQueue) return 'DeadLetterQueue configuration is required';
+
+  // Validate policy
+  if (!deadLetterQueue.policy) {
+    return 'DeadLetterQueue policy is required';
+  }
+
+  if (!VALID_DEAD_LETTER_POLICIES.has(deadLetterQueue.policy)) {
+    return 'Policy must be one of: expire, retry, dead-letter';
+  }
+
+  return null;
+};
+
+const validateCompliance = (compliance: InfrastructureConfig['compliance']): string | null => {
+  if (!compliance) return 'Compliance configuration is required';
+
+  if (!compliance.config) {
+    return 'Compliance config is required';
+  }
+
+  if (typeof compliance.config.retentionDays !== 'number' || compliance.config.retentionDays < 0) {
+    return 'Retention days must be a non-negative number';
+  }
+  const MAX_RETENTION_DAYS = 3650; // ~10 years
+  if (compliance.config.retentionDays > MAX_RETENTION_DAYS) {
+    return `Retention days cannot exceed ${MAX_RETENTION_DAYS}`;
+  }
+
+  return null;
+};
+
+const validateObservability = (
+  observability: InfrastructureConfig['observability']
+): string | null => {
+  if (!observability) return 'Observability configuration is required';
+
+  if (typeof observability.enabled !== 'boolean') {
+    return 'Observability enabled flag must be a boolean';
+  }
+
+  return null;
+};
+
+const validateAutoScaler = (autoScaler: InfrastructureConfig['autoScaler']): string | null => {
+  if (!autoScaler) return 'AutoScaler configuration is required';
+
+  if (typeof autoScaler.enabled !== 'boolean') {
+    return 'AutoScaler enabled flag must be a boolean';
+  }
+
+  if (autoScaler.enabled) {
+    const minWorkersError = validateWorkerCount(autoScaler.minWorkers, 'minWorkers');
+    if (minWorkersError) return minWorkersError;
+
+    const maxWorkersError = validateWorkerCount(autoScaler.maxWorkers, 'maxWorkers');
+    if (maxWorkersError) return maxWorkersError;
+
+    if (autoScaler.minWorkers > autoScaler.maxWorkers) {
+      return 'AutoScaler minWorkers cannot be greater than maxWorkers';
+    }
+    const MAX_AUTOSCALER_WORKERS = 1000;
+    if (autoScaler.maxWorkers > MAX_AUTOSCALER_WORKERS) {
+      return `AutoScaler maxWorkers cannot exceed ${MAX_AUTOSCALER_WORKERS}`;
+    }
+  }
+
+  return null;
+};
+
+const validateWorkerCount = (value: number, fieldName: string): string | null => {
+  if (typeof value !== 'number') {
+    return `AutoScaler ${fieldName} must be a number`;
+  }
+
+  if (!Number.isInteger(value)) {
+    return `AutoScaler ${fieldName} must be a whole number (integer)`;
+  }
+
+  if (value < 0) {
+    return `AutoScaler ${fieldName} must be a non-negative number`;
+  }
+
+  return null;
+};
+
+const sanitizeInfrastructure = (infrastructure: InfrastructureConfig): InfrastructureConfig => {
+  return {
+    ...infrastructure,
+    autoScaler: {
+      ...infrastructure.autoScaler,
+      minWorkers: Math.floor(infrastructure.autoScaler.minWorkers),
+      maxWorkers: Math.floor(infrastructure.autoScaler.maxWorkers),
+    },
+  };
+};
+
+export const withInfrastructureValidation = (handler: RouteHandler): RouteHandler => {
+  return async (req: IRequest, res: IResponse): Promise<void> => {
+    try {
+      const data = req.data();
+      const infrastructure = data['infrastructure'] as InfrastructureConfig;
+
+      if (!infrastructure) {
+        return res.setStatus(400).json({
+          error: 'Infrastructure configuration is required',
+          code: 'MISSING_INFRASTRUCTURE',
+        });
+      }
+
+      // Validate persistence
+      const persistenceError = validatePersistence(infrastructure.persistence);
+      if (persistenceError) {
+        return res.setStatus(400).json({
+          error: 'Invalid persistence configuration',
+          message: persistenceError,
+          code: 'INVALID_PERSISTENCE_CONFIG',
+        });
+      }
+
+      // Validate redis
+      const redisError = validateRedis(infrastructure.redis);
+      if (redisError) {
+        return res.setStatus(400).json({
+          error: 'Invalid redis configuration',
+          message: redisError,
+          code: 'INVALID_REDIS_CONFIG',
+        });
+      }
+
+      // Validate deadLetterQueue
+      const deadLetterQueueError = validateDeadLetterQueue(infrastructure.deadLetterQueue);
+      if (deadLetterQueueError) {
+        return res.setStatus(400).json({
+          error: 'Invalid deadLetterQueue configuration',
+          message: deadLetterQueueError,
+          code: 'INVALID_DEAD_LETTER_QUEUE_CONFIG',
+        });
+      }
+
+      // Validate compliance
+      const complianceError = validateCompliance(infrastructure.compliance);
+      if (complianceError) {
+        return res.setStatus(400).json({
+          error: 'Invalid compliance configuration',
+          message: complianceError,
+          code: 'INVALID_COMPLIANCE_CONFIG',
+        });
+      }
+
+      // Validate observability
+      const observabilityError = validateObservability(infrastructure.observability);
+      if (observabilityError) {
+        return res.setStatus(400).json({
+          error: 'Invalid observability configuration',
+          message: observabilityError,
+          code: 'INVALID_OBSERVABILITY_CONFIG',
+        });
+      }
+
+      // Validate autoScaler
+      const autoScalerError = validateAutoScaler(infrastructure.autoScaler);
+      if (autoScalerError) {
+        return res.setStatus(400).json({
+          error: 'Invalid autoScaler configuration',
+          message: autoScalerError,
+          code: 'INVALID_AUTO_SCALER_CONFIG',
+        });
+      }
+
+      // Sanitize infrastructure values
+      const currentBody = req.getBody() as Record<string, unknown>;
+      const sanitizedInfrastructure = sanitizeInfrastructure(infrastructure);
+
+      // Update the infrastructure in the request body
+      const updatedBody = {
+        ...currentBody,
+        infrastructure: sanitizedInfrastructure,
+      };
+      req.setBody(updatedBody);
+
+      return handler(req, res);
+    } catch (error) {
+      Logger.error('Infrastructure validation failed', error);
+      return res.setStatus(500).json({
+        error: 'Internal validation error',
+        code: 'VALIDATION_ERROR',
+      });
+    }
+  };
+};

package/src/http/middleware/OptionsValidator.ts

@@ -0,0 +1,144 @@
+import { Logger, type IRequest, type IResponse } from '@zintrust/core';
+
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+
+interface OptionsConfig {
+  concurrency: number;
+  limiter: {
+    max: number;
+    duration: number;
+  };
+}
+
+const validateConcurrency = (concurrency: unknown): string | null => {
+  if (concurrency === undefined || concurrency === null) {
+    return 'Concurrency is required';
+  }
+
+  if (typeof concurrency !== 'number') {
+    return 'Concurrency must be a number';
+  }
+
+  if (!Number.isInteger(concurrency)) {
+    return 'Concurrency must be a whole number (integer)';
+  }
+
+  if (concurrency < 1) {
+    return 'Concurrency must be at least 1';
+  }
+
+  const MAX_CONCURRENCY = 200;
+  if (concurrency > MAX_CONCURRENCY) {
+    return `Concurrency cannot exceed ${MAX_CONCURRENCY}`;
+  }
+
+  return null;
+};
+
+const validateLimiter = (limiter: OptionsConfig['limiter']): string | null => {
+  if (!limiter) {
+    return 'Limiter configuration is required';
+  }
+
+  // Validate max
+  if (limiter.max === undefined || limiter.max === null) {
+    return 'Limiter max is required';
+  }
+
+  if (typeof limiter.max !== 'number') {
+    return 'Limiter max must be a number';
+  }
+
+  if (!Number.isInteger(limiter.max)) {
+    return 'Limiter max must be a whole number (integer)';
+  }
+
+  if (limiter.max < 1) {
+    return 'Limiter max must be at least 1';
+  }
+  const MAX_LIMITER_MAX = 100000;
+  if (limiter.max > MAX_LIMITER_MAX) {
+    return `Limiter max cannot exceed ${MAX_LIMITER_MAX}`;
+  }
+
+  // Validate duration
+  if (limiter.duration === undefined || limiter.duration === null) {
+    return 'Limiter duration is required';
+  }
+
+  if (typeof limiter.duration !== 'number') {
+    return 'Limiter duration must be a number';
+  }
+
+  if (!Number.isInteger(limiter.duration)) {
+    return 'Limiter duration must be a whole number (integer)';
+  }
+
+  if (limiter.duration < 1000) {
+    return 'Limiter duration must be at least 1000ms';
+  }
+  const MAX_LIMITER_DURATION = 24 * 60 * 60 * 1000; // 1 day
+  if (limiter.duration > MAX_LIMITER_DURATION) {
+    return `Limiter duration cannot exceed ${MAX_LIMITER_DURATION} ms`;
+  }
+
+  return null;
+};
+
+export const withOptionsValidation = (handler: RouteHandler): RouteHandler => {
+  return async (req: IRequest, res: IResponse): Promise<void> => {
+    try {
+      const data = req.data();
+      const options = data['options'] as OptionsConfig;
+
+      if (!options) {
+        return res.setStatus(400).json({
+          error: 'Options configuration is required',
+          code: 'MISSING_OPTIONS',
+        });
+      }
+
+      // Validate concurrency
+      const concurrencyError = validateConcurrency(options.concurrency);
+      if (concurrencyError) {
+        return res.setStatus(400).json({
+          error: 'Invalid concurrency',
+          message: concurrencyError,
+          code: 'INVALID_CONCURRENCY',
+        });
+      }
+
+      // Validate limiter
+      const limiterError = validateLimiter(options.limiter);
+      if (limiterError) {
+        return res.setStatus(400).json({
+          error: 'Invalid limiter configuration',
+          message: limiterError,
+          code: 'INVALID_LIMITER_CONFIG',
+        });
+      }
+
+      // Sanitize concurrency to ensure it's an integer
+      const currentBody = req.getBody() as Record<string, unknown>;
+      const sanitizedOptions = {
+        ...options,
+        concurrency: Math.floor(options.concurrency),
+        limiter: {
+          ...options.limiter,
+          max: Math.floor(options.limiter.max),
+          duration: Math.floor(options.limiter.duration),
+        },
+      };
+
+      req.setBody({ ...currentBody, options: sanitizedOptions });
+
+      return handler(req, res);
+    } catch (error) {
+      Logger.error('Options validation failed', error);
+      return res.setStatus(500).json({
+        error: 'Internal validation error',
+        code: 'VALIDATION_ERROR',
+      });
+    }
+  };
+};

package/src/http/middleware/PayloadSanitizer.ts

@@ -0,0 +1,52 @@
+import { Logger, type IRequest, type IResponse } from '@zintrust/core';
+
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+
+/**
+ * Middleware to strip unknown properties from the request body.
+ * Only properties included in the allowedKeys list are preserved.
+ */
+export const withStrictPayloadKeys = (
+  allowedKeys: string[],
+  handler: RouteHandler
+): RouteHandler => {
+  const allowedSet = new Set(allowedKeys);
+
+  return async (req: IRequest, res: IResponse): Promise<void> => {
+    try {
+      const data = req.data();
+
+      if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        // If body is not an object, skip stripping or strictly enforce object?
+        // For worker creation, it must be an object.
+        // Let's rely on downstream validators to complain if data is missing/wrong type.
+        return handler(req, res);
+      }
+
+      const body = data as Record<string, unknown>;
+      const strippedBody: Record<string, unknown> = {};
+      let hasUnknowns = false;
+
+      for (const key of Object.keys(body)) {
+        if (allowedSet.has(key)) {
+          strippedBody[key] = body[key];
+        } else {
+          hasUnknowns = true;
+        }
+      }
+
+      if (hasUnknowns) {
+        // Update the body with sanitized version
+        req.setBody(strippedBody);
+      }
+
+      return handler(req, res);
+    } catch (error) {
+      Logger.error('Strict payload validation failed', error);
+      return res.setStatus(500).json({
+        error: 'Internal validation error',
+        code: 'VALIDATION_ERROR',
+      });
+    }
+  };
+};

package/src/http/middleware/ProcessorPathSanitizer.ts

@@ -0,0 +1,86 @@
+import { Logger, NodeSingletons, type IRequest, type IResponse } from '@zintrust/core';
+
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+
+const PROCESSOR_PATH_PATTERN = /^[a-zA-Z0-9/_.-]+\.(ts|js)$/;
+
+const decodeProcessorPath = (processor: string): string => {
+  return processor
+    .replaceAll('&#x2F;', '/') // HTML hex entity for /
+    .replaceAll('%2F', '/') // URL encoding for /
+    .replaceAll('&#x2E;', '.') // HTML hex entity for .
+    .replaceAll('%2E', '.') // URL encoding for .
+    .replaceAll('&#x5F;', '_') // HTML hex entity for _
+    .replaceAll('%5F', '_') // URL encoding for _
+    .replaceAll('&#x2D;', '-') // HTML hex entity for -
+    .replaceAll('%2D', '-'); // URL encoding for -
+};
+
+export const withProcessorPathValidation = (handler: RouteHandler): RouteHandler => {
+  return async (req: IRequest, res: IResponse): Promise<void> => {
+    try {
+      const data = req.data();
+      let processor = data['processor'] as string;
+
+      if (!processor) {
+        return res.setStatus(400).json({
+          error: 'Processor path is required',
+          code: 'MISSING_PROCESSOR_PATH',
+        });
+      }
+
+      // Decode URL-encoded characters
+      processor = decodeProcessorPath(processor);
+
+      // Trim whitespace
+      processor = processor.trim();
+
+      // Prevent path traversal
+      if (processor.includes('..') || processor.startsWith('/')) {
+        return res.setStatus(400).json({
+          error: 'Invalid processor path',
+          message: 'Processor path must be relative and cannot contain path traversal',
+          code: 'INVALID_PROCESSOR_PATH',
+        });
+      }
+
+      if (!PROCESSOR_PATH_PATTERN.test(processor)) {
+        Logger.error('Processor path validation failed', {
+          processor,
+          pattern: PROCESSOR_PATH_PATTERN.toString(),
+          testResult: PROCESSOR_PATH_PATTERN.test(processor),
+        });
+        return res.setStatus(400).json({
+          error: 'Invalid processor path',
+          message: `Processor must be a TypeScript or JavaScript file. Got: "${processor}"`,
+          code: 'INVALID_PROCESSOR_EXTENSION',
+        });
+      }
+
+      // Sanitize the processor path (remove any invalid characters just in case)
+      const sanitizedProcessor = processor.replaceAll(/[^a-zA-Z0-9/_.-]/g, '');
+      const path = NodeSingletons.path;
+      // Ensure resolved path stays within repository/app scope
+      const BASE_PROCESSOR_DIR = path.resolve(process.cwd());
+      const resolved = path.resolve(BASE_PROCESSOR_DIR, sanitizedProcessor);
+      if (!resolved.startsWith(BASE_PROCESSOR_DIR)) {
+        return res.setStatus(400).json({
+          error: 'Invalid processor path',
+          message: 'Processor path resolves outside of allowed base directory',
+          code: 'INVALID_PROCESSOR_PATH_TRAVERSAL',
+        });
+      }
+
+      const currentBody = req.getBody() as Record<string, unknown>;
+      req.setBody({ ...currentBody, processor: sanitizedProcessor });
+
+      return handler(req, res);
+    } catch (error) {
+      Logger.error('Processor path validation failed', error);
+      return res.setStatus(500).json({
+        error: 'Internal validation error',
+        code: 'VALIDATION_ERROR',
+      });
+    }
+  };
+};

package/src/http/middleware/QueueNameSanitizer.ts

@@ -0,0 +1,55 @@
+import { Logger, type IRequest, type IResponse } from '@zintrust/core';
+
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+
+const QUEUE_NAME_PATTERN = /^[a-zA-Z0-9_-]{3,50}$/;
+
+export const withQueueNameValidation = (handler: RouteHandler): RouteHandler => {
+  return async (req: IRequest, res: IResponse): Promise<void> => {
+    try {
+      const data = req.data();
+      const queueName = data['queueName'] as string;
+
+      if (!queueName) {
+        return res.setStatus(400).json({
+          error: 'Queue name is required',
+          code: 'MISSING_QUEUE_NAME',
+        });
+      }
+
+      if (!QUEUE_NAME_PATTERN.test(queueName)) {
+        return res.setStatus(400).json({
+          error: 'Invalid queue name',
+          message:
+            'Queue name must be 3-50 characters long and contain only letters, numbers, hyphens, and underscores',
+          code: 'INVALID_QUEUE_NAME',
+        });
+      }
+
+      // Sanitize the queue name
+      const sanitizedQueueName = queueName
+        .trim()
+        .replaceAll(/[^a-zA-Z0-9_-]/g, '')
+        .substring(0, 50);
+
+      if (sanitizedQueueName.length < 3) {
+        return res.setStatus(400).json({
+          error: 'Queue name too short after sanitization',
+          message: 'Queue name must be at least 3 characters long',
+          code: 'QUEUE_NAME_TOO_SHORT',
+        });
+      }
+
+      const currentBody = req.getBody() as Record<string, unknown>;
+      req.setBody({ ...currentBody, queueName: sanitizedQueueName });
+
+      return handler(req, res);
+    } catch (error) {
+      Logger.error('Queue name validation failed', error);
+      return res.setStatus(500).json({
+        error: 'Internal validation error',
+        code: 'VALIDATION_ERROR',
+      });
+    }
+  };
+};

package/src/http/middleware/ValidateDriver.ts

@@ -0,0 +1,29 @@
+/**
+ * Validate Driver Middleware
+ * Ensures the 'driver' query parameter is valid if present.
+ */
+
+import type { IRequest, IResponse } from '@zintrust/core';
+
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+
+const VALID_DRIVERS = new Set(['database', 'redis', 'memory']);
+
+export const withDriverValidation = (handler: RouteHandler): RouteHandler => {
+  return async (req: IRequest, res: IResponse): Promise<void> => {
+    const driver = req.getQueryParam('driver');
+
+    // Normalize to string if it's an array (take first)
+    const driverValue = Array.isArray(driver) ? driver[0] : driver;
+
+    if (driverValue && !VALID_DRIVERS.has(driverValue)) {
+      res.setStatus(400).json({
+        error: 'Invalid driver parameter',
+        message: 'Driver must be one of: database, redis, memory',
+      });
+      return;
+    }
+
+    return handler(req, res);
+  };
+};

package/src/http/middleware/VersionSanitizer.ts

@@ -0,0 +1,30 @@
+import { Logger, type IRequest, type IResponse } from '@zintrust/core';
+
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+
+const VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
+
+export const withVersionValidation = (handler: RouteHandler): RouteHandler => {
+  return async (req: IRequest, res: IResponse): Promise<void> => {
+    try {
+      const data = req.data();
+      const version = data['version'] as string;
+
+      if (version && !VERSION_PATTERN.test(version)) {
+        return res.setStatus(400).json({
+          error: 'Invalid version format',
+          message: 'Version must follow semantic versioning (e.g., 1.0.0)',
+          code: 'INVALID_VERSION_FORMAT',
+        });
+      }
+
+      return handler(req, res);
+    } catch (error) {
+      Logger.error('Version validation failed', error);
+      return res.setStatus(500).json({
+        error: 'Internal validation error',
+        code: 'VALIDATION_ERROR',
+      });
+    }
+  };
+};