@diia-inhouse/workflow 1.17.7 → 2.5.0

package/dist/interfaces/services/schedulesExporter.d.ts

@@ -0,0 +1,96 @@
+import { Logger } from "@diia-inhouse/types";
+import { Client } from "@temporalio/client";
+
+//#region src/interfaces/services/schedulesExporter.d.ts
+interface SchedulesExporterConfig {
+  /**
+  * Polling interval for `client.schedule.list()` and `describe()`. Default 30s.
+  */
+  pollIntervalMs?: number;
+  /**
+  * Polling interval for the visibility query that powers `diia_workflows_running`.
+  * Default 10s. Ignored when `pollVisibility` is `false`.
+  */
+  visibilityPollIntervalMs?: number;
+  /**
+  * If `false`, skip the visibility query (`workflow.list({ status=Running })`). Use this
+  * when the Temporal cluster does not have advanced visibility (Elasticsearch) enabled.
+  * Default `true`.
+  */
+  pollVisibility?: boolean;
+  /**
+  * How many upcoming fire times to expose per schedule as `slot=0..N-1` gauges.
+  * Default 5.
+  */
+  nextActionSlots?: number;
+  /**
+  * Maximum number of recent action events kept in memory for the `getRecentActions()`
+  * snapshot. Default 200.
+  */
+  recentActionsHistorySize?: number;
+  /**
+  * If `false`, skip the completed-executions query that powers `diia_workflow_duration_seconds`.
+  * Default `true`. Disable when you have no advanced visibility, or when duration
+  * tracking is handled elsewhere (e.g. via the SDK's `workflow_endtoend_latency` metric).
+  */
+  pollCompletions?: boolean;
+  /**
+  * Polling interval for the completed-executions query. Default 60s.
+  */
+  completionsPollIntervalMs?: number;
+  /**
+  * How far back the FIRST completions poll looks (subsequent polls use a sliding window
+  * based on the previous poll time). Set this to roughly the histogram retention you want
+  * after a fresh restart. Default 1h.
+  */
+  completionsLookbackMs?: number;
+  /**
+  * Maximum number of recently-observed completed run IDs kept in memory for de-duplication
+  * across overlapping polls. LRU-trimmed. Default 2000.
+  */
+  completionsSeenCapacity?: number;
+}
+interface SchedulesExporterDeps {
+  /**
+  * Temporal client used to call `schedule.list`, `schedule.getHandle().describe`, and
+  * `workflow.list`. Typed as `Pick<Client, 'schedule' | 'workflow'>` so this interface
+  * stays decoupled from the `TemporalClient` wrapper class (avoids a cycle through
+  * `interfaces/config.ts`); the wrapper's `schedule`/`workflow` getters satisfy this shape.
+  */
+  client: Pick<Client, "schedule" | "workflow">;
+  /**
+  * The worker's task queue. Schedules whose `action.taskQueue` does not match are
+  * ignored — this guarantees each service emits metrics only for the schedules it owns.
+  */
+  taskQueue: string;
+  logger?: Logger;
+}
+/**
+* Single upcoming schedule fire returned by `SchedulesExporter.getCalendarEvents()`.
+* Each schedule contributes up to `nextActionSlots` events, ordered by `slot` ascending
+* (slot 0 is the next fire).
+*/
+interface ScheduleCalendarEvent {
+  scheduleId: string;
+  workflowType: string;
+  taskQueue: string;
+  cadence: string;
+  slot: number;
+  fireAt: string;
+  fireAtMs: number;
+  paused: number;
+  lastSucceeded: number | null;
+}
+/**
+* Single recent schedule action returned by `SchedulesExporter.getRecentActions()`.
+*/
+interface ScheduleRecentAction {
+  scheduleId: string;
+  workflowType: string;
+  taskQueue: string;
+  firedAt: string;
+  firedAtMs: number;
+  succeeded: number;
+}
+//#endregion
+export { ScheduleCalendarEvent, ScheduleRecentAction, SchedulesExporterConfig, SchedulesExporterDeps };

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

