@diia-inhouse/workflow 1.17.11 → 2.5.0

package/dist/types/services/worker.d.ts

@@ -1,113 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
-import { Worker, WorkerOptions } from '@temporalio/worker';
-import { EnvService } from '@diia-inhouse/env';
-import { AlsData, Logger } from '@diia-inhouse/types';
-import { AppConfig } from '../interfaces/config';
-import type { ActivityClass, App, WorkerBootstrapOptions } from '../interfaces/services/worker';
-export type { ActivityClass, App, State, WorkerBootstrapOptions } from '../interfaces/services/worker';
-export type { WorkerHealthDetails } from './workerHealth';
-export { buildWorkerIdentity } from './worker/identity';
-export { WorkerHealthService } from './workerHealth';
-/**
- * Applies service process configuration overrides when the worker runs separately.
- *
- * When `temporal.workerInProcess` is `false`, disables `temporal` and `temporal-worker` scrapers
- * so the main service does not scrape metrics that the worker process handles.
- *
- * Mutates the config object in place. Safe to call when scrapers are absent.
- */
-export declare function applyServiceProcessConfig(config: AppConfig): void;
-/**
- * Applies worker process configuration overrides.
- *
- * - Disables queue consumers on all rabbit connections (unless `temporal.disableQueueConsumers` is `false`)
- * - Overrides `metrics.custom.port` with the `'temporal-worker'` scraper port and disables that scraper to prevent self-scraping
- *
- * Mutates the config object in place. Safe to call when queue config is absent.
- */
-export declare function applyWorkerProcessConfig(config: AppConfig): void;
-export declare function instantiateActivities(app: App, workerActivities: Record<string, ActivityClass>): Record<string, (...args: unknown[]) => Promise<unknown>>;
-/**
- * Initializes and starts Temporal worker with full dependency injection support.
- *
- * This is the recommended way to initialize Temporal workers. It handles:
- * - Automatic dependency injection for activities
- * - AsyncLocalStorage setup for distributed tracing
- * - OpenTelemetry integration
- * - Activity instantiation and binding
- *
- * @param app - App instance for DI container and config access
- * @param options - Worker configuration options
- * @param options.nodeTracerProvider - OpenTelemetry tracer provider
- * @param options.workflowsPath - Path to workflows module
- * @param options.activities - Activity classes to instantiate
- *
- * @example
- * ```typescript
- * // Define your activities
- * const workerActivities = {
- *     userActivity: UserActivity,
- *     notificationActivity: NotificationActivity,
- * }
- *
- * // Initialize and start the worker
- * await initTemporalWorker(app, {
- *     nodeTracerProvider,
- *     workflowsPath: require.resolve('./worker/workflows'),
- *     activities: workerActivities,
- * })
- * ```
- */
-export declare function initTemporalWorker(app: App, options: {
-    nodeTracerProvider: NodeTracerProvider;
-    workflowsPath: string;
-    activities: Record<string, ActivityClass>;
-} & Omit<WorkerOptions, 'taskQueue' | 'activities' | 'workflowsPath'>): Promise<void>;
-/**
- * Bootstraps and runs Temporal worker with graceful shutdown.
- *
- * Handles both in-process and separate-process worker topologies:
- *
- * - **In-process** (`workerInProcess` is `true` or unset): initializes and runs the worker.
- * - **Separate process** (called from a dedicated worker entry with `configFactory`/`deps`):
- *   manages the full application lifecycle: setConfig → apply worker overrides → setDeps →
- *   initialize → start → run worker.
- * - **Service-only** (`workerInProcess` is `false`, no `configFactory`): disables temporal
- *   scrapers on the main service (worker handles them separately) and returns immediately.
- *
- * Automatically integrates worker health with the app's centralized health check
- * system via `HealthCheck.addHealthCheckable()`.
- *
- * @param app - App instance for DI container and config access
- * @param options - Worker bootstrap options
- *
- * @example
- * ```typescript
- * // Separate worker process with full lifecycle management
- * const app = new Application(serviceName, nodeTracerProvider, loggerConfig)
- *
- * await bootstrapWorker(app, {
- *     configFactory,
- *     deps,
- *     workflowsPath: require.resolve('./worker/workflows'),
- *     activities: workerActivities,
- *     nodeTracerProvider,
- * })
- * ```
- */
-export declare function bootstrapWorker(app: App, options: WorkerBootstrapOptions): Promise<void>;
-/**
- * Initializes Temporal worker.
- *
- * @param config - Application configuration
- * @param options - Worker options including workflows path
- * @param envService - Environment service instance
- * @param logger - Logger instance (optional)
- * @param nodeTracerProvider - OpenTelemetry tracer provider (optional)
- * @param asyncLocalStorage - AsyncLocalStorage instance for tracing context (optional)
- * @returns Configured Temporal worker
- */
-export declare function initWorker({ temporal: temporalConfig, metrics: { custom: metricsConfig } }: AppConfig, options: Omit<WorkerOptions, 'taskQueue'> & {
-    taskQueue?: string;
-}, envService: EnvService, logger?: Logger, nodeTracerProvider?: NodeTracerProvider, asyncLocalStorage?: AsyncLocalStorage<AlsData>): Promise<Worker>;

