@zintrust/core 0.1.41 → 0.1.43

package/packages/workers/src/WorkerShutdown.js

@@ -0,0 +1,185 @@
+/**
+ * Worker Shutdown Coordinator
+ *
+ * Centralized graceful shutdown handling for the worker management system.
+ * Coordinates orderly shutdown of all worker modules and the WorkerFactory.
+ */
+import { Logger } from '../../../src/index.js';
+import { WorkerFactory } from './WorkerFactory.js';
+// ============================================================================
+// Implementation
+// ============================================================================
+const state = {
+    isShuttingDown: false,
+    completedAt: null,
+    startedAt: null,
+    reason: null,
+};
+let shutdownHandlersRegistered = false;
+const signalHandlers = {};
+/**
+ * Perform graceful shutdown of all worker modules
+ */
+async function shutdown(options = {}) {
+    const { timeout = 30000, forceExit = true, signal = 'unknown' } = options;
+    // Prevent concurrent shutdowns
+    if (state.isShuttingDown) {
+        Logger.warn('Shutdown already in progress, ignoring duplicate request');
+        return;
+    }
+    state.isShuttingDown = true;
+    state.startedAt = new Date();
+    state.reason = `Signal: ${signal}`;
+    Logger.info('🛑 Initiating graceful shutdown of worker management system', {
+        signal,
+        timeout,
+        forceExit,
+    });
+    // Setup timeout for forced shutdown
+    let timeoutHandle = null;
+    if (forceExit && timeout > 0) {
+        // eslint-disable-next-line no-restricted-syntax
+        timeoutHandle = setTimeout(() => {
+            Logger.error('❌ Graceful shutdown timeout exceeded, forcing exit', { timeout });
+            process.exit(1);
+        }, timeout);
+    }
+    try {
+        // Shutdown WorkerFactory - this will coordinate shutdown of all modules
+        await WorkerFactory.shutdown();
+        state.completedAt = new Date();
+        const duration = state.completedAt.getTime() - (state.startedAt?.getTime() ?? 0);
+        Logger.info('✅ Worker management system shutdown complete', {
+            duration: `${duration}ms`,
+            signal,
+        });
+        // Clear timeout if successful
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+        }
+    }
+    catch (error) {
+        Logger.error('❌ Error during worker management system shutdown', error);
+        throw error;
+    }
+}
+/**
+ * Register process signal handlers for graceful shutdown
+ */
+function registerShutdownHandlers() {
+    if (shutdownHandlersRegistered) {
+        Logger.debug('Shutdown handlers already registered, skipping');
+        return;
+    }
+    Logger.debug('Registering worker management system shutdown handlers');
+    // SIGTERM - graceful shutdown (Docker, systemd, etc.)
+    signalHandlers.sigterm = async () => {
+        Logger.info('📨 Received SIGTERM signal');
+        try {
+            await shutdown({ signal: 'SIGTERM', timeout: 30000, forceExit: true });
+        }
+        catch (error) {
+            Logger.error('Error during SIGTERM shutdown', error);
+        }
+    };
+    process.on('SIGTERM', signalHandlers.sigterm);
+    // SIGINT - user interrupt (Ctrl+C) - REMOVED: handled by bootstrap.ts to prevent race condition
+    // process.on('SIGINT', async () => {
+    //   Logger.info('📨 Received SIGINT signal');
+    //   try {
+    //     await shutdown({ signal: 'SIGINT', timeout: 30000, forceExit: true });
+    //   } catch (error) {
+    //     Logger.error('Error during SIGINT shutdown', error);
+    //   }
+    // });
+    // SIGHUP - terminal closed
+    signalHandlers.sighup = async () => {
+        Logger.info('📨 Received SIGHUP signal');
+        try {
+            await shutdown({ signal: 'SIGHUP', timeout: 30000, forceExit: true });
+        }
+        catch (error) {
+            Logger.error('Error during SIGHUP shutdown', error);
+        }
+    };
+    process.on('SIGHUP', signalHandlers.sighup);
+    // Handle uncaught errors during shutdown
+    signalHandlers.uncaughtException = async (error) => {
+        Logger.error('💥 Uncaught exception during worker operations', error);
+        try {
+            await shutdown({ signal: 'uncaughtException', timeout: 10000, forceExit: true });
+        }
+        catch {
+            // Ignore errors during emergency shutdown
+        }
+        process.exit(1);
+    };
+    process.on('uncaughtException', signalHandlers.uncaughtException);
+    signalHandlers.unhandledRejection = (reason) => {
+        // Only log the error - don't shut down the entire application
+        Logger.error('💥 Unhandled promise rejection detected', reason);
+        Logger.warn('⚠️  This error has been logged but will not shut down the server');
+        Logger.warn('⚠️  Check the error context and fix the underlying issue');
+    };
+    process.on('unhandledRejection', signalHandlers.unhandledRejection);
+    shutdownHandlersRegistered = true;
+    Logger.debug('Worker management system shutdown handlers registered');
+}
+/**
+ * Unregister process signal handlers (for hot reload/testing)
+ */
+function unregisterShutdownHandlers() {
+    if (!shutdownHandlersRegistered)
+        return;
+    if (signalHandlers.sigterm)
+        process.off('SIGTERM', signalHandlers.sigterm);
+    if (signalHandlers.sighup)
+        process.off('SIGHUP', signalHandlers.sighup);
+    if (signalHandlers.uncaughtException)
+        process.off('uncaughtException', signalHandlers.uncaughtException);
+    if (signalHandlers.unhandledRejection)
+        process.off('unhandledRejection', signalHandlers.unhandledRejection);
+    signalHandlers.sigterm = undefined;
+    signalHandlers.sighup = undefined;
+    signalHandlers.uncaughtException = undefined;
+    signalHandlers.unhandledRejection = undefined;
+    shutdownHandlersRegistered = false;
+    Logger.debug('Worker management system shutdown handlers unregistered');
+}
+/**
+ * Check if system is currently shutting down
+ */
+function isShuttingDown() {
+    return state.isShuttingDown;
+}
+/**
+ * Get current shutdown state
+ */
+function getShutdownState() {
+    return { ...state };
+}
+// ============================================================================
+// Public API (Sealed Namespace)
+// ============================================================================
+export const WorkerShutdown = Object.freeze({
+    /**
+     * Perform graceful shutdown of all worker modules
+     */
+    shutdown,
+    /**
+     * Register process signal handlers for graceful shutdown
+     */
+    registerShutdownHandlers,
+    /**
+     * Unregister process signal handlers (for hot reload/testing)
+     */
+    unregisterShutdownHandlers,
+    /**
+     * Check if system is currently shutting down
+     */
+    isShuttingDown,
+    /**
+     * Get current shutdown state
+     */
+    getShutdownState,
+});