@@ -0,0 +1,60 @@
+import { WorkerOptions, WorkerStatus } from "@temporalio/worker";
+
+//#region src/interfaces/services/worker.d.ts
+/**
+* Structural type for the OpenTelemetry tracer provider that pkg-workflow accepts.
+*
+* pkg-workflow only needs the `service.name` resource attribute. By matching that
+* shape structurally (instead of importing `NodeTracerProvider` from a pinned
+* `@opentelemetry/sdk-trace-node` major), we accept providers from both OTel 1.x
+* (where `resource` is a public field) and OTel 2.x (where it is private and the
+* value is read defensively at runtime).
+*
+* `getTracer` is required because it is the only public member shared by both
+* OTel majors — without it TypeScript's weak-type check rejects 2.x providers
+* (whose other state is private).
+*/
+interface NodeTracerProviderLike {
+  getTracer(name: string, version?: string, options?: {
+    schemaUrl?: string;
+  }): unknown;
+  resource?: {
+    attributes?: Record<string, unknown>;
+  };
+}
+type WorkerStatusProvider = () => WorkerStatus;
+type ActivityClass = new (...args: any[]) => any;
+interface WorkerBootstrapOptions extends Omit<WorkerOptions, "taskQueue" | "activities" | "workflowsPath"> {
+  /**
+  * Path to the workflows module. Accepts either an absolute filesystem path
+  * or a `file://` URL (e.g. from `import.meta.resolve('./worker/workflows/index.js')`).
+  */
+  workflowsPath: string;
+  activities: Record<string, ActivityClass>;
+  nodeTracerProvider?: NodeTracerProviderLike;
+  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;
+}
+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>;
+  }>;
+}
+//#endregion
+export { ActivityClass, App, NodeTracerProviderLike, WorkerBootstrapOptions, WorkerStatusProvider };

package/dist/operations.d.ts

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

package/dist/operations.js

