@geniehr/utilities 1.0.16 → 1.0.17

package/dist/conductor/ConductorClient.d.ts

@@ -3,9 +3,11 @@ export declare class ConductorClient {
     private workers;
     constructor(serviceName?: string);
     startWorkflow(name: string, input: any, correlationId?: string, version?: number): Promise<any>;
+    executeWorkflow(name: string, input: any, correlationId?: string, version?: number, timeout?: number): Promise<any>;
     registerWorker(taskType: string, execute: (input: any) => Promise<any>, pollInterval?: number, domain?: string): Promise<void>;
     private poll;
     updateTask(taskId: string, workflowInstanceId: string, status: string, outputData: any, reasonForIncompletion?: string): Promise<void>;
     getTask(workflowInstanceId: string, taskReferenceName: string): Promise<any>;
     getWorkflow(workflowInstanceId: string, includeTasks?: boolean): Promise<any>;
+    getWorkflowStatus(workflowInstanceId: string): Promise<string>;
 }

package/dist/conductor/ConductorClient.js

@@ -31,6 +31,41 @@ export class ConductorClient {
             throw error;
         }
     }
+    async executeWorkflow(name, input, correlationId, version, timeout = 30000) {
+        try {
+            // 1. Start the workflow
+            const startTime = Date.now();
+            const workflowId = await this.startWorkflow(name, input, correlationId, version);
+            console.log(`[${correlationId}] Started workflow ${name} (ID: ${workflowId})`);
+            // 2. Poll for completion with exponential backoff
+            let pollCount = 0;
+            let pollInterval = 50; // Start at 50ms
+            const maxInterval = 1000; // Cap at 1 second
+            while (Date.now() - startTime < timeout) {
+                pollCount++;
+                const elapsed = Date.now() - startTime;
+                // Use lightweight status check
+                const status = await this.getWorkflowStatus(workflowId);
+                if (status === 'COMPLETED') {
+                    console.log(`[${correlationId}] Workflow completed in ${elapsed}ms after ${pollCount} polls`);
+                    // Fetch full workflow only on completion
+                    return await this.getWorkflow(workflowId, true);
+                }
+                if (['FAILED', 'TERMINATED', 'PAUSED'].includes(status)) {
+                    const workflow = await this.getWorkflow(workflowId, true);
+                    throw new Error(`Workflow execution failed with status: ${workflow.status}. Reason: ${workflow.reasonForIncompletion}`);
+                }
+                // Exponential backoff
+                await new Promise(resolve => setTimeout(resolve, pollInterval));
+                pollInterval = Math.min(pollInterval * 1.5, maxInterval);
+            }
+            throw new Error(`Workflow execution timed out after ${timeout}ms`);
+        }
+        catch (error) {
+            console.error(`Error executing synchronous workflow ${name}:`, error.message);
+            throw error;
+        }
+    }
     async registerWorker(taskType, execute, pollInterval = 1000, domain) {
         if (this.workers[taskType]) {
             console.warn(`Worker for ${taskType} already registered.`);
@@ -43,18 +78,21 @@ export class ConductorClient {
     async poll(taskType, execute, interval, domain) {
         while (this.workers[taskType]) {
             try {
-                // Poll for a task
-                // GET /tasks/poll/{taskType}?workerid=...&domain=...
+                // Poll for a task with long polling enabled
                 const workerId = `worker-${process.pid}`;
+                const pollStart = Date.now();
                 const response = await this.client.get(`/tasks/poll/${taskType}`, {
                     params: {
                         workerid: workerId,
-                        domain
+                        domain,
+                        count: 1,
+                        timeout: 5000 // Enable long polling (5s)
                     }
                 });
                 const task = response.data;
                 if (task && task.taskId) {
-                    console.log(`Received task ${taskType} (ID: ${task.taskId})`);
+                    const pickupLatency = Date.now() - pollStart;
+                    console.log(`Received task ${taskType} (ID: ${task.taskId}) after ${pickupLatency}ms`);
                     let status = 'COMPLETED';
                     let outputData = {};
                     let reasonForIncompletion = '';
@@ -69,13 +107,12 @@ export class ConductorClient {
                     // Update task status
                     await this.updateTask(task.taskId, task.workflowInstanceId, status, outputData, reasonForIncompletion);
                 }
+                // No sleep here - long-polling handles the wait
             }
             catch (error) {
-                // If polling fails (e.g. 204 No Content or connection error), just log debug/warn and wait
-                // console.debug(`Polling error for ${taskType}: ${error}`);
+                // On error, wait briefly before retry
+                await new Promise(resolve => setTimeout(resolve, 500));
             }
-            // Wait before next poll
-            await new Promise(resolve => setTimeout(resolve, interval));
         }
     }
     async updateTask(taskId, workflowInstanceId, status, outputData, reasonForIncompletion) {
@@ -117,4 +154,20 @@ export class ConductorClient {
             throw error;
         }
     }
+    async getWorkflowStatus(workflowInstanceId) {
+        try {
+            // Try status-only endpoint first (may not exist in all Conductor versions)
+            const response = await this.client.get(`/workflow/${workflowInstanceId}/status`);
+            return response.data.status;
+        }
+        catch (error) {
+            // Fallback to full workflow fetch with minimal data if status endpoint doesn't exist
+            if (error.response?.status === 404 || error.response?.status === 405) {
+                const workflow = await this.getWorkflow(workflowInstanceId, false);
+                return workflow.status;
+            }
+            console.error(`Error getting workflow status:`, error.message);
+            throw error;
+        }
+    }
 }

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { validateRequest } from './schema/validation.js';
 export { MQClient } from './mq/client.js';
 export { getContext, setExtras, setContext } from './shared/context/index.js';
+export { GHRContext } from './types/GHRContext.js';
 export { LoggerService as Logger } from './logger/LoggerService.js';
 export { HttpStatusCode } from './shared/enums/HttpStatusCodes.js';
 export { InvalidRequestException, InvalidEnvironmentException, AppException } from './shared/exceptions/index.js';

package/dist/types/GHRContext.d.ts

@@ -1,4 +1,5 @@
 import type { MQClient } from '../mq/client.js';
+import type { ConductorClient } from '../conductor/ConductorClient.js';
 import Redis from 'ioredis';
 export type GHRContext<TPrismaClient = any> = {
     service?: string;
@@ -7,5 +8,6 @@ export type GHRContext<TPrismaClient = any> = {
     prisma?: TPrismaClient;
     redis?: Redis;
     mongo?: any;
+    conductor?: ConductorClient;
     extras?: Record<string, any>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geniehr/utilities",
-  "version": "1.0.16",
+  "version": "1.0.17",
   "description": "",
   "homepage": "https://github.com/Genie-HR/ghr-utilities#readme",
   "bugs": {