package/packages/workers/src/WorkerVersioning.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Worker Versioning System
+ * Semantic versioning support for workers with backward compatibility
+ * Sealed namespace for immutability
+ */
+export type SemanticVersion = {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease?: string;
+    build?: string;
+};
+export type WorkerVersion = {
+    workerName: string;
+    version: SemanticVersion;
+    createdAt: Date;
+    deprecatedAt?: Date;
+    eolDate?: Date;
+    isActive: boolean;
+    isDeprecated: boolean;
+    migrationPath?: string;
+    changelog?: string;
+    breakingChanges?: string[];
+};
+export type VersionCompatibility = {
+    sourceVersion: SemanticVersion;
+    targetVersion: SemanticVersion;
+    compatible: boolean;
+    requiresMigration: boolean;
+    breakingChanges: string[];
+    recommendations: string[];
+};
+/**
+ * Worker Versioning - Sealed namespace
+ */
+export declare const WorkerVersioning: Readonly<{
+    /**
+     * Register a worker version
+     */
+    register(workerVersion: Omit<WorkerVersion, "createdAt" | "isActive" | "isDeprecated">): void;
+    /**
+     * Get worker version
+     */
+    getVersion(workerName: string, versionStr: string): WorkerVersion | null;
+    /**
+     * Get all versions for a worker
+     */
+    getVersions(workerName: string, includeDeprecated?: boolean): ReadonlyArray<WorkerVersion>;
+    /**
+     * Get latest version
+     */
+    getLatest(workerName: string): WorkerVersion | null;
+    /**
+     * Deprecate a version
+     */
+    deprecate(workerName: string, versionStr: string, migrationPath?: string, eolDate?: Date): void;
+    /**
+     * Deactivate a version (stop accepting new jobs)
+     */
+    deactivate(workerName: string, versionStr: string): void;
+    /**
+     * Activate a version
+     */
+    activate(workerName: string, versionStr: string): void;
+    /**
+     * Check compatibility between versions
+     */
+    checkCompatibility(workerName: string, sourceVersionStr: string, targetVersionStr: string): VersionCompatibility;
+    /**
+     * Set version alias
+     */
+    setAlias(workerName: string, alias: string, versionStr: string): void;
+    /**
+     * Get version by alias
+     */
+    resolveAlias(workerName: string, alias: string): string | null;
+    /**
+     * Parse version string
+     */
+    parse(versionStr: string): SemanticVersion;
+    /**
+     * Convert version to string
+     */
+    stringify(version: SemanticVersion): string;
+    /**
+     * Compare two versions
+     */
+    compare(v1Str: string, v2Str: string): number;
+    /**
+     * Get version summary
+     */
+    getSummary(workerName: string): {
+        totalVersions: number;
+        activeVersions: number;
+        deprecatedVersions: number;
+        latest: string | null;
+        stable: string | null;
+    };
+    /**
+     * Clear all versions for a worker
+     */
+    clear(workerName: string): void;
+    /**
+     * Shutdown
+     */
+    shutdown(): void;
+}>;
+//# sourceMappingURL=WorkerVersioning.d.ts.map