@@ -1,77 +1,13 @@
-"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.buildActivitiesProxy = exports.TemporalFailure = exports.TerminatedFailure = exports.CancelledFailure = exports.ActivityFailure = exports.TimeoutFailure = exports.ServerFailure = exports.ChildWorkflowFailure = exports.ApplicationFailure = exports.WorkflowError = exports.DeterminismViolationError = exports.getExternalWorkflowHandle = exports.Trigger = exports.CancellationScope = exports.inWorkflowContext = exports.proxySinks = exports.proxyLocalActivities = exports.proxyActivities = exports.scheduleLocalActivity = exports.scheduleActivity = exports.isCancellation = exports.uuid4 = exports.addDefaultWorkflowOptions = exports.deprecatePatch = exports.patched = exports.upsertSearchAttributes = exports.upsertMemo = exports.extractWorkflowType = exports.startChild = exports.executeChild = exports.defineUpdate = exports.defineSignal = exports.defineQuery = exports.setHandler = exports.sleep = exports.workflowMetadataQuery = exports.currentUpdateInfo = exports.workflowInfo = exports.log = exports.setDefaultSignalHandler = exports.ContinueAsNew = exports.makeContinueAsNewFunc = exports.continueAsNew = exports.condition = exports.allHandlersFinished = void 0;
-exports.isNonRetryableFailure = isNonRetryableFailure;
-const common_1 = require("@temporalio/common");
-var workflow_1 = require("@temporalio/workflow");
-Object.defineProperty(exports, "allHandlersFinished", { enumerable: true, get: function () { return workflow_1.allHandlersFinished; } });
-Object.defineProperty(exports, "condition", { enumerable: true, get: function () { return workflow_1.condition; } });
-Object.defineProperty(exports, "continueAsNew", { enumerable: true, get: function () { return workflow_1.continueAsNew; } });
-Object.defineProperty(exports, "makeContinueAsNewFunc", { enumerable: true, get: function () { return workflow_1.makeContinueAsNewFunc; } });
-Object.defineProperty(exports, "ContinueAsNew", { enumerable: true, get: function () { return workflow_1.ContinueAsNew; } });
-Object.defineProperty(exports, "setDefaultSignalHandler", { enumerable: true, get: function () { return workflow_1.setDefaultSignalHandler; } });
-Object.defineProperty(exports, "log", { enumerable: true, get: function () { return workflow_1.log; } });
-Object.defineProperty(exports, "workflowInfo", { enumerable: true, get: function () { return workflow_1.workflowInfo; } });
-Object.defineProperty(exports, "currentUpdateInfo", { enumerable: true, get: function () { return workflow_1.currentUpdateInfo; } });
-Object.defineProperty(exports, "workflowMetadataQuery", { enumerable: true, get: function () { return workflow_1.workflowMetadataQuery; } });
-Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return workflow_1.sleep; } });
-Object.defineProperty(exports, "setHandler", { enumerable: true, get: function () { return workflow_1.setHandler; } });
-Object.defineProperty(exports, "defineQuery", { enumerable: true, get: function () { return workflow_1.defineQuery; } });
-Object.defineProperty(exports, "defineSignal", { enumerable: true, get: function () { return workflow_1.defineSignal; } });
-Object.defineProperty(exports, "defineUpdate", { enumerable: true, get: function () { return workflow_1.defineUpdate; } });
-Object.defineProperty(exports, "executeChild", { enumerable: true, get: function () { return workflow_1.executeChild; } });
-Object.defineProperty(exports, "startChild", { enumerable: true, get: function () { return workflow_1.startChild; } });
-Object.defineProperty(exports, "extractWorkflowType", { enumerable: true, get: function () { return workflow_1.extractWorkflowType; } });
-Object.defineProperty(exports, "upsertMemo", { enumerable: true, get: function () { return workflow_1.upsertMemo; } });
-Object.defineProperty(exports, "upsertSearchAttributes", { enumerable: true, get: function () { return workflow_1.upsertSearchAttributes; } });
-Object.defineProperty(exports, "patched", { enumerable: true, get: function () { return workflow_1.patched; } });
-Object.defineProperty(exports, "deprecatePatch", { enumerable: true, get: function () { return workflow_1.deprecatePatch; } });
-Object.defineProperty(exports, "addDefaultWorkflowOptions", { enumerable: true, get: function () { return workflow_1.addDefaultWorkflowOptions; } });
-Object.defineProperty(exports, "uuid4", { enumerable: true, get: function () { return workflow_1.uuid4; } });
-Object.defineProperty(exports, "isCancellation", { enumerable: true, get: function () { return workflow_1.isCancellation; } });
-Object.defineProperty(exports, "scheduleActivity", { enumerable: true, get: function () { return workflow_1.scheduleActivity; } });
-Object.defineProperty(exports, "scheduleLocalActivity", { enumerable: true, get: function () { return workflow_1.scheduleLocalActivity; } });
-Object.defineProperty(exports, "proxyActivities", { enumerable: true, get: function () { return workflow_1.proxyActivities; } });
-Object.defineProperty(exports, "proxyLocalActivities", { enumerable: true, get: function () { return workflow_1.proxyLocalActivities; } });
-Object.defineProperty(exports, "proxySinks", { enumerable: true, get: function () { return workflow_1.proxySinks; } });
-Object.defineProperty(exports, "inWorkflowContext", { enumerable: true, get: function () { return workflow_1.inWorkflowContext; } });
-Object.defineProperty(exports, "CancellationScope", { enumerable: true, get: function () { return workflow_1.CancellationScope; } });
-Object.defineProperty(exports, "Trigger", { enumerable: true, get: function () { return workflow_1.Trigger; } });
-Object.defineProperty(exports, "getExternalWorkflowHandle", { enumerable: true, get: function () { return workflow_1.getExternalWorkflowHandle; } });
-Object.defineProperty(exports, "DeterminismViolationError", { enumerable: true, get: function () { return workflow_1.DeterminismViolationError; } });
-Object.defineProperty(exports, "WorkflowError", { enumerable: true, get: function () { return workflow_1.WorkflowError; } });
-Object.defineProperty(exports, "ApplicationFailure", { enumerable: true, get: function () { return workflow_1.ApplicationFailure; } });
-Object.defineProperty(exports, "ChildWorkflowFailure", { enumerable: true, get: function () { return workflow_1.ChildWorkflowFailure; } });
-Object.defineProperty(exports, "ServerFailure", { enumerable: true, get: function () { return workflow_1.ServerFailure; } });
-Object.defineProperty(exports, "TimeoutFailure", { enumerable: true, get: function () { return workflow_1.TimeoutFailure; } });
-Object.defineProperty(exports, "ActivityFailure", { enumerable: true, get: function () { return workflow_1.ActivityFailure; } });
-Object.defineProperty(exports, "CancelledFailure", { enumerable: true, get: function () { return workflow_1.CancelledFailure; } });
-Object.defineProperty(exports, "TerminatedFailure", { enumerable: true, get: function () { return workflow_1.TerminatedFailure; } });
-Object.defineProperty(exports, "TemporalFailure", { enumerable: true, get: function () { return workflow_1.TemporalFailure; } });
-var activities_1 = require("./activities");
-Object.defineProperty(exports, "buildActivitiesProxy", { enumerable: true, get: function () { return activities_1.buildActivitiesProxy; } });
-__exportStar(require("./interceptors"), exports);
+import { buildActivitiesProxy } from "./activities/proxy.js";
+import "./activities/index.js";
+import { workflowInterceptors } from "./interceptors.js";
+import { ActivityFailure as ActivityFailure$1, ApplicationFailure as ApplicationFailure$1, RetryState } from "@temporalio/common";
+import { ActivityFailure, ApplicationFailure, CancellationScope, CancelledFailure, ChildWorkflowFailure, ContinueAsNew, DeterminismViolationError, ServerFailure, TemporalFailure, TerminatedFailure, TimeoutFailure, Trigger, WorkflowError, addDefaultWorkflowOptions, allHandlersFinished, condition, continueAsNew, currentUpdateInfo, defineQuery, defineSignal, defineUpdate, deprecatePatch, executeChild, extractWorkflowType, getExternalWorkflowHandle, inWorkflowContext, isCancellation, log, makeContinueAsNewFunc, patched, proxyActivities, proxyLocalActivities, proxySinks, scheduleActivity, scheduleLocalActivity, setDefaultSignalHandler, setHandler, sleep, startChild, upsertMemo, upsertSearchAttributes, uuid4, workflowInfo, workflowMetadataQuery } from "@temporalio/workflow";
+//#region src/operations.ts
 function isNonRetryableFailure(err) {
-    if (!(err instanceof common_1.ActivityFailure)) {
-        return false;
-    }
-    if (err.retryState === common_1.RetryState.RETRY_POLICY_NOT_SET || err.retryState === common_1.RetryState.MAXIMUM_ATTEMPTS_REACHED) {
-        return true;
-    }
-    return err.cause instanceof common_1.ApplicationFailure && Boolean(err.cause.nonRetryable);
+	if (!(err instanceof ActivityFailure$1)) return false;
+	if (err.retryState === RetryState.RETRY_POLICY_NOT_SET || err.retryState === RetryState.MAXIMUM_ATTEMPTS_REACHED) return true;
+	return err.cause instanceof ApplicationFailure$1 && Boolean(err.cause.nonRetryable);
 }
