@diia-inhouse/workflow 1.15.0

package/dist/testing.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflowInterceptorModules = exports.TimeSkippingWorkflowClient = exports.TestWorkflowEnvironment = exports.MockActivityEnvironment = exports.defaultActivityInfo = void 0;
+exports.mockActivities = mockActivities;
+var testing_1 = require("@temporalio/testing");
+Object.defineProperty(exports, "defaultActivityInfo", { enumerable: true, get: function () { return testing_1.defaultActivityInfo; } });
+Object.defineProperty(exports, "MockActivityEnvironment", { enumerable: true, get: function () { return testing_1.MockActivityEnvironment; } });
+Object.defineProperty(exports, "TestWorkflowEnvironment", { enumerable: true, get: function () { return testing_1.TestWorkflowEnvironment; } });
+Object.defineProperty(exports, "TimeSkippingWorkflowClient", { enumerable: true, get: function () { return testing_1.TimeSkippingWorkflowClient; } });
+Object.defineProperty(exports, "workflowInterceptorModules", { enumerable: true, get: function () { return testing_1.workflowInterceptorModules; } });
+/**
+ * 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
+ * })
+ */
+function mockActivities(activities) {
+    const result = {};
+    for (const activityName in activities) {
+        const methods = activities[activityName];
+        if (methods) {
+            for (const [methodName, method] of Object.entries(methods)) {
+                const fullKey = `${activityName}.${methodName}`;
+                if (typeof method === 'function') {
+                    result[fullKey] = method;
+                }
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=testing.js.map

package/dist/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.js","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":";;;AA4CA,wCAoBC;AAhED,+CAM4B;AALxB,8GAAA,mBAAmB,OAAA;AACnB,kHAAA,uBAAuB,OAAA;AACvB,kHAAA,uBAAuB,OAAA;AACvB,qHAAA,0BAA0B,OAAA;AAC1B,qHAAA,0BAA0B,OAAA;AAQ9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,SAAgB,cAAc,CAA6D,UAE1F;IACG,MAAM,MAAM,GAAoD,EAAE,CAAA;IAElE,KAAK,MAAM,YAAY,IAAI,UAAU,EAAE,CAAC;QACpC,MAAM,OAAO,GAAG,UAAU,CAAC,YAAY,CAAC,CAAA;QAExC,IAAI,OAAO,EAAE,CAAC;YACV,KAAK,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;gBACzD,MAAM,OAAO,GAAG,GAAG,YAAY,IAAI,UAAU,EAAE,CAAA;gBAE/C,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE,CAAC;oBAC/B,MAAM,CAAC,OAAO,CAAC,GAAG,MAAyC,CAAA;gBAC/D,CAAC;YACL,CAAC;QACL,CAAC;IACL,CAAC;IAED,OAAO,MAAM,CAAA;AACjB,CAAC"}

package/dist/types/activities/index.d.ts

@@ -0,0 +1 @@
+export * from './proxy';

package/dist/types/activities/proxy.d.ts

@@ -0,0 +1,35 @@
+import { ActivityInterfaceFor, ActivityOptions, proxyLocalActivities } from '@temporalio/workflow';
+type ActivityClass<T> = T extends {
+    prototype: infer P;
+} ? P : never;
+type LocalActivityOptions = Parameters<typeof proxyLocalActivities>[0];
+/**
+ * Enhances Temporal activities by prefixing method names with their class name.
+ *
+ * Wraps Temporal's proxy functions to provide namespacing (e.g., `orderProcessing.processOrder`),
+ * improving organization in Temporal's UI and avoiding naming conflicts.
+ *
+ * @param {boolean} useLocalActivitiesProxy - Use local activities (true) or regular activities (false, default)
+ * @returns {Object} Proxy with class name prefixing for activity methods
+ *
+ * @example
+ * import type { workerActivities } from '../activities'
+ *
+ * const activities = buildActivitiesProxy<typeof workerActivities>();
+ *
+ * // In workflow
+ * const payment = activities.payment({ startToCloseTimeout: '30s' });
+ * const order = activities.order({ startToCloseTimeout: '30s' });
+ *
+ * const success = await payment.processPayment(orderId, amount); // Calls "payment.processPayment" activity
+ * if (success) {
+ *   return await order.process(orderId); // Calls "order.process" activity
+ * }
+ */
+export declare function buildActivitiesProxy<TActivity extends Record<string, unknown>>(useLocalActivitiesProxy: true): {
+    [K in keyof TActivity]: (options: LocalActivityOptions) => ActivityInterfaceFor<ActivityClass<TActivity[K]>>;
+};
+export declare function buildActivitiesProxy<TActivity extends Record<string, unknown>>(useLocalActivitiesProxy?: false): {
+    [K in keyof TActivity]: (options: ActivityOptions) => ActivityInterfaceFor<ActivityClass<TActivity[K]>>;
+};
+export {};

package/dist/types/activity.d.ts

@@ -0,0 +1 @@
+export { type Info as ActivityInfo, ApplicationFailure, CancelledFailure, CompleteAsyncError, activityInfo, sleep, heartbeat, log, Context, cancellationSignal, cancelled, } from '@temporalio/activity';

package/dist/types/cli/checkWorkflowDeterminism.d.ts

@@ -0,0 +1,22 @@
+import { EnvService } from '@diia-inhouse/env';
+import { Logger } from '@diia-inhouse/types';
+export declare class CheckWorkflowDeterminismCommand {
+    private readonly logger;
+    private readonly envService;
+    private temporalConfig;
+    private report;
+    private readonly maxWorkflowsPerType;
+    private readonly maxRetries;
+    private readonly retryDelay;
+    constructor(logger: Logger, envService: EnvService);
+    run(workflowsPath?: string, taskQueueParam?: string, workflowId?: string): Promise<void>;
+    private checkWorkflowDeterminism;
+    private runReplayHistory;
+    private runReplayHistoryWithRetry;
+    private checkSingleWorkflow;
+    private loadWorkflows;
+    private listCompletedOrFailedWorkflows;
+    private resolveWorkflowsPath;
+    private getTaskQueue;
+    private printBeautifulResults;
+}

package/dist/types/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/types/cli/syncTemporalSchedules.d.ts

@@ -0,0 +1,12 @@
+import { EnvService } from '@diia-inhouse/env';
+import { Logger } from '@diia-inhouse/types';
+export declare class SyncTemporalSchedulesCommand {
+    private readonly logger;
+    private readonly envService;
+    constructor(logger: Logger, envService: EnvService);
+    run(schedulesPath?: string, taskQueueParam?: string): Promise<void>;
+    private loadSchedules;
+    private resolveSchedulesPath;
+    private syncSchedules;
+    private getTaskQueue;
+}

package/dist/types/cli/updateTemporalSchedule.d.ts

@@ -0,0 +1,9 @@
+import { EnvService } from '@diia-inhouse/env';
+import { Logger } from '@diia-inhouse/types';
+export declare class UpdateTemporalScheduleCommand {
+    private readonly logger;
+    private readonly envService;
+    constructor(logger: Logger, envService: EnvService);
+    run(scheduleId: string, updateData: Record<string, unknown>): Promise<void>;
+    private getTaskQueue;
+}

package/dist/types/client.d.ts

@@ -0,0 +1,2 @@
+export { Client, ScheduleOptions, DAYS_OF_WEEK, type DayOfWeek, MONTHS, type Month, WorkflowClient, ActivityFailure, ProtoFailure, ServerFailure, TimeoutFailure, TemporalFailure, CancelledFailure, TerminatedFailure, ApplicationFailure, ChildWorkflowFailure, WorkflowHandleWithFirstExecutionRunId, } from '@temporalio/client';
+export { TemporalClient } from './services/client';

package/dist/types/common.d.ts

@@ -0,0 +1 @@
+export { type DataConverter, arrayFromPayloads, cutoffStackTrace, ensureApplicationFailure, ensureTemporalFailure, extractWorkflowType, defaultFailureConverter, rootCause, WorkflowExecutionAlreadyStartedError, } from '@temporalio/common';

package/dist/types/encryption/crypto.d.ts

@@ -0,0 +1,3 @@
+import { webcrypto as crypto } from 'crypto';
+export declare function encrypt(data: Uint8Array, key: crypto.CryptoKey): Promise<Uint8Array>;
+export declare function decrypt(encryptedData: Uint8Array, key: crypto.CryptoKey): Promise<Uint8Array>;

package/dist/types/encryption/dataConverter.d.ts

@@ -0,0 +1,3 @@
+import { DataConverter } from '@temporalio/common';
+import { EnvService } from '@diia-inhouse/env';
+export declare function getDataConverter(keyId: string, envService: EnvService, refreshInterval?: number): Promise<DataConverter>;

package/dist/types/encryption/encryptionCodec.d.ts

@@ -0,0 +1,27 @@
+import { webcrypto as crypto } from 'node:crypto';
+import { Payload, PayloadCodec } from '@temporalio/common';
+import { EnvService } from '@diia-inhouse/env';
+import { Logger } from '@diia-inhouse/types';
+export declare class EncryptionCodec implements PayloadCodec {
+    private readonly keys;
+    private defaultKeyId;
+    private readonly envService;
+    private readonly logger;
+    private readonly batchSize;
+    private readonly encoding;
+    private readonly metadataEncryptionKeyId;
+    constructor(keys: Map<string, crypto.CryptoKey>, defaultKeyId: string, envService: EnvService, logger: Logger, options?: {
+        batchSize?: number;
+        vaultEnabled?: boolean;
+    });
+    static create(keyId: string, envService: EnvService, options: {
+        batchSize?: number;
+        vaultEnabled?: boolean;
+    }, logger?: Logger): Promise<EncryptionCodec>;
+    private static createCryptoKey;
+    refreshDefaultKey(): Promise<void>;
+    encode(payloads: Payload[]): Promise<Payload[]>;
+    decode(payloads: Payload[]): Promise<Payload[]>;
+    private processBatch;
+    private splitKeyId;
+}

package/dist/types/encryption/index.d.ts

@@ -0,0 +1,3 @@
+export * from './dataConverter';
+export * from './encryptionCodec';
+export * from './crypto';

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * as proto from '@temporalio/proto';
+export { TemporalConfig } from './interfaces';
+export * from './encryption';

package/dist/types/instrumentation.d.ts

@@ -0,0 +1,2 @@
+import { OTLPTraceExporter as OTLPTraceExporterGrpc } from '@opentelemetry/exporter-trace-otlp-grpc';
+export declare const traceExporter: OTLPTraceExporterGrpc;

package/dist/types/interceptors/asyncLocalStorageBridge.d.ts

@@ -0,0 +1,21 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { Context as ActivityContext } from '@temporalio/activity';
+import { ActivityExecuteInput, ActivityInboundCallsInterceptor, Next } from '@temporalio/worker';
+import { AlsData, Logger } from '@diia-inhouse/types';
+/**
+ * Bridges OpenTelemetry trace context to AsyncLocalStorage for Temporal activities.
+ *
+ * Extracts trace_id from OpenTelemetry span and injects it into AsyncLocalStorage,
+ * making it available to services.
+ *
+ * @example
+ * // In a service called from an activity:
+ * const traceId = this.asyncLocalStorage.getStore()?.logData?.traceId
+ */
+export declare class AsyncLocalStorageBridgeInterceptor implements ActivityInboundCallsInterceptor {
+    protected readonly ctx: ActivityContext;
+    private readonly asyncLocalStorage;
+    private readonly logger;
+    constructor(ctx: ActivityContext, asyncLocalStorage: AsyncLocalStorage<AlsData>, logger: Logger);
+    execute(input: ActivityExecuteInput, next: Next<ActivityInboundCallsInterceptor, 'execute'>): Promise<unknown>;
+}

package/dist/types/interceptors/index.d.ts

@@ -0,0 +1 @@
+export { AsyncLocalStorageBridgeInterceptor } from './asyncLocalStorageBridge';

package/dist/types/interceptors.d.ts

@@ -0,0 +1,2 @@
+import { WorkflowInterceptorsFactory } from '@temporalio/workflow';
+export declare const workflowInterceptors: WorkflowInterceptorsFactory;

package/dist/types/interfaces/config.d.ts

@@ -0,0 +1,38 @@
+import { ClientOptions, ConnectionOptions } from '@temporalio/client';
+import { MetricsConfig } from '@diia-inhouse/diia-metrics';
+import type { QueueConnectionConfig } from '@diia-inhouse/diia-queue';
+export interface TemporalConfig extends Omit<ClientOptions, 'dataConverter'> {
+    taskQueue: string;
+    encryptionEnabled: boolean;
+    encryptionKeyId: string;
+    encryptionKeyRefreshInterval?: number;
+    address?: string;
+    tls?: ConnectionOptions['tls'];
+    connectTimeout?: ConnectionOptions['connectTimeout'];
+    /**
+     * Controls whether the Temporal worker runs in the same process as the service.
+     *
+     * - `true` (default): Worker is bootstrapped together with the service in the same process.
+     * - `false`: Service starts without bootstrapping the worker. The worker should be run
+     *   as a separate process using `bootstrapWorker()`.
+     *
+     * This is configured at the service level to enable flexible deployment topologies
+     * where workers can be scaled independently from the main service.
+     */
+    workerInProcess?: boolean;
+    /**
+     * Whether to disable message queue consumers when running as a separate worker process.
+     * Applies to all queue connection types (internal, external, etc.).
+     *
+     * Defaults to `true` when `bootstrapWorker` manages the full application lifecycle
+     * (i.e. when `configFactory` and `deps` are provided).
+     */
+    disableQueueConsumers?: boolean;
+}
+export interface AppConfig {
+    temporal: TemporalConfig;
+    metrics: {
+        custom: MetricsConfig;
+    };
+    rabbit?: QueueConnectionConfig;
+}

package/dist/types/interfaces/index.d.ts

@@ -0,0 +1 @@
+export * from './config';

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

@@ -0,0 +1,37 @@
+import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
+import { WorkerOptions, WorkerStatus } from '@temporalio/worker';
+export type { State, WorkerStatus } from '@temporalio/worker';
+export type WorkerStatusProvider = () => WorkerStatus;
+export type ActivityInstance = Record<string, (...args: any[]) => any>;
+export type BoundActivities<T extends ActivityInstance> = {
+    [K in keyof T as `${string}.${string & K}`]: ReturnType<T[K]> extends Promise<any> ? T[K] : (...args: Parameters<T[K]>) => Promise<ReturnType<T[K]>>;
+};
+export type ActivityClass = new (...args: any[]) => any;
+export interface WorkerBootstrapOptions extends Omit<WorkerOptions, 'taskQueue' | 'activities' | 'workflowsPath'> {
+    workflowsPath: string;
+    activities: Record<string, ActivityClass>;
+    nodeTracerProvider?: NodeTracerProvider;
+    shutdownSignals?: NodeJS.Signals[];
+    /**
+     * When provided together with `deps`, `bootstrapWorker` manages the full application
+     * lifecycle: setConfig → apply worker overrides → setDeps → initialize → start → run worker.
+     */
+    configFactory?: (...args: any[]) => Promise<any>;
+    /**
+     * Dependency factory passed to `app.setDeps()`. Required when `configFactory` is provided.
+     */
+    deps?: (...args: any[]) => Promise<any>;
+}
+interface Container {
+    build(constructor: new (...args: unknown[]) => unknown): unknown;
+    resolve<T = unknown>(key: string): T;
+}
+export interface App {
+    container?: Container;
+    getConfig?(): unknown;
+    setConfig?(factory: (...args: any[]) => Promise<any>): Promise<any>;
+    setDeps?(factory: (...args: any[]) => Promise<any>): Promise<any>;
+    initialize?(...args: any[]): Promise<{
+        start(): Promise<any>;
+    }>;
+}

package/dist/types/operations.d.ts

@@ -0,0 +1,5 @@
+import { ActivityFailure } from '@temporalio/common';
+export { allHandlersFinished, condition, continueAsNew, makeContinueAsNewFunc, ContinueAsNew, type ContinueAsNewOptions, setDefaultSignalHandler, log, workflowInfo, type WorkflowInfo, currentUpdateInfo, workflowMetadataQuery, sleep, setHandler, defineQuery, defineSignal, defineUpdate, executeChild, startChild, type ChildWorkflowHandle, type ChildWorkflowOptions, extractWorkflowType, upsertMemo, upsertSearchAttributes, patched, deprecatePatch, addDefaultWorkflowOptions, uuid4, isCancellation, type CommonWorkflowOptions, scheduleActivity, scheduleLocalActivity, proxyActivities, proxyLocalActivities, proxySinks, inWorkflowContext, CancellationScope, type CancellationScopeOptions, type WorkflowInterceptorsFactory, Trigger, getExternalWorkflowHandle, DeterminismViolationError, WorkflowError, ApplicationFailure, ChildWorkflowFailure, ServerFailure, TimeoutFailure, ActivityFailure, CancelledFailure, TerminatedFailure, TemporalFailure, } from '@temporalio/workflow';
+export { buildActivitiesProxy } from './activities';
+export * from './interceptors';
+export declare function isNonRetryableFailure(err: unknown): err is ActivityFailure;

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

@@ -0,0 +1,20 @@
+import { Client, ScheduleOptions, ScheduleUpdateOptions } from '@temporalio/client';
+import { EnvService } from '@diia-inhouse/env';
+import { Logger, OnInit } from '@diia-inhouse/types';
+import { TemporalConfig } from '../interfaces/config';
+export declare class TemporalClient implements OnInit {
+    private readonly config;
+    private readonly envService;
+    private readonly logger;
+    nativeClient: Client;
+    private readonly defaultTimezone;
+    constructor(config: TemporalConfig, envService: EnvService, logger: Logger);
+    get connection(): Client['connection'];
+    get workflow(): Client['workflow'];
+    get workflowService(): Client['workflowService'];
+    get schedule(): Client['schedule'];
+    get taskQueue(): Client['taskQueue'];
+    onInit(): Promise<void>;
+    syncSchedules(schedules: Record<string, ((config: TemporalConfig) => ScheduleOptions) | ScheduleOptions>): Promise<void>;
+    updateSchedule(scheduleId: string, updateData: ScheduleUpdateOptions): Promise<void>;
+}

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

@@ -0,0 +1,2 @@
+export * from './client';
+export * from './worker';

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

@@ -0,0 +1 @@
+export declare function buildWorkerIdentity(taskQueue: string, identityOverride?: string): string;

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

@@ -0,0 +1 @@
+export * from './identity';

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

@@ -0,0 +1,113 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Worker = exports.bundleWorkflowCode = exports.Runtime = exports.NativeConnection = void 0;
+var worker_1 = require("@temporalio/worker");
+Object.defineProperty(exports, "NativeConnection", { enumerable: true, get: function () { return worker_1.NativeConnection; } });
+Object.defineProperty(exports, "Runtime", { enumerable: true, get: function () { return worker_1.Runtime; } });
+Object.defineProperty(exports, "bundleWorkflowCode", { enumerable: true, get: function () { return worker_1.bundleWorkflowCode; } });
+Object.defineProperty(exports, "Worker", { enumerable: true, get: function () { return worker_1.Worker; } });
+__exportStar(require("./interceptors"), exports);
+__exportStar(require("./services/worker"), exports);
+//# sourceMappingURL=worker.js.map

package/dist/worker.js.map

@@ -0,0 +1 @@
+{"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"}