@io-orkes/conductor-javascript 2.2.1 → 2.3.0

package/dist/index.js

@@ -22474,6 +22474,7 @@ __export(index_exports, {
   ConductorSdkError: () => ConductorSdkError,
   Consistency: () => Consistency,
   DefaultLogger: () => DefaultLogger,
+  EventClient: () => EventClient,
   HumanExecutor: () => HumanExecutor,
   MAX_RETRIES: () => MAX_RETRIES,
   MetadataClient: () => MetadataClient,
@@ -23827,6 +23828,70 @@ var EventResource = class {
     });
   }
 };
+var EventExecutionResource = class {
+  /**
+   * Get All active Event Handlers
+   */
+  static getEventHandlersForEvent1(options) {
+    return (options?.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event/execution",
+      ...options
+    });
+  }
+  /**
+   * Get event handlers for a given event
+   */
+  static getEventHandlersForEvent2(options) {
+    return (options.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event/execution/{eventHandlerName}",
+      ...options
+    });
+  }
+};
+var EventMessageResource = class {
+  /**
+   * Get all event handlers with statistics
+   */
+  static getEvents(options) {
+    return (options?.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event/message",
+      ...options
+    });
+  }
+  /**
+   * Get event messages for a given event
+   */
+  static getMessages(options) {
+    return (options.client ?? client).get({
+      security: [
+        {
+          name: "X-Authorization",
+          type: "apiKey"
+        }
+      ],
+      url: "/api/event/message/{event}",
+      ...options
+    });
+  }
+};
 var HumanTask = class {
   /**
    * API for backpopulating index data
@@ -28218,6 +28283,434 @@ var MetadataClient = class {
   }
 };
 
+// src/core/eventClient.ts
+var EventClient = class {
+  _client;
+  constructor(client2) {
+    this._client = client2;
+  }
+  /**
+   * Get all the event handlers
+   * @returns {Promise<EventHandler[]>}
+   * @throws {ConductorSdkError}
+   */
+  async getAllEventHandlers() {
+    try {
+      const { data } = await EventResource.getEventHandlers({
+        client: this._client,
+        throwOnError: true
+      });
+      return data;
+    } catch (error) {
+      handleSdkError(error, `Failed to get all event handlers`);
+    }
+  }
+  /**
+   * Add event handlers
+   * @param {EventHandler[]} eventHandlers
+   * @returns {Promise<void>}
+   * @throws {ConductorSdkError}
+   */
+  async addEventHandlers(eventHandlers) {
+    try {
+      await EventResource.addEventHandler({
+        body: eventHandlers,
+        client: this._client,
+        throwOnError: true
+      });
+    } catch (error) {
+      handleSdkError(error, `Failed to add event handlers`);
+    }
+  }
+  /**
+   * Add an event handler
+   * @param {EventHandler} eventHandler
+   * @returns {Promise<void>}
+   * @throws {ConductorSdkError}
+   */
+  async addEventHandler(eventHandler) {
+    try {
+      await EventResource.addEventHandler({
+        body: [eventHandler],
+        client: this._client,
+        throwOnError: true
+      });
+    } catch (error) {
+      handleSdkError(error, `Failed to add event handler`);
+    }
+  }
+  /**
+   * Update an event handler
+   * @param {EventHandler} eventHandler
+   * @returns {Promise<void>}
+   * @throws {ConductorSdkError}
+   */
+  async updateEventHandler(eventHandler) {
+    try {
+      await EventResource.updateEventHandler({
+        body: eventHandler,
+        client: this._client,
+        throwOnError: true
+      });
+    } catch (error) {
+      handleSdkError(error, `Failed to update event handler`);
+    }
+  }
+  /**
+   * Handle an incoming event
+   * @param {Record<string, string>} data
+   * @returns {Promise<void>}
+   * @throws {ConductorSdkError}
+   */
+  async handleIncomingEvent(data) {
+    try {
+      await EventResource.handleIncomingEvent({
+        body: data,
+        client: this._client,
+        throwOnError: true
+      });
+    } catch (error) {
+      handleSdkError(error, `Failed to handle incoming event`);
+    }
+  }
+  /**
+   * Get an event handler by name
+   * @param {string} eventHandlerName
+   * @returns {Promise<EventHandler>}
+   * @throws {ConductorSdkError}
+   */
+  async getEventHandlerByName(eventHandlerName) {
+    try {
+      const { response, data } = await EventResource.getEventHandlerByName({
+        client: this._client,
+        throwOnError: true,
+        path: { name: eventHandlerName }
+      });
+      if (response.headers.get("content-length") === "0") {
+        throw new Error("Response is empty");
+      }
+      return data;
+    } catch (error) {
+      handleSdkError(
+        error,
+        `Failed to get event handler by name ${eventHandlerName}`
+      );
+    }
+  }
+  /**
+   * Get all queue configs
+   * @returns {Promise<Record<string, string>>}
+   * @throws {ConductorSdkError}
+   */
+  async getAllQueueConfigs() {
+    try {
+      const { data } = await EventResource.getQueueNames({
+        client: this._client,
+        throwOnError: true
+      });
+      return data;
+    } catch (error) {
+      handleSdkError(error, `Failed to get all queue configs`);
+    }
+  }
+  /**
+   * Delete queue config
+   * @param {string} queueType
+   * @param {string} queueName
+   * @returns {Promise<void>}
+   * @throws {ConductorSdkError}
+   */
+  async deleteQueueConfig(queueType, queueName) {
+    try {
+      await EventResource.deleteQueueConfig({
+        path: { queueType, queueName },
+        client: this._client,
+        throwOnError: true
+      });
+    } catch (error) {
+      handleSdkError(
+        error,
+        `Failed to delete queue config ${queueType} ${queueName}`
+      );
+    }
+  }
+  /**
+   * Get queue config
+   * @param {string} queueType
+   * @param {string} queueName
+   * @returns {Promise<Record<string, unknown>>}
+   * @throws {ConductorSdkError}
+   */
+  async getQueueConfig(queueType, queueName) {
+    try {
+      const { data } = await EventResource.getQueueConfig({
+        path: { queueType, queueName },
+        client: this._client,
+        throwOnError: true
+      });
+      if (Object.keys(data).length === 0) {
+        throw new Error("Response is empty");
+      }
+      return data;
+    } catch (error) {
+      handleSdkError(error, `Failed to get queue config`);
+    }
+  }
+  /**
+   * Get event handlers for a given event
+   * @param {string} event
+   * @param {boolean} [activeOnly=false] Only return active handlers.
+   * @returns {Promise<EventHandler[]>}
+   * @throws {ConductorSdkError}
+   */
+  async getEventHandlersForEvent(event, activeOnly = false) {
+    try {
+      const { data } = await EventResource.getEventHandlersForEvent({
+        client: this._client,
+        throwOnError: true,
+        path: { event },
+        query: { activeOnly }
+      });
+      return data;
+    } catch (error) {
+      handleSdkError(error, `Failed to get event handlers for event: ${event}`);
+    }
+  }
+  /**
+   * Remove an event handler by name
+   * @param {string} name
+   * @returns {Promise<void>}
+   * @throws {ConductorSdkError}
+   */
+  async removeEventHandler(name) {
+    try {
+      await EventResource.removeEventHandlerStatus({
+        client: this._client,
+        throwOnError: true,
+        path: { name }
+      });
+    } catch (error) {
+      handleSdkError(error, `Failed to remove event handler: ${name}`);
+    }
+  }
+  /**
+   * Get tags for an event handler
+   * @param {string} name
+   * @returns {Promise<Tag[]>}
+   * @throws {ConductorSdkError}
+   */
+  async getTagsForEventHandler(name) {
+    try {
+      const { data } = await EventResource.getTagsForEventHandler({
+        client: this._client,
+        throwOnError: true,
+        path: { name }
+      });
+      return data;
+    } catch (error) {
+      handleSdkError(error, `Failed to get tags for event handler: ${name}`);
+    }
+  }
+  /**
+   * Put tags for an event handler
+   * @param {string} name
+   * @param {Tag[]} tags
+   * @returns {Promise<void>}
+   * @throws {ConductorSdkError}
+   */
+  async putTagForEventHandler(name, tags) {
+    try {
+      await EventResource.putTagForEventHandler({
+        client: this._client,
+        throwOnError: true,
+        path: { name },
+        body: tags
+      });
+    } catch (error) {
+      handleSdkError(error, `Failed to put tags for event handler: ${name}`);
+    }
+  }
+  /**
+   * Delete tags for an event handler
+   * @param {string} name
+   * @param {Tag[]} tags
+   * @returns {Promise<void>}
+   * @throws {ConductorSdkError}
+   */
+  async deleteTagsForEventHandler(name, tags) {
+    try {
+      await EventResource.deleteTagForEventHandler({
+        client: this._client,
+        throwOnError: true,
+        path: { name },
+        body: tags
+      });
+    } catch (error) {
+      handleSdkError(
+        error,
+        `Failed to delete tags for an event handler: ${name}`
+      );
+    }
+  }
+  /**
+   * Delete a tag for an event handler
+   * @param {string} name
+   * @param {Tag} tag
+   * @returns {Promise<void>}
+   * @throws {ConductorSdkError}
+   */
+  async deleteTagForEventHandler(name, tag) {
+    try {
+      await EventResource.deleteTagForEventHandler({
+        client: this._client,
+        throwOnError: true,
+        path: { name },
+        body: [tag]
+      });
+    } catch (error) {
+      handleSdkError(
+        error,
+        `Failed to delete a tag for an event handler: ${name}`
+      );
+    }
+  }
+  /**
+   * Test connectivity for a given queue using a workflow with EVENT task and an EventHandler
+   * @param {ConnectivityTestInput} input
+   * @returns {Promise<ConnectivityTestResult>}
+   * @throws {ConductorSdkError}
+   */
+  async testConnectivity(input) {
+    try {
+      const { data } = await EventResource.testConnectivity({
+        client: this._client,
+        throwOnError: true,
+        body: input
+      });
+      return data;
+    } catch (error) {
+      handleSdkError(error, `Failed to test connectivity`);
+    }
+  }
+  /**
+   * Create or update queue config by name
+   * @deprecated Prefer server's newer endpoints if available
+   * @param {string} queueType
+   * @param {string} queueName
+   * @param {string} config
+   * @returns {Promise<void>}
+   * @throws {ConductorSdkError}
+   */
+  async putQueueConfig(queueType, queueName, config) {
+    try {
+      await EventResource.putQueueConfig({
+        client: this._client,
+        throwOnError: true,
+        path: { queueType, queueName },
+        body: config
+      });
+    } catch (error) {
+      handleSdkError(error, `Failed to put queue config`);
+    }
+  }
+  /**
+   * Test endpoint (as exposed by API)
+   * @returns {Promise<EventHandler>}
+   * @throws {ConductorSdkError}
+   */
+  async test() {
+    try {
+      const { data } = await EventResource.test({
+        client: this._client,
+        throwOnError: true
+      });
+      return data;
+    } catch (error) {
+      handleSdkError(error, `Failed to call test endpoint`);
+    }
+  }
+  /**
+   * Get all active event handlers (execution view)
+   * @returns {Promise<SearchResultHandledEventResponse>}
+   * @throws {ConductorSdkError}
+   */
+  async getAllActiveEventHandlers() {
+    try {
+      const { data } = await EventExecutionResource.getEventHandlersForEvent1({
+        client: this._client,
+        throwOnError: true
+      });
+      return data;
+    } catch (error) {
+      handleSdkError(
+        error,
+        `Failed to get all active event handlers (execution view)`
+      );
+    }
+  }
+  /**
+   * Get event executions for a specific handler
+   * @param {string} eventHandlerName
+   * @param {number} [from] Pagination cursor
+   * @returns {Promise<ExtendedEventExecution[]>}
+   * @throws {ConductorSdkError}
+   */
+  async getEventExecutions(eventHandlerName, from) {
+    try {
+      const { data } = await EventExecutionResource.getEventHandlersForEvent2({
+        client: this._client,
+        throwOnError: true,
+        path: { eventHandlerName },
+        query: { from }
+      });
+      return data;
+    } catch (error) {
+      handleSdkError(
+        error,
+        `Failed to get event executions for handler: ${eventHandlerName}`
+      );
+    }
+  }
+  /**
+   * Get all event handlers with statistics (messages view)
+   * @param {number} [from] Pagination cursor
+   * @returns {Promise<SearchResultHandledEventResponse>}
+   * @throws {ConductorSdkError}
+   */
+  async getEventHandlersWithStats(from) {
+    try {
+      const { data } = await EventMessageResource.getEvents({
+        client: this._client,
+        throwOnError: true,
+        query: { from }
+      });
+      return data;
+    } catch (error) {
+      handleSdkError(error, `Failed to get event handlers statistics`);
+    }
+  }
+  /**
+   * Get event messages for a given event
+   * @param {string} event
+   * @param {number} [from] Pagination cursor
+   * @returns {Promise<EventMessage[]>}
+   * @throws {ConductorSdkError}
+   */
+  async getEventMessages(event, from) {
+    try {
+      const { data } = await EventMessageResource.getMessages({
+        client: this._client,
+        throwOnError: true,
+        path: { event },
+        query: { from }
+      });
+      return data;
+    } catch (error) {
+      handleSdkError(error, `Failed to get event messages for event: ${event}`);
+    }
+  }
+};
+
 // src/orkes/constants.ts
 var REFRESH_TOKEN_IN_MILLISECONDS = 30 * 60 * 1e3;
 var MAX_HTTP2_CONNECTIONS = 1;
@@ -29818,6 +30311,7 @@ var orkesConductorClient = async (config, customFetch) => {
   ConductorSdkError,
   Consistency,
   DefaultLogger,
+  EventClient,
   HumanExecutor,
   MAX_RETRIES,
   MetadataClient,