-//# sourceMappingURL=operations.js.map
+//#endregion
+export { ActivityFailure, ApplicationFailure, CancellationScope, CancelledFailure, ChildWorkflowFailure, ContinueAsNew, DeterminismViolationError, ServerFailure, TemporalFailure, TerminatedFailure, TimeoutFailure, Trigger, WorkflowError, addDefaultWorkflowOptions, allHandlersFinished, buildActivitiesProxy, condition, continueAsNew, currentUpdateInfo, defineQuery, defineSignal, defineUpdate, deprecatePatch, executeChild, extractWorkflowType, getExternalWorkflowHandle, inWorkflowContext, isCancellation, isNonRetryableFailure, log, makeContinueAsNewFunc, patched, proxyActivities, proxyLocalActivities, proxySinks, scheduleActivity, scheduleLocalActivity, setDefaultSignalHandler, setHandler, sleep, startChild, upsertMemo, upsertSearchAttributes, uuid4, workflowInfo, workflowInterceptors, workflowMetadataQuery };

package/dist/services/client.d.ts

@@ -0,0 +1,24 @@
+import { TemporalConfig } from "../interfaces/config.js";
+import { EnvService } from "@diia-inhouse/env";
+import { Logger, OnInit } from "@diia-inhouse/types";
+import { Client, ScheduleOptions, ScheduleUpdateOptions } from "@temporalio/client";
+
+//#region src/services/client.d.ts
+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>;
+}
+//#endregion
+export { TemporalClient };

package/dist/services/client.js