package/dist/types/services/workerHealth.d.ts

@@ -1,11 +0,0 @@
-import { WorkerStatus } from '@temporalio/worker';
-import { HealthCheckResult, OnHealthCheck } from '@diia-inhouse/types';
-import { WorkerStatusProvider } from '../interfaces/services/worker';
-export interface WorkerHealthDetails {
-    worker: WorkerStatus | 'NOT_INITIALIZED';
-}
-export declare class WorkerHealthService implements OnHealthCheck {
-    private statusProvider?;
-    setStatusProvider(provider: WorkerStatusProvider): void;
-    onHealthCheck(): Promise<HealthCheckResult<WorkerHealthDetails>>;
-}

package/dist/types/testing.d.ts

@@ -1,42 +0,0 @@
-export { defaultActivityInfo, MockActivityEnvironment, TestWorkflowEnvironment, TimeSkippingWorkflowClient, workflowInterceptorModules, } from '@temporalio/testing';
-type ActivityMethods<T> = T extends {
-    prototype: infer P;
-} ? {
-    [K in keyof P]?: P[K] extends (...args: any[]) => any ? (...args: Parameters<P[K]>) => ReturnType<P[K]> : never;
-} : never;
-/**
- * Redefines instantiated activities for use in test environments.
- *
- * This function allows to override specific activity methods with mock implementations
- * while preserving the overall activity structure.
- *
- * @example
- * // Original activities object
- * const activities = instantiateActivities(app, workerActivities)
- *
- * // Mock specific methods for testing
- * const mockedActivities = {
- *   ...activities,
- *   ...mockActivities<typeof workerActivities>({
- *     user: {
- *       getProfile: async (userId) => ({ id: userId, name: 'Test User' }),
- *     },
- *     payment: {
- *       process: async () => ({ success: true, transactionId: 'mock-123' })
- *     }
- *   })
- * }
- *
- * @example
- * // Using with test runner
- * await runWorkflow({
- *   workflow: myWorkflow,
- *   args: [workflowInput],
- *   activities: mockedActivities
- * })
- */
-export declare function mockActivities<TActivities extends Record<string, {
-    prototype: unknown;
-}>>(activities: {
-    [K in keyof TActivities]?: ActivityMethods<TActivities[K]>;
-}): Record<string, (...args: unknown[]) => unknown>;

package/dist/types/worker.d.ts

@@ -1,3 +0,0 @@
-export { type WorkerOptions, type WorkerStatus, type WorkerInterceptors, NativeConnection, Runtime, type State, bundleWorkflowCode, Worker, } from '@temporalio/worker';
-export * from './interceptors';
-export * from './services/worker';

package/dist/worker.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"worker.js","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,6CAS2B;AALvB,0GAAA,gBAAgB,OAAA;AAChB,iGAAA,OAAO,OAAA;AAEP,4GAAA,kBAAkB,OAAA;AAClB,gGAAA,MAAM,OAAA;AAGV,iDAA8B;AAE9B,oDAAiC"}