package/packages/workers/src/WorkerVersioning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerVersioning.d.ts","sourceRoot":"","sources":["../../../../packages/workers/src/WorkerVersioning.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,eAAe,CAAC;IACzB,SAAS,EAAE,IAAI,CAAC;IAChB,YAAY,CAAC,EAAE,IAAI,CAAC;IACpB,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,aAAa,EAAE,eAAe,CAAC;IAC/B,aAAa,EAAE,eAAe,CAAC;IAC/B,UAAU,EAAE,OAAO,CAAC;IACpB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B,CAAC;AAoEF;;GAEG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;OAEG;4BACqB,IAAI,CAAC,aAAa,EAAE,WAAW,GAAG,UAAU,GAAG,cAAc,CAAC,GAAG,IAAI;IA2C7F;;OAEG;2BACoB,MAAM,cAAc,MAAM,GAAG,aAAa,GAAG,IAAI;IAoBxE;;OAEG;4BACqB,MAAM,gCAA8B,aAAa,CAAC,aAAa,CAAC;IAUxF;;OAEG;0BACmB,MAAM,GAAG,aAAa,GAAG,IAAI;IAWnD;;OAEG;0BACmB,MAAM,cAAc,MAAM,kBAAkB,MAAM,YAAY,IAAI,GAAG,IAAI;IAuB/F;;OAEG;2BACoB,MAAM,cAAc,MAAM,GAAG,IAAI;IAiBxD;;OAEG;yBACkB,MAAM,cAAc,MAAM,GAAG,IAAI;IAkBtD;;OAEG;mCAEW,MAAM,oBACA,MAAM,oBACN,MAAM,GACvB,oBAAoB;IAqCvB;;OAEG;yBACkB,MAAM,SAAS,MAAM,cAAc,MAAM,GAAG,IAAI;IAerE;;OAEG;6BACsB,MAAM,SAAS,MAAM,GAAG,MAAM,GAAG,IAAI;IAK9D;;OAEG;sBACe,MAAM,GAAG,eAAe;IAI1C;;OAEG;uBACgB,eAAe,GAAG,MAAM;IAI3C;;OAEG;mBACY,MAAM,SAAS,MAAM,GAAG,MAAM;IAM7C;;OAEG;2BACoB,MAAM,GAAG;QAC9B,aAAa,EAAE,MAAM,CAAC;QACtB,cAAc,EAAE,MAAM,CAAC;QACvB,kBAAkB,EAAE,MAAM,CAAC;QAC3B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;KACvB;IAcD;;OAEG;sBACe,MAAM,GAAG,IAAI;IAkB/B;;OAEG;gBACS,IAAI;EAQhB,CAAC"}

package/packages/workers/src/WorkerVersioning.js

@@ -0,0 +1,300 @@
+/**
+ * Worker Versioning System
+ * Semantic versioning support for workers with backward compatibility
+ * Sealed namespace for immutability
+ */
+import { ErrorFactory, Logger } from '../../../src/index.js';
+// Internal state
+const workerVersions = new Map();
+const versionAliases = new Map(); // 'latest', 'stable', etc. -> version string
+/**
+ * Helper: Parse version string
+ */
+const parseVersion = (versionStr) => {
+    const match = new RegExp(/^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9.-]+))?(?:\+([a-zA-Z0-9.-]+))?$/).exec(versionStr);
+    if (!match) {
+        throw ErrorFactory.createConfigError(`Invalid version format: ${versionStr}`);
+    }
+    return {
+        major: Number.parseInt(match[1], 10),
+        minor: Number.parseInt(match[2], 10),
+        patch: Number.parseInt(match[3], 10),
+        prerelease: match[4],
+        build: match[5],
+    };
+};
+/**
+ * Helper: Convert version to string
+ */
+const versionToString = (version) => {
+    let str = `${version.major}.${version.minor}.${version.patch}`;
+    if (typeof version.prerelease === 'string' && version.prerelease.length > 0) {
+        str += `-${version.prerelease}`;
+    }
+    if (typeof version.build === 'string' && version.build.length > 0) {
+        str += `+${version.build}`;
+    }
+    return str;
+};
+/**
+ * Helper: Compare versions
+ * Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
+ */
+const compareVersions = (v1, v2) => {
+    if (v1.major !== v2.major)
+        return v1.major - v2.major;
+    if (v1.minor !== v2.minor)
+        return v1.minor - v2.minor;
+    if (v1.patch !== v2.patch)
+        return v1.patch - v2.patch;
+    // Prerelease versions have lower precedence
+    if (v1.prerelease === undefined && v2.prerelease !== undefined)
+        return 1;
+    if (v1.prerelease !== undefined && v2.prerelease === undefined)
+        return -1;
+    if (v1.prerelease !== undefined && v2.prerelease !== undefined) {
+        return v1.prerelease.localeCompare(v2.prerelease);
+    }
+    return 0;
+};
+/**
+ * Helper: Check if versions are compatible (no breaking changes)
+ */
+const areVersionsCompatible = (v1, v2) => {
+    // Same major version = compatible (semver rules)
+    return v1.major === v2.major;
+};
+/**
+ * Worker Versioning - Sealed namespace
+ */
+export const WorkerVersioning = Object.freeze({
+    /**
+     * Register a worker version
+     */
+    register(workerVersion) {
+        const { workerName, version } = workerVersion;
+        const versionStr = versionToString(version);
+        let versions = workerVersions.get(workerName);
+        if (!versions) {
+            versions = [];
+            workerVersions.set(workerName, versions);
+        }
+        // Check if version already exists
+        const existing = versions.find((v) => versionToString(v.version) === versionStr);
+        if (existing) {
+            ErrorFactory.createConfigError(`Version ${versionStr} already registered for worker "${workerName}"`);
+        }
+        const fullVersion = {
+            ...workerVersion,
+            createdAt: new Date(),
+            isActive: true,
+            isDeprecated: false,
+        };
+        versions.push(fullVersion);
+        // Sort by version (descending)
+        versions.sort((a, b) => -compareVersions(a.version, b.version));
+        // Update 'latest' alias if this is the newest version
+        if (versions[0] === fullVersion) {
+            const aliasKey = `${workerName}:latest`;
+            versionAliases.set(aliasKey, versionStr);
+        }
+        Logger.info(`Worker version registered: ${workerName}@${versionStr}`, {
+            isActive: fullVersion.isActive,
+        });
+    },
+    /**
+     * Get worker version
+     */
+    getVersion(workerName, versionStr) {
+        // Check if it's an alias
+        let newVersionStr = versionStr;
+        const aliasKey = `${workerName}:${newVersionStr}`;
+        const aliasedVersion = versionAliases.get(aliasKey);
+        if (aliasedVersion !== undefined) {
+            newVersionStr = aliasedVersion;
+        }
+        const versions = workerVersions.get(workerName);
+        if (!versions)
+            return null;
+        const version = parseVersion(newVersionStr);
+        const found = versions.find((v) => compareVersions(v.version, version) === 0);
+        return found ? { ...found } : null;
+    },
+    /**
+     * Get all versions for a worker
+     */
+    getVersions(workerName, includeDeprecated = false) {
+        const versions = workerVersions.get(workerName) ?? [];
+        if (!includeDeprecated) {
+            return versions.filter((v) => !v.isDeprecated);
+        }
+        return versions.map((v) => ({ ...v }));
+    },
+    /**
+     * Get latest version
+     */
+    getLatest(workerName) {
+        const versions = workerVersions.get(workerName);
+        if (!versions || versions.length === 0)
+            return null;
+        // Already sorted by version (descending)
+        const latest = versions.find((v) => v.isActive && !v.isDeprecated);
+        return latest ? { ...latest } : null;
+    },
+    /**
+     * Deprecate a version
+     */
+    deprecate(workerName, versionStr, migrationPath, eolDate) {
+        const version = WorkerVersioning.getVersion(workerName, versionStr);
+        if (!version) {
+            throw ErrorFactory.createNotFoundError(`Version ${versionStr} not found for worker "${workerName}"`);
+        }
+        const versions = workerVersions.get(workerName) ?? [];
+        const index = versions.findIndex((v) => versionToString(v.version) === versionStr);
+        versions[index].isDeprecated = true;
+        versions[index].deprecatedAt = new Date();
+        versions[index].migrationPath = migrationPath;
+        versions[index].eolDate = eolDate;
+        Logger.warn(`Worker version deprecated: ${workerName}@${versionStr}`, {
+            migrationPath,
+            eolDate,
+        });
+    },
+    /**
+     * Deactivate a version (stop accepting new jobs)
+     */
+    deactivate(workerName, versionStr) {
+        const version = WorkerVersioning.getVersion(workerName, versionStr);
+        if (!version) {
+            throw ErrorFactory.createNotFoundError(`Version ${versionStr} not found for worker "${workerName}"`);
+        }
+        const versions = workerVersions.get(workerName) ?? [];
+        const index = versions.findIndex((v) => versionToString(v.version) === versionStr);
+        versions[index].isActive = false;
+        Logger.info(`Worker version deactivated: ${workerName}@${versionStr}`);
+    },
+    /**
+     * Activate a version
+     */
+    activate(workerName, versionStr) {
+        const version = WorkerVersioning.getVersion(workerName, versionStr);
+        if (!version) {
+            throw ErrorFactory.createNotFoundError(`Version ${versionStr} not found for worker "${workerName}"`);
+        }
+        const getWorkerVersions = workerVersions.get(workerName);
+        const versions = getWorkerVersions ?? [];
+        const index = versions.findIndex((v) => versionToString(v.version) === versionStr);
+        versions[index].isActive = true;
+        Logger.info(`Worker version activated: ${workerName}@${versionStr}`);
+    },
+    /**
+     * Check compatibility between versions
+     */
+    checkCompatibility(workerName, sourceVersionStr, targetVersionStr) {
+        const sourceVersion = parseVersion(sourceVersionStr);
+        const targetVersion = parseVersion(targetVersionStr);
+        const source = WorkerVersioning.getVersion(workerName, sourceVersionStr);
+        const target = WorkerVersioning.getVersion(workerName, targetVersionStr);
+        const compatible = areVersionsCompatible(sourceVersion, targetVersion);
+        const requiresMigration = !compatible || sourceVersion.major < targetVersion.major;
+        const breakingChanges = target?.breakingChanges ?? [];
+        const recommendations = [];
+        if (target?.isDeprecated === true) {
+            recommendations.push(`Target version is deprecated. Consider migrating to ${(target.migrationPath ?? '') || 'latest'}`);
+        }
+        if (!compatible) {
+            recommendations.push('Major version change detected. Review breaking changes carefully.');
+        }
+        if (source?.eolDate && source.eolDate < new Date()) {
+            recommendations.push('Source version has reached end of life. Migration is required.');
+        }
+        return {
+            sourceVersion,
+            targetVersion,
+            compatible,
+            requiresMigration,
+            breakingChanges,
+            recommendations,
+        };
+    },
+    /**
+     * Set version alias
+     */
+    setAlias(workerName, alias, versionStr) {
+        const version = WorkerVersioning.getVersion(workerName, versionStr);
+        if (!version) {
+            throw ErrorFactory.createNotFoundError(`Version ${versionStr} not found for worker "${workerName}"`);
+        }
+        const aliasKey = `${workerName}:${alias}`;
+        versionAliases.set(aliasKey, versionStr);
+        Logger.info(`Version alias set: ${alias} -> ${workerName}@${versionStr}`);
+    },
+    /**
+     * Get version by alias
+     */
+    resolveAlias(workerName, alias) {
+        const aliasKey = `${workerName}:${alias}`;
+        return versionAliases.get(aliasKey) ?? null;
+    },
+    /**
+     * Parse version string
+     */
+    parse(versionStr) {
+        return parseVersion(versionStr);
+    },
+    /**
+     * Convert version to string
+     */
+    stringify(version) {
+        return versionToString(version);
+    },
+    /**
+     * Compare two versions
+     */
+    compare(v1Str, v2Str) {
+        const v1 = parseVersion(v1Str);
+        const v2 = parseVersion(v2Str);
+        return compareVersions(v1, v2);
+    },
+    /**
+     * Get version summary
+     */
+    getSummary(workerName) {
+        const versions = workerVersions.get(workerName) ?? [];
+        const summary = {
+            totalVersions: versions.length,
+            activeVersions: versions.filter((v) => v.isActive).length,
+            deprecatedVersions: versions.filter((v) => v.isDeprecated).length,
+            latest: WorkerVersioning.resolveAlias(workerName, 'latest'),
+            stable: WorkerVersioning.resolveAlias(workerName, 'stable'),
+        };
+        return summary;
+    },
+    /**
+     * Clear all versions for a worker
+     */
+    clear(workerName) {
+        workerVersions.delete(workerName);
+        // Remove aliases
+        const keysToDelete = [];
+        for (const [key] of versionAliases.entries()) {
+            if (key.startsWith(`${workerName}:`)) {
+                keysToDelete.push(key);
+            }
+        }
+        for (const key of keysToDelete) {
+            versionAliases.delete(key);
+        }
+        Logger.info(`All versions cleared for worker: ${workerName}`);
+    },
+    /**
+     * Shutdown
+     */
+    shutdown() {
+        Logger.info('WorkerVersioning shutting down...');
+        workerVersions.clear();
+        versionAliases.clear();
+        Logger.info('WorkerVersioning shutdown complete');
+    },
+});
+// Graceful shutdown handled by WorkerShutdown

package/packages/workers/src/config/workerConfig.d.ts

@@ -0,0 +1,5 @@
+export declare const WorkerConfig: Readonly<{
+    getWorkerBaseUrl: () => string;
+}>;
+export declare const keyPrefix: () => string;
+//# sourceMappingURL=workerConfig.d.ts.map

package/packages/workers/src/config/workerConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workerConfig.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/src/config/workerConfig.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,YAAY;4BATO,MAAM;EAWpC,CAAC;AAEH,eAAO,MAAM,SAAS,QAAO,MAM5B,CAAC"}

package/packages/workers/src/config/workerConfig.js

@@ -0,0 +1,25 @@
+import { Env, appConfig } from '../../../../src/index.js';
+const normalizeBaseUrl = (value) => {
+    let end = value.length;
+    while (end > 0 && value.charAt(end - 1) === '/') {
+        end--;
+    }
+    return value.slice(0, end);
+};
+const withHttpScheme = (value) => value.startsWith('http://') || value.startsWith('https://') ? value : `http://${value}`;
+const resolveWorkerApiUrl = () => {
+    const workerApiUrl = Env.get('WORKER_API_URL');
+    if (workerApiUrl) {
+        return normalizeBaseUrl(withHttpScheme(workerApiUrl));
+    }
+    return '';
+};
+export const WorkerConfig = Object.freeze({
+    getWorkerBaseUrl: resolveWorkerApiUrl,
+});
+export const keyPrefix = () => {
+    const redisKeyPrefix = (Env.get('WORKER_PERSISTENCE_REDIS_KEY_PREFIX', '') ?? '').trim();
+    return redisKeyPrefix
+        ? `${redisKeyPrefix}_worker_${appConfig.prefix}`
+        : `worker_${appConfig.prefix}`;
+};

package/packages/workers/src/createQueueWorker.d.ts

@@ -0,0 +1,26 @@
+type QueueWorker = {
+    processOne: (queueName?: string, driverName?: string) => Promise<boolean>;
+    processAll: (queueName?: string, driverName?: string) => Promise<number>;
+    runOnce: (opts?: {
+        queueName?: string;
+        driverName?: string;
+        maxItems?: number;
+        maxDurationMs?: number;
+    }) => Promise<number>;
+    startWorker: (opts?: {
+        queueName?: string;
+        driverName?: string;
+        signal?: AbortSignal;
+        maxDurationMs?: number;
+    }) => Promise<number>;
+};
+export type CreateQueueWorkerOptions<TPayload> = {
+    kindLabel: string;
+    defaultQueueName: string;
+    maxAttempts: number;
+    getLogFields: (payload: TPayload) => Record<string, unknown>;
+    handle: (payload: TPayload) => Promise<void>;
+};
+export declare function createQueueWorker<TPayload>(options: CreateQueueWorkerOptions<TPayload>): QueueWorker;
+export {};
+//# sourceMappingURL=createQueueWorker.d.ts.map

package/packages/workers/src/createQueueWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createQueueWorker.d.ts","sourceRoot":"","sources":["../../../../packages/workers/src/createQueueWorker.ts"],"names":[],"mappings":"AAkHA,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1E,UAAU,EAAE,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACzE,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE;QACf,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACtB,WAAW,EAAE,CAAC,IAAI,CAAC,EAAE;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,MAAM,CAAC,EAAE,WAAW,CAAC;QACrB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,wBAAwB,CAAC,QAAQ,IAAI;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7D,MAAM,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9C,CAAC;AAucF,wBAAgB,iBAAiB,CAAC,QAAQ,EACxC,OAAO,EAAE,wBAAwB,CAAC,QAAQ,CAAC,GAC1C,WAAW,CAOb"}