@@ -1,96 +1,89 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemporalClient = void 0;
-const client_1 = require("@temporalio/client");
-const client_2 = require("@temporalio/interceptors-opentelemetry/lib/client");
-const lodash_1 = require("lodash");
-const env_1 = require("@diia-inhouse/env");
-const dataConverter_1 = require("../encryption/dataConverter");
-class TemporalClient {
-    config;
-    envService;
-    logger;
-    nativeClient;
-    defaultTimezone = 'Europe/Kyiv';
-    constructor(config, envService, logger) {
-        this.config = config;
-        this.envService = envService;
-        this.logger = logger;
-    }
-    get connection() {
-        return this.nativeClient.connection;
-    }
-    get workflow() {
-        return this.nativeClient.workflow;
-    }
-    get workflowService() {
-        return this.nativeClient.workflowService;
-    }
-    get schedule() {
-        return this.nativeClient.schedule;
-    }
-    get taskQueue() {
-        return this.nativeClient.taskQueue;
-    }
-    async onInit() {
-        const { address, tls, connectTimeout, encryptionEnabled, encryptionKeyId, encryptionKeyRefreshInterval, ...clientConfig } = this.config;
-        const connection = await client_1.Connection.connect({ address, tls, connectTimeout }).catch((err) => {
-            this.logger.error('Failed to connect to Temporal', { err });
-            throw new Error('Failed to connect to Temporal', { cause: err });
-        });
-        const dataConverter = encryptionEnabled
-            ? await (0, dataConverter_1.getDataConverter)(encryptionKeyId, this.envService, encryptionKeyRefreshInterval)
-            : undefined;
-        const interceptors = env_1.EnvService.getVar('TRACING_ENABLED', 'boolean', false)
-            ? { workflow: [new client_2.OpenTelemetryWorkflowClientInterceptor()] }
-            : undefined;
-        this.nativeClient = new client_1.Client({ ...clientConfig, connection, dataConverter, interceptors });
-    }
-    async syncSchedules(schedules) {
-        const applicationSchedules = Object.entries(schedules).map(([, schedule]) => typeof schedule === 'function' ? schedule(this.config) : schedule);
-        const temporalSchedules = [];
-        for await (const schedule of this.schedule.list()) {
-            if (schedule.memo?.TaskQueue === this.config.taskQueue) {
-                temporalSchedules.push(schedule);
-            }
-        }
-        const schedulesToCreate = applicationSchedules.filter((scheduleOptions) => !temporalSchedules.some((schedule) => schedule.scheduleId === scheduleOptions.scheduleId));
-        for (const scheduleOptions of schedulesToCreate) {
-            scheduleOptions.memo = {
-                ...scheduleOptions.memo,
-                TaskQueue: scheduleOptions.action.taskQueue,
-            };
-            if (!scheduleOptions.spec.timezone) {
-                scheduleOptions.spec.timezone = this.defaultTimezone;
-            }
-            await this.schedule.create(scheduleOptions);
-        }
-        if (schedulesToCreate.length > 0) {
-            this.logger.info(`Schedules created (${schedulesToCreate.length}): ${schedulesToCreate.map((schedule) => schedule.scheduleId).join(', ')}`);
-        }
-        const schedulesToDelete = temporalSchedules.filter((schedule) => !applicationSchedules.some((scheduleOptions) => scheduleOptions.scheduleId === schedule.scheduleId));
-        for (const schedule of schedulesToDelete) {
-            const handle = this.schedule.getHandle(schedule.scheduleId);
-            await handle.delete();
-        }
-        if (schedulesToDelete.length > 0) {
-            this.logger.info(`Schedules deleted (${schedulesToDelete.length}): ${schedulesToDelete.map((schedule) => schedule.scheduleId).join(', ')}`);
-        }
-    }
-    async updateSchedule(scheduleId, updateData) {
-        try {
-            const scheduleHandle = this.schedule.getHandle(scheduleId);
-            this.logger.info('Schedule update details:', { scheduleId, updateData });
-            await scheduleHandle.update((previous) => {
-                return (0, lodash_1.merge)(previous, updateData);
-            });
-            this.logger.info('Successfully updated temporal schedule', { scheduleId });
-        }
-        catch (err) {
-            this.logger.error('Failed to update temporal schedule', { err });
-            throw err;
-        }
-    }
-}
-exports.TemporalClient = TemporalClient;
-//# sourceMappingURL=client.js.map
+import { getDataConverter } from "../encryption/dataConverter.js";
+import { EnvService } from "@diia-inhouse/env";
+import { Client, Connection } from "@temporalio/client";
+import { OpenTelemetryWorkflowClientInterceptor } from "@temporalio/interceptors-opentelemetry/lib/client/index.js";
+import lodash from "lodash";
+//#region src/services/client.ts
+const { merge } = lodash;
+var TemporalClient = class {
+	config;
+	envService;
+	logger;
+	nativeClient;
+	defaultTimezone = "Europe/Kyiv";
+	constructor(config, envService, logger) {
+		this.config = config;
+		this.envService = envService;
+		this.logger = logger;
+	}
+	get connection() {
+		return this.nativeClient.connection;
+	}
+	get workflow() {
+		return this.nativeClient.workflow;
+	}
+	get workflowService() {
+		return this.nativeClient.workflowService;
+	}
+	get schedule() {
+		return this.nativeClient.schedule;
+	}
+	get taskQueue() {
+		return this.nativeClient.taskQueue;
+	}
+	async onInit() {
+		const { address, tls, connectTimeout, encryptionEnabled, encryptionKeyId, encryptionKeyRefreshInterval, ...clientConfig } = this.config;
+		const connection = await Connection.connect({
+			address,
+			tls,
+			connectTimeout
+		}).catch((err) => {
+			this.logger.error("Failed to connect to Temporal", { err });
+			throw new Error("Failed to connect to Temporal", { cause: err });
+		});
+		const dataConverter = encryptionEnabled ? await getDataConverter(encryptionKeyId, this.envService, encryptionKeyRefreshInterval) : void 0;
+		const interceptors = EnvService.getVar("TRACING_ENABLED", "boolean", false) ? { workflow: [new OpenTelemetryWorkflowClientInterceptor()] } : void 0;
+		this.nativeClient = new Client({
+			...clientConfig,
+			connection,
+			dataConverter,
+			interceptors
+		});
+	}
+	async syncSchedules(schedules) {
+		const applicationSchedules = Object.entries(schedules).map(([, schedule]) => typeof schedule === "function" ? schedule(this.config) : schedule);
+		const temporalSchedules = [];
+		for await (const schedule of this.schedule.list()) if (schedule.memo?.TaskQueue === this.config.taskQueue) temporalSchedules.push(schedule);
+		const schedulesToCreate = applicationSchedules.filter((scheduleOptions) => !temporalSchedules.some((schedule) => schedule.scheduleId === scheduleOptions.scheduleId));
+		for (const scheduleOptions of schedulesToCreate) {
+			scheduleOptions.memo = {
+				...scheduleOptions.memo,
+				TaskQueue: scheduleOptions.action.taskQueue
+			};
+			if (!scheduleOptions.spec.timezone) scheduleOptions.spec.timezone = this.defaultTimezone;
+			await this.schedule.create(scheduleOptions);
+		}
+		if (schedulesToCreate.length > 0) this.logger.info(`Schedules created (${schedulesToCreate.length}): ${schedulesToCreate.map((schedule) => schedule.scheduleId).join(", ")}`);
+		const schedulesToDelete = temporalSchedules.filter((schedule) => !applicationSchedules.some((scheduleOptions) => scheduleOptions.scheduleId === schedule.scheduleId));
+		for (const schedule of schedulesToDelete) await this.schedule.getHandle(schedule.scheduleId).delete();
+		if (schedulesToDelete.length > 0) this.logger.info(`Schedules deleted (${schedulesToDelete.length}): ${schedulesToDelete.map((schedule) => schedule.scheduleId).join(", ")}`);
+	}
+	async updateSchedule(scheduleId, updateData) {
+		try {
+			const scheduleHandle = this.schedule.getHandle(scheduleId);
+			this.logger.info("Schedule update details:", {
+				scheduleId,
+				updateData
+			});
+			await scheduleHandle.update((previous) => {
+				return merge(previous, updateData);
+			});
+			this.logger.info("Successfully updated temporal schedule", { scheduleId });
+		} catch (err) {
+			this.logger.error("Failed to update temporal schedule", { err });
+			throw err;
+		}
+	}
+};
+//#endregion
+export { TemporalClient };

package/dist/services/schedulesExporter.d.ts

@@ -0,0 +1,101 @@
+import { ScheduleCalendarEvent, ScheduleRecentAction, SchedulesExporterConfig, SchedulesExporterDeps } from "../interfaces/services/schedulesExporter.js";
+import { OnDestroy, OnInit } from "@diia-inhouse/types";
+
+//#region src/services/schedulesExporter.d.ts
+/**
+* Periodically polls the Temporal Schedule and Visibility APIs, exposing per-schedule and
+* per-workflow-type business metrics that the SDK does not provide out of the box:
+*
+* - `diia_schedule_paused` (0/1)
+* - `diia_schedule_last_action_age_seconds`
+* - `diia_schedule_last_action_succeeded` (0/1)
+* - `diia_schedule_next_action_at_seconds{slot}` — Unix seconds of upcoming fire
+* - `diia_schedule_next_action_eta_seconds{slot}` — seconds from now until upcoming fire
+
+* - `diia_schedule_cadence_seconds` — approximate gap between fires (slot1 − slot0, falls back to spec)
+* - `diia_schedule_fires_total{result="ok"|"failed"}` — counter of observed schedule fires; pair
+*   with cadence to compute expected/day and detect missed runs
+* - `diia_workflows_running` — count of executions in `Running` state for this task queue
+* - `diia_workflows_oldest_running_age_seconds` — age of the oldest running workflow
+*
+* The `service` label is supplied by the `diia-metrics` default labels at scrape time, so it
+* is intentionally absent from the metric labelNames.
+*
+* Schedules with `action.taskQueue` other than `deps.taskQueue` are ignored, so a service
+* only emits metrics for schedules it actually owns. This avoids fan-out when many services
+* share a Temporal namespace.
+*
+* The exporter does NOT run its own HTTP server. Metrics flow through the existing
+* `diia-metrics` `/metrics` endpoint. If a service needs to expose the calendar event list
+* or recent action feed as JSON (e.g. for a Grafana Infinity datasource), it should call
+* {@link SchedulesExporter.getCalendarEvents} and {@link SchedulesExporter.getRecentActions}
+* from a route on its existing HTTP framework.
+*/
+declare class SchedulesExporter implements OnInit, OnDestroy {
+  private readonly deps;
+  private readonly pollIntervalMs;
+  private readonly visibilityPollIntervalMs;
+  private readonly pollVisibility;
+  private readonly nextActionSlots;
+  private readonly historySize;
+  private readonly logger;
+  private readonly calendarEvents;
+  private readonly recentActionsLog;
+  private readonly paused;
+  private readonly lastActionAge;
+  private readonly lastActionSucceeded;
+  private readonly nextActionAt;
+  private readonly nextActionEta;
+  private readonly cadence;
+  private readonly running;
+  private readonly oldestRunningAge;
+  private readonly firesTotal;
+  private readonly workflowDuration;
+  private readonly seenCompletedRunIds;
+  private readonly seenCompletedRunIdSet;
+  private readonly seenActionKeys;
+  private readonly seenActionKeySet;
+  private static readonly ACTIONS_SEEN_CAPACITY;
+  private readonly lastSeenScheduleLabels;
+  private readonly pollCompletions;
+  private readonly completionsPollIntervalMs;
+  private readonly completionsLookbackMs;
+  private readonly completionsSeenCapacity;
+  private completionsLastPollMs;
+  private scheduleTimer;
+  private visibilityTimer;
+  private completionsTimer;
+  private schedulesPolling;
+  private runningPolling;
+  private completionsPolling;
+  private activeSchedulesPoll;
+  private activeRunningPoll;
+  private activeCompletionsPoll;
+  private stopped;
+  constructor(deps: SchedulesExporterDeps, config?: SchedulesExporterConfig);
+  onInit(): Promise<void>;
+  onDestroy(): Promise<void>;
+  private armSchedulesTimer;
+  private armVisibilityTimer;
+  private armCompletionsTimer;
+  private runSchedulesPoll;
+  private runRunningPoll;
+  private runCompletionsPoll;
+  /**
+  * Snapshot of the next-N upcoming fires across all tracked schedules.
+  * Each schedule contributes up to `nextActionSlots` events, ordered by `slot`.
+  * Mount on a service HTTP route to feed the Grafana Business Calendar panel via the
+  * Infinity datasource — the data shape is already calendar-event-shaped.
+  */
+  getCalendarEvents(): readonly ScheduleCalendarEvent[];
+  /**
+  * Snapshot of the most recent schedule actions across all tracked schedules,
+  * ordered newest first. Capped at `recentActionsHistorySize` entries.
+  */
+  getRecentActions(limit?: number): readonly ScheduleRecentAction[];
+  private pollSchedules;
+  private pollRunning;
+  private pollCompleted;
+}
+//#endregion
+export { SchedulesExporter };