@zintrust/workers 0.1.27

package/dist/http/middleware/WorkerValidationChain.js

@@ -0,0 +1,185 @@
+import { Logger } from '@zintrust/core';
+// 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) => {
+    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) => {
+    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) => {
+    return withWorkerNameValidation(handler);
+};
+/**
+ * Composite middleware for bulk operations validation
+ * Validates arrays of worker names and operation parameters
+ */
+export const withBulkOperationValidation = (handler) => {
+    return async (req, res) => {
+        try {
+            const data = req.data();
+            const workerNames = data['workerNames'];
+            // 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();
+            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) => {
+    return async (req, res) => {
+        try {
+            const data = req.data();
+            const newVersion = data['newVersion'];
+            const initialTrafficPercent = data['initialTrafficPercent'];
+            const targetTrafficPercent = data['targetTrafficPercent'];
+            // 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/dist/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Worker Management System - Public API
+ *
+ * Central export file for all worker management modules.
+ */
+export { ClusterLock } from './ClusterLock';
+export { PriorityQueue } from './PriorityQueue';
+export { WorkerMetrics } from './WorkerMetrics';
+export { WorkerRegistry } from './WorkerRegistry';
+export { AutoScaler } from './AutoScaler';
+export { CircuitBreaker } from './CircuitBreaker';
+export { DeadLetterQueue } from './DeadLetterQueue';
+export { HealthMonitor } from './HealthMonitor';
+export { ResourceMonitor } from './ResourceMonitor';
+export { SLAMonitor } from './SLAMonitor';
+export { ComplianceManager } from './ComplianceManager';
+export { Observability } from './Observability';
+export { PluginManager } from './PluginManager';
+export { AnomalyDetection } from './AnomalyDetection';
+export { CanaryController } from './CanaryController';
+export { ChaosEngineering } from './ChaosEngineering';
+export { DatacenterOrchestrator } from './DatacenterOrchestrator';
+export { MultiQueueWorker } from './MultiQueueWorker';
+export { WorkerVersioning } from './WorkerVersioning';
+export { WorkerFactory } from './WorkerFactory';
+export type { WorkerPersistenceConfig } from './WorkerFactory';
+export { WorkerInit } from './WorkerInit';
+export { WorkerShutdown } from './WorkerShutdown';
+export { WorkerController } from './http/WorkerController';
+export { registerWorkerRoutes } from './routes/workers';
+export { BroadcastWorker } from './BroadcastWorker';
+export { createQueueWorker } from './createQueueWorker';
+export type { CreateQueueWorkerOptions } from './createQueueWorker';
+export { NotificationWorker } from './NotificationWorker';
+export type { RedisConfig, WorkerAutoScalingConfig, WorkerComplianceConfig, WorkerConfig, WorkerCostConfig, WorkerObservabilityConfig, WorkersConfigOverrides, WorkersGlobalConfig, WorkerStatus, WorkerVersioningConfig, } from '@zintrust/core';
+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 declare const _ZINTRUST_WORKERS_VERSION = "0.1.0";
+export declare const _ZINTRUST_WORKERS_BUILD_DATE = "__BUILD_DATE__";

package/dist/index.js

@@ -0,0 +1,48 @@
+/**
+ * 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 { 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 { NotificationWorker } from './NotificationWorker';
+/**
+ * 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/dist/routes/workers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Worker Management Routes
+ * HTTP API for managing workers with dashboard functionality
+ */
+import type { IRouter } from '@zintrust/core';
+import { type WorkersDashboardUiOptions } from '../dashboard';
+type WorkerUiOptions = WorkersDashboardUiOptions;
+type RouteOptions = {
+    middleware?: ReadonlyArray<string>;
+} | undefined;
+export declare function registerWorkerRoutes(router: IRouter, _options?: WorkerUiOptions, routeOptions?: RouteOptions): void;
+export default registerWorkerRoutes;

package/dist/routes/workers.js

@@ -0,0 +1,81 @@
+/**
+ * Worker Management Routes
+ * HTTP API for managing workers with dashboard functionality
+ */
+import { Logger, Router } from '@zintrust/core';
+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';
+const controller = WorkerController.create();
+const apiController = WorkerApiController.create();
+function registerCoreWorkerRoutes(r) {
+    // 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) {
+    // 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) {
+    // 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) {
+    // 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) {
+    // Utility endpoints
+    Router.get(r, '/drivers', apiController.getDriversHandler);
+    Router.get(r, '/queue-data', apiController.getQueueDataHandler);
+    Router.get(r, '/health', apiController.getHealthSummaryHandler);
+}
+function registerWorkerLifecycleRoutes(router, middleware) {
+    Router.group(router, '/api/workers', (r) => {
+        Logger.info('Registering Worker Management Routes');
+        registerCoreWorkerRoutes(r);
+        registerWorkerQueryRoutes(r);
+        registerMonitoringRoutes(r);
+        registerVersioningRoutes(r);
+        registerUtilityRoutes(r);
+    }, { middleware: middleware });
+}
+export function registerWorkerRoutes(router, _options, routeOptions) {
+    registerStaticAssets(router, routeOptions?.middleware ?? []);
+    registerWorkerLifecycleRoutes(router, routeOptions?.middleware);
+    Logger.info('Worker routes registered at http://127.0.0.1:7777/workers');
+}
+export default registerWorkerRoutes;

package/dist/storage/WorkerStore.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Worker Store
+ * Persistence layer for workers (memory, redis, db)
+ */
+import type { IDatabase } from '@zintrust/core';
+import type { Redis } from 'ioredis';
+export type WorkerRecord = {
+    name: string;
+    queueName: string;
+    version: string | null;
+    status: string;
+    autoStart: boolean;
+    concurrency: number;
+    region: string | null;
+    processorPath?: string | null;
+    features?: Record<string, unknown> | null;
+    infrastructure?: Record<string, unknown> | null;
+    datacenter?: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+    lastHealthCheck?: Date;
+    lastError?: string;
+    connectionState?: 'disconnected' | 'connecting' | 'connected' | 'error';
+};
+export type WorkerStore = {
+    init(): Promise<void>;
+    list(options?: {
+        offset?: number;
+        limit?: number;
+        search?: string;
+    }): Promise<WorkerRecord[]>;
+    get(name: string): Promise<WorkerRecord | null>;
+    save(record: WorkerRecord): Promise<void>;
+    update(name: string, patch: Partial<WorkerRecord>): Promise<void>;
+    remove(name: string): Promise<void>;
+};
+export declare const InMemoryWorkerStore: Readonly<{
+    create(): WorkerStore;
+}>;
+export declare const RedisWorkerStore: Readonly<{
+    create(client: Redis, keyPrefix?: string): WorkerStore;
+}>;
+export declare const DbWorkerStore: Readonly<{
+    create(db: IDatabase, table?: string): WorkerStore;
+}>;

package/dist/storage/WorkerStore.js

@@ -0,0 +1,195 @@
+/**
+ * Worker Store
+ * Persistence layer for workers (memory, redis, db)
+ */
+const now = () => new Date();
+const mergeRecord = (current, patch) => ({
+    ...current,
+    ...patch,
+    updatedAt: patch.updatedAt ?? now(),
+});
+const serializeDbWorker = (record) => ({
+    name: record.name,
+    queue_name: record.queueName,
+    version: record.version,
+    status: record.status,
+    auto_start: record.autoStart,
+    concurrency: record.concurrency,
+    region: record.region,
+    processor_path: record.processorPath ?? null,
+    features: record.features ? JSON.stringify(record.features) : null,
+    infrastructure: record.infrastructure ? JSON.stringify(record.infrastructure) : null,
+    datacenter: record.datacenter ? JSON.stringify(record.datacenter) : null,
+    created_at: record.createdAt,
+    updated_at: record.updatedAt,
+    last_health_check: record.lastHealthCheck ?? null,
+    last_error: record.lastError ?? null,
+    connection_state: record.connectionState ?? null,
+});
+const getHealthCheck = (row) => {
+    if (!row['last_health_check']) {
+        return undefined;
+    }
+    return row['last_health_check'] instanceof Date
+        ? row['last_health_check']
+        : new Date(String(row['last_health_check']));
+};
+const deserializeDbWorker = (row) => {
+    const parseJson = (value) => {
+        if (typeof value !== 'string' || value.trim() === '')
+            return null;
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    };
+    return {
+        name: String(row['name'] ?? ''),
+        queueName: String(row['queue_name'] ?? ''),
+        version: row['version'] ? String(row['version']) : null,
+        status: String(row['status'] ?? 'unknown'),
+        autoStart: Boolean(row['auto_start'] ?? false),
+        concurrency: Number(row['concurrency'] ?? 0),
+        region: row['region'] ? String(row['region']) : null,
+        processorPath: row['processor_path'] ? String(row['processor_path']) : null,
+        features: parseJson(row['features']),
+        infrastructure: parseJson(row['infrastructure']),
+        datacenter: parseJson(row['datacenter']),
+        createdAt: row['created_at'] instanceof Date ? row['created_at'] : new Date(String(row['created_at'])),
+        updatedAt: row['updated_at'] instanceof Date ? row['updated_at'] : new Date(String(row['updated_at'])),
+        lastHealthCheck: getHealthCheck(row),
+        lastError: row['last_error'] ? String(row['last_error']) : undefined,
+        connectionState: row['connection_state']
+            ? String(row['connection_state'])
+            : undefined,
+    };
+};
+export const InMemoryWorkerStore = Object.freeze({
+    create() {
+        const store = new Map();
+        return {
+            async init() {
+                return undefined;
+            },
+            async list(options) {
+                let values = Array.from(store.values());
+                if (options) {
+                    const start = options.offset || 0;
+                    const end = options.limit ? start + options.limit : undefined;
+                    values = values.slice(start, end);
+                }
+                return values;
+            },
+            async get(name) {
+                return store.get(name) ?? null;
+            },
+            async save(record) {
+                store.set(record.name, record);
+            },
+            async update(name, patch) {
+                const current = store.get(name);
+                if (!current)
+                    return;
+                store.set(name, mergeRecord(current, patch));
+            },
+            async remove(name) {
+                store.delete(name);
+            },
+        };
+    },
+});
+export const RedisWorkerStore = Object.freeze({
+    create(client, keyPrefix = 'workers:registry') {
+        const key = keyPrefix;
+        const serialize = (record) => JSON.stringify({
+            ...record,
+            createdAt: record.createdAt.toISOString(),
+            updatedAt: record.updatedAt.toISOString(),
+        });
+        const deserialize = (raw) => {
+            const parsed = JSON.parse(raw);
+            return {
+                ...parsed,
+                createdAt: new Date(parsed.createdAt),
+                updatedAt: new Date(parsed.updatedAt),
+            };
+        };
+        return {
+            async init() {
+                return undefined;
+            },
+            async list(options) {
+                const all = await client.hgetall(key);
+                let values = Object.values(all).map(deserialize);
+                values.sort((a, b) => a.name.localeCompare(b.name));
+                if (options) {
+                    const start = options.offset || 0;
+                    const end = options.limit ? start + options.limit : undefined;
+                    values = values.slice(start, end);
+                }
+                return values;
+            },
+            async get(name) {
+                const raw = await client.hget(key, name);
+                return raw ? deserialize(raw) : null;
+            },
+            async save(record) {
+                await client.hset(key, record.name, serialize(record));
+            },
+            async update(name, patch) {
+                const current = await this.get(name);
+                if (!current)
+                    return;
+                await client.hset(key, name, serialize(mergeRecord(current, patch)));
+            },
+            async remove(name) {
+                await client.hdel(key, name);
+            },
+        };
+    },
+});
+export const DbWorkerStore = Object.freeze({
+    create(db, table = 'zintrust_workers') {
+        return {
+            async init() {
+                return undefined;
+            },
+            async list(options) {
+                const query = db.table(table);
+                if (options?.limit)
+                    query.limit(options.limit);
+                if (options?.offset)
+                    query.offset(options.offset);
+                const rows = await query.get();
+                return rows.map(deserializeDbWorker);
+            },
+            async get(name) {
+                const row = await db.table(table).where('name', '=', name).first();
+                return row ? deserializeDbWorker(row) : null;
+            },
+            async save(record) {
+                const existing = await db
+                    .table(table)
+                    .where('name', '=', record.name)
+                    .first();
+                if (existing) {
+                    await db.table(table).where('name', '=', record.name).update(serializeDbWorker(record));
+                    return;
+                }
+                await db.table(table).insert(serializeDbWorker(record));
+            },
+            async update(name, patch) {
+                const current = await this.get(name);
+                if (!current)
+                    return;
+                const updated = mergeRecord(current, patch);
+                await db.table(table).where('name', '=', name).update(serializeDbWorker(updated));
+            },
+            async remove(name) {
+                await db.table(table).where('name', '=', name).delete();
+            },
+        };
+    },
+});