@zintrust/workers 0.1.27

package/src/http/middleware/WorkerNameSanitizer.ts

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

package/src/http/middleware/WorkerValidationChain.ts

@@ -0,0 +1,230 @@
+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 { withOptionsValidation } from './OptionsValidator';
+import { withStrictPayloadKeys } from './PayloadSanitizer';
+import { withProcessorPathValidation } from './ProcessorPathSanitizer';
+import { withQueueNameValidation } from './QueueNameSanitizer';
+import { withVersionValidation } from './VersionSanitizer';
+import { withWorkerNameValidation } from './WorkerNameSanitizer';
+
+/**
+ * Composite middleware for worker creation validation
+ * Validates all required fields for creating a new worker
+ */
+export const withCreateWorkerValidation = (handler: RouteHandler): RouteHandler => {
+  return withStrictPayloadKeys(
+    [
+      'name',
+      'queueName',
+      'processor',
+      'version',
+      'options',
+      'infrastructure',
+      'features',
+      'datacenter',
+    ],
+    withProcessorPathValidation(
+      withWorkerNameValidation(
+        withQueueNameValidation(
+          withVersionValidation(
+            withOptionsValidation(
+              withInfrastructureValidation(
+                withFeaturesValidation(withDatacenterValidation(handler))
+              )
+            )
+          )
+        )
+      )
+    )
+  );
+};
+
+/**
+ * Composite middleware for worker update validation
+ * Validates optional fields for updating an existing worker
+ */
+export const withUpdateWorkerValidation = (handler: RouteHandler): RouteHandler => {
+  return withVersionValidation(
+    withInfrastructureValidation(withFeaturesValidation(withDatacenterValidation(handler)))
+  );
+};
+
+/**
+ * Composite middleware for worker operation validation
+ * Validates worker name for operations like start, stop, restart, etc.
+ */
+export const withWorkerOperationValidation = (handler: RouteHandler): RouteHandler => {
+  return withWorkerNameValidation(handler);
+};
+
+/**
+ * Composite middleware for bulk operations validation
+ * Validates arrays of worker names and operation parameters
+ */
+export const withBulkOperationValidation = (handler: RouteHandler): RouteHandler => {
+  return async (req: IRequest, res: IResponse): Promise<void> => {
+    try {
+      const data = req.data();
+      const workerNames = data['workerNames'] as string[] | string;
+
+      // Handle single worker name or array of names
+      const names = Array.isArray(workerNames) ? workerNames : [workerNames];
+
+      // Prevent enormous bulk operations
+      const MAX_BULK_NAMES = 1000;
+      if (names.length > MAX_BULK_NAMES) {
+        return res.setStatus(413).json({
+          error: 'Too many worker names',
+          message: `Bulk operation exceeds maximum allowed names (${MAX_BULK_NAMES})`,
+          code: 'BULK_OPERATION_TOO_LARGE',
+        });
+      }
+
+      if (!names || names.length === 0) {
+        return res.setStatus(400).json({
+          error: 'Worker names are required',
+          message: 'At least one worker name must be provided',
+          code: 'MISSING_WORKER_NAMES',
+        });
+      }
+
+      // Validate each worker name
+      const WORKER_NAME_PATTERN = /^[a-zA-Z0-9_-]{3,50}$/;
+      for (const name of names) {
+        if (!name || typeof name !== 'string') {
+          return res.setStatus(400).json({
+            error: 'Invalid worker name',
+            message: 'Worker name must be a string',
+            code: 'INVALID_WORKER_NAME_TYPE',
+          });
+        }
+
+        if (!WORKER_NAME_PATTERN.test(name)) {
+          return res.setStatus(400).json({
+            error: 'Invalid worker name',
+            message: `Worker name "${name}" must be 3-50 characters long and contain only letters, numbers, hyphens, and underscores`,
+            code: 'INVALID_WORKER_NAME',
+          });
+        }
+      }
+
+      // Sanitize worker names
+      const sanitizedNames = names
+        .map((name) =>
+          name
+            .trim()
+            .replaceAll(/[^a-zA-Z0-9_-]/g, '')
+            .substring(0, 50)
+        )
+        .filter((name) => name.length >= 3);
+
+      if (sanitizedNames.length === 0) {
+        return res.setStatus(400).json({
+          error: 'No valid worker names after sanitization',
+          message: 'All worker names were invalid after sanitization',
+          code: 'NO_VALID_WORKER_NAMES',
+        });
+      }
+
+      // Update request data with sanitized names
+      const currentBody = req.getBody() as Record<string, unknown>;
+      req.setBody({ ...currentBody, workerNames: sanitizedNames });
+
+      return handler(req, res);
+    } catch (error) {
+      Logger.error('Bulk operation validation failed', error);
+      return res.setStatus(500).json({
+        error: 'Internal validation error',
+        code: 'VALIDATION_ERROR',
+      });
+    }
+  };
+};
+
+/**
+ * Composite middleware for canary deployment validation
+ * Validates canary-specific parameters
+ */
+export const withCanaryDeploymentValidation = (handler: RouteHandler): RouteHandler => {
+  return async (req: IRequest, res: IResponse): Promise<void> => {
+    try {
+      const data = req.data();
+      const newVersion = data['newVersion'] as string;
+      const initialTrafficPercent = data['initialTrafficPercent'] as number;
+      const targetTrafficPercent = data['targetTrafficPercent'] as number;
+
+      // Validate new version
+      if (!newVersion) {
+        return res.setStatus(400).json({
+          error: 'New version is required',
+          code: 'MISSING_NEW_VERSION',
+        });
+      }
+
+      const VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
+      if (!VERSION_PATTERN.test(newVersion)) {
+        return res.setStatus(400).json({
+          error: 'Invalid version format',
+          message: 'Version must follow semantic versioning (e.g., 1.0.0)',
+          code: 'INVALID_VERSION_FORMAT',
+        });
+      }
+
+      // Validate initial traffic percent
+      if (initialTrafficPercent !== undefined) {
+        if (
+          typeof initialTrafficPercent !== 'number' ||
+          initialTrafficPercent < 0 ||
+          initialTrafficPercent > 100
+        ) {
+          return res.setStatus(400).json({
+            error: 'Invalid initial traffic percent',
+            message: 'Initial traffic percent must be a number between 0 and 100',
+            code: 'INVALID_INITIAL_TRAFFIC_PERCENT',
+          });
+        }
+      }
+
+      // Validate target traffic percent
+      if (targetTrafficPercent !== undefined) {
+        if (
+          typeof targetTrafficPercent !== 'number' ||
+          targetTrafficPercent < 0 ||
+          targetTrafficPercent > 100
+        ) {
+          return res.setStatus(400).json({
+            error: 'Invalid target traffic percent',
+            message: 'Target traffic percent must be a number between 0 and 100',
+            code: 'INVALID_TARGET_TRAFFIC_PERCENT',
+          });
+        }
+      }
+
+      // Validate traffic progression
+      if (initialTrafficPercent !== undefined && targetTrafficPercent !== undefined) {
+        if (targetTrafficPercent < initialTrafficPercent) {
+          return res.setStatus(400).json({
+            error: 'Invalid traffic progression',
+            message:
+              'Target traffic percent must be greater than or equal to initial traffic percent',
+            code: 'INVALID_TRAFFIC_PROGRESSION',
+          });
+        }
+      }
+
+      return handler(req, res);
+    } catch (error) {
+      Logger.error('Canary deployment validation failed', error);
+      return res.setStatus(500).json({
+        error: 'Internal validation error',
+        code: 'VALIDATION_ERROR',
+      });
+    }
+  };
+};

package/src/index.ts

@@ -0,0 +1,98 @@
+/**
+ * Worker Management System - Public API
+ *
+ * Central export file for all worker management modules.
+ */
+
+// Core Infrastructure
+export { ClusterLock } from './ClusterLock';
+export { PriorityQueue } from './PriorityQueue';
+export { WorkerMetrics } from './WorkerMetrics';
+export { WorkerRegistry } from './WorkerRegistry';
+
+// Resilience & Recovery
+export { AutoScaler } from './AutoScaler';
+export { CircuitBreaker } from './CircuitBreaker';
+export { DeadLetterQueue } from './DeadLetterQueue';
+
+// Monitoring & Resources
+export { HealthMonitor } from './HealthMonitor';
+export { ResourceMonitor } from './ResourceMonitor';
+export { SLAMonitor } from './SLAMonitor';
+
+// Compliance & Security
+export { ComplianceManager } from './ComplianceManager';
+
+// Observability
+export { Observability } from './Observability';
+
+// Plugin System
+export { PluginManager } from './PluginManager';
+
+// Advanced Features
+export { AnomalyDetection } from './AnomalyDetection';
+export { CanaryController } from './CanaryController';
+export { ChaosEngineering } from './ChaosEngineering';
+export { DatacenterOrchestrator } from './DatacenterOrchestrator';
+export { MultiQueueWorker } from './MultiQueueWorker';
+export { WorkerVersioning } from './WorkerVersioning';
+
+// Factory & Lifecycle
+export { WorkerFactory } from './WorkerFactory';
+export type { WorkerPersistenceConfig } from './WorkerFactory';
+export { WorkerInit } from './WorkerInit';
+export { WorkerShutdown } from './WorkerShutdown';
+
+// HTTP Controllers & Routes
+export { WorkerController } from './http/WorkerController';
+export { registerWorkerRoutes } from './routes/workers';
+
+// Queue Workers
+export { BroadcastWorker } from './BroadcastWorker';
+export { createQueueWorker } from './createQueueWorker';
+export type { CreateQueueWorkerOptions } from './createQueueWorker';
+
+export { NotificationWorker } from './NotificationWorker';
+
+// Re-export types from core config
+export type {
+  RedisConfig,
+  WorkerAutoScalingConfig,
+  WorkerComplianceConfig,
+  WorkerConfig,
+  WorkerCostConfig,
+  WorkerObservabilityConfig,
+  WorkersConfigOverrides,
+  WorkersGlobalConfig,
+  WorkerStatus,
+  WorkerVersioningConfig,
+} from '@zintrust/core';
+
+// Re-export bullmq types for type compatibility
+export type { Job, Worker, WorkerOptions } from 'bullmq';
+
+export type {
+  IAnomaly,
+  IAnomalyConfig,
+  IForecast,
+  IMetric,
+  IPrediction,
+  IRecommendation,
+  IRootCauseAnalysis,
+} from './AnomalyDetection';
+export type {
+  IChaosComparison,
+  IChaosExperiment,
+  IChaosReport,
+  IChaosStatus,
+} from './ChaosEngineering';
+export type { ISLAConfig, ISLAReport, ISLAStatus, ISLAViolation, ITimeRange } from './SLAMonitor';
+
+export type * from './type';
+
+/**
+ * Package version and build metadata
+ * Available at runtime for debugging and health checks
+ */
+export const _ZINTRUST_WORKERS_VERSION = '0.1.0';
+export const _ZINTRUST_WORKERS_BUILD_DATE = '__BUILD_DATE__';

package/src/routes/workers.ts

@@ -0,0 +1,154 @@
+/**
+ * Worker Management Routes
+ * HTTP API for managing workers with dashboard functionality
+ */
+
+import type { IRouter } from '@zintrust/core';
+import { Logger, Router } from '@zintrust/core';
+import { type WorkersDashboardUiOptions } from '../dashboard';
+import { WorkerApiController } from '../http/WorkerApiController';
+import { WorkerController } from '../http/WorkerController';
+import { ValidationSchemas, withCustomValidation } from '../http/middleware/CustomValidation';
+import { withEditWorkerValidation } from '../http/middleware/EditWorkerValidation';
+import { withDriverValidation } from '../http/middleware/ValidateDriver';
+import {
+  withCreateWorkerValidation,
+  withWorkerOperationValidation,
+} from '../http/middleware/WorkerValidationChain';
+import { registerStaticAssets } from '../ui/router/ui';
+
+type WorkerUiOptions = WorkersDashboardUiOptions;
+type RouteOptions = { middleware?: ReadonlyArray<string> } | undefined;
+
+const controller = WorkerController.create();
+const apiController = WorkerApiController.create();
+
+function registerCoreWorkerRoutes(r: IRouter): void {
+  // Core worker operations
+  Router.post(r, '/create', withCreateWorkerValidation(controller.create));
+  Router.put(r, '/:name', withCreateWorkerValidation(controller.update));
+
+  // Worker editing with custom validation that handles processorPath mapping
+  Router.put(r, '/:name/edit', withEditWorkerValidation(controller.update));
+  Router.post(
+    r,
+    '/:name/start',
+    withDriverValidation(withWorkerOperationValidation(controller.start))
+  );
+  Router.post(
+    r,
+    '/:name/auto-start',
+    withDriverValidation(withWorkerOperationValidation(controller.setAutoStart))
+  );
+  Router.post(
+    r,
+    '/:name/stop',
+    withDriverValidation(withWorkerOperationValidation(controller.stop))
+  );
+  Router.post(
+    r,
+    '/:name/restart',
+    withDriverValidation(withWorkerOperationValidation(controller.restart))
+  );
+  Router.post(
+    r,
+    '/:name/pause',
+    withDriverValidation(withWorkerOperationValidation(controller.pause))
+  );
+  Router.post(
+    r,
+    '/:name/resume',
+    withDriverValidation(withWorkerOperationValidation(controller.resume))
+  );
+  Router.del(r, '/:name', withDriverValidation(withWorkerOperationValidation(controller.remove)));
+}
+
+function registerWorkerQueryRoutes(r: IRouter): void {
+  // Worker listing and filtering
+  Router.get(
+    r,
+    '/',
+    withDriverValidation(
+      withCustomValidation(ValidationSchemas.workerFilter, apiController.listWorkers)
+    )
+  );
+
+  Router.get(r, '/:name', withDriverValidation(withWorkerOperationValidation(controller.get)));
+
+  Router.get(r, '/:name/status', withWorkerOperationValidation(controller.status));
+  Router.get(
+    r,
+    '/:name/creation-status',
+    withWorkerOperationValidation(controller.getCreationStatus)
+  );
+  Router.get(r, '/:name/metrics', withWorkerOperationValidation(controller.metrics));
+  Router.get(r, '/:name/health', withWorkerOperationValidation(controller.health));
+
+  // Worker details
+  Router.get(r, '/:name/details', withDriverValidation(apiController.getWorkerDetailsHandler));
+
+  // Worker driver data for editing
+  Router.get(
+    r,
+    '/:name/driver-data',
+    withDriverValidation(apiController.getWorkerDriverDataHandler)
+  );
+}
+
+function registerMonitoringRoutes(r: IRouter): void {
+  // Health monitoring
+  Router.post(r, '/:name/monitoring/start', controller.startMonitoring);
+  Router.post(r, '/:name/monitoring/stop', controller.stopMonitoring);
+  Router.get(r, '/:name/monitoring/history', controller.healthHistory);
+  Router.get(r, '/:name/monitoring/trend', controller.healthTrend);
+  Router.put(r, '/:name/monitoring/config', controller.updateMonitoringConfig);
+
+  // SLA monitoring
+  Router.get(r, '/:name/sla/status', controller.getSlaStatus);
+
+  // SSE events stream for monitoring + workers snapshot
+  Router.get(r, '/events', controller.eventsStream);
+}
+
+function registerVersioningRoutes(r: IRouter): void {
+  // Versioning
+  Router.post(r, '/:name/versions', controller.registerVersion);
+  Router.get(r, '/:name/versions', controller.listVersions);
+  Router.get(r, '/:name/versions/:version', controller.getVersion);
+}
+
+function registerUtilityRoutes(r: IRouter): void {
+  // Utility endpoints
+  Router.get(r, '/drivers', apiController.getDriversHandler);
+  Router.get(r, '/queue-data', apiController.getQueueDataHandler);
+  Router.get(r, '/health', apiController.getHealthSummaryHandler);
+}
+
+function registerWorkerLifecycleRoutes(router: IRouter, middleware?: ReadonlyArray<string>): void {
+  Router.group(
+    router,
+    '/api/workers',
+    (r: IRouter) => {
+      Logger.info('Registering Worker Management Routes');
+
+      registerCoreWorkerRoutes(r);
+      registerWorkerQueryRoutes(r);
+      registerMonitoringRoutes(r);
+      registerVersioningRoutes(r);
+      registerUtilityRoutes(r);
+    },
+    { middleware: middleware }
+  );
+}
+
+export function registerWorkerRoutes(
+  router: IRouter,
+  _options?: WorkerUiOptions,
+  routeOptions?: RouteOptions
+): void {
+  registerStaticAssets(router, routeOptions?.middleware ?? []);
+  registerWorkerLifecycleRoutes(router, routeOptions?.middleware);
+  Logger.info('Worker routes registered at http://127.0.0.1:7777/workers');
+}
+
+export default registerWorkerRoutes;