@io-orkes/conductor-javascript 2.0.0-rc1 → 2.0.0-rc2

package/dist/index.mjs

@@ -5,16 +5,9 @@ var LOG_LEVELS = {
   ERROR: 60
 };
 var DefaultLogger = class {
+  tags;
+  level;
   constructor(config = {}) {
-    this.info = (...args) => {
-      this.log("INFO", ...args);
-    };
-    this.debug = (...args) => {
-      this.log("DEBUG", ...args);
-    };
-    this.error = (...args) => {
-      this.log("ERROR", ...args);
-    };
     const { level, tags = [] } = config;
     this.tags = tags;
     if (level && level in LOG_LEVELS) {
@@ -36,6 +29,15 @@ var DefaultLogger = class {
       console.log(name, ...this.tags, ...args);
     }
   }
+  info = (...args) => {
+    this.log("INFO", ...args);
+  };
+  debug = (...args) => {
+    this.log("DEBUG", ...args);
+  };
+  error = (...args) => {
+    this.log("ERROR", ...args);
+  };
 };
 var noopLogger = {
   //eslint-disable-next-line
@@ -1486,6 +1488,11 @@ var WorkflowResourceService = class {
 
 // src/common/open-api/core/ApiError.ts
 var ApiError = class extends Error {
+  url;
+  status;
+  statusText;
+  body;
+  request;
   constructor(request3, response, message) {
     super(message);
     this.name = "ApiError";
@@ -1508,9 +1515,14 @@ var CancelError = class extends Error {
   }
 };
 var CancelablePromise = class {
-  static {
-    Symbol.toStringTag;
-  }
+  [Symbol.toStringTag];
+  _isResolved;
+  _isRejected;
+  _isCancelled;
+  _cancelHandlers;
+  _promise;
+  _resolve;
+  _reject;
   constructor(executor) {
     this._isResolved = false;
     this._isRejected = false;
@@ -2147,6 +2159,18 @@ var HumanTaskResourceService = class {
 // src/common/open-api/ConductorClient.ts
 var defaultRequestHandler = (request3, config, options) => request3(config, options);
 var ConductorClient = class {
+  eventResource;
+  healthCheckResource;
+  metadataResource;
+  schedulerResource;
+  taskResource;
+  tokenResource;
+  workflowBulkResource;
+  workflowResource;
+  humanTask;
+  humanTaskResource;
+  request;
+  token;
   constructor(config, requestHandler = defaultRequestHandler) {
     const resolvedConfig = {
       BASE: config?.serverUrl ?? "http://localhost:8080",
@@ -2200,75 +2224,21 @@ var DEFAULT_BATCH_POLLING_TIMEOUT = 100;
 
 // src/task/Poller.ts
 var Poller = class {
+  timeoutHandler;
+  pollFunction;
+  performWorkFunction = async () => {
+  };
+  polling = false;
+  _tasksInProcess = 0;
+  _counterAtO = 0;
+  _pollerId = "";
+  options = {
+    pollInterval: DEFAULT_POLL_INTERVAL,
+    concurrency: DEFAULT_CONCURRENCY,
+    warnAtO: DEFAULT_WARN_AT_O
+  };
+  logger = noopLogger;
   constructor(pollerId, pollFunction, performWorkFunction, pollerOptions, logger) {
-    this.performWorkFunction = async () => {
-    };
-    this.polling = false;
-    this._tasksInProcess = 0;
-    this._counterAtO = 0;
-    this._pollerId = "";
-    this.options = {
-      pollInterval: DEFAULT_POLL_INTERVAL,
-      concurrency: DEFAULT_CONCURRENCY,
-      warnAtO: DEFAULT_WARN_AT_O
-    };
-    this.logger = noopLogger;
-    /**
-     * Starts polling for work
-     */
-    this.startPolling = () => {
-      if (this.polling) {
-        throw new Error("Runner is already started");
-      }
-      this._tasksInProcess = 0;
-      this.polling = true;
-      this.poll();
-    };
-    /**
-     * Stops Polling for work
-     */
-    this.stopPolling = async () => {
-      this.polling = false;
-      clearTimeout(this.timeoutHandler);
-    };
-    this.performWork = async (work) => {
-      await this.performWorkFunction(work);
-      this._tasksInProcess--;
-    };
-    this.poll = async () => {
-      while (this.isPolling) {
-        try {
-          const count = Math.max(
-            0,
-            this.options.concurrency - this._tasksInProcess
-          );
-          if (count === 0) {
-            this.logger.debug(
-              "Max in process reached, Will skip polling for " + this._pollerId
-            );
-            this._counterAtO++;
-            if (this._counterAtO > (this.options.warnAtO ?? 100)) {
-              this.logger.info(
-                `Not polling anything because in process tasks is maxed as concurrency level. ${this._pollerId}`
-              );
-            }
-          } else {
-            this._counterAtO = 0;
-            const tasksResult = await this.pollFunction(count);
-            this._tasksInProcess = this._tasksInProcess + (tasksResult ?? []).length;
-            tasksResult.forEach(this.performWork);
-          }
-        } catch (e) {
-          this.logger.error(`Error polling for tasks: ${e.message}`, e);
-        }
-        await new Promise(
-          (r) => this.isPolling ? this.timeoutHandler = setTimeout(
-            () => r(true),
-            this.options.pollInterval
-          ) : r(true)
-        );
-      }
-    };
     this._pollerId = pollerId;
     this.pollFunction = pollFunction;
     this.performWorkFunction = performWorkFunction;
@@ -2281,10 +2251,66 @@ var Poller = class {
   get tasksInProcess() {
     return this._tasksInProcess;
   }
+  /**
+   * Starts polling for work
+   */
+  startPolling = () => {
+    if (this.polling) {
+      throw new Error("Runner is already started");
+    }
+    this._tasksInProcess = 0;
+    this.polling = true;
+    this.poll();
+  };
+  /**
+   * Stops Polling for work
+   */
+  stopPolling = async () => {
+    this.polling = false;
+    clearTimeout(this.timeoutHandler);
+  };
+  performWork = async (work) => {
+    await this.performWorkFunction(work);
+    this._tasksInProcess--;
+  };
   updateOptions(options) {
     const newOptions = { ...this.options, ...options };
     this.options = newOptions;
   }
+  poll = async () => {
+    while (this.isPolling) {
+      try {
+        const count = Math.max(
+          0,
+          this.options.concurrency - this._tasksInProcess
+        );
+        if (count === 0) {
+          this.logger.debug(
+            "Max in process reached, Will skip polling for " + this._pollerId
+          );
+          this._counterAtO++;
+          if (this._counterAtO > (this.options.warnAtO ?? 100)) {
+            this.logger.info(
+              `Not polling anything because in process tasks is maxed as concurrency level. ${this._pollerId}`
+            );
+          }
+        } else {
+          this._counterAtO = 0;
+          const tasksResult = await this.pollFunction(count);
+          this._tasksInProcess = this._tasksInProcess + (tasksResult ?? []).length;
+          tasksResult.forEach(this.performWork);
+        }
+      } catch (e) {
+        this.logger.error(`Error polling for tasks: ${e.message}`, e);
+      }
+      await new Promise(
+        (r) => this.isPolling ? this.timeoutHandler = setTimeout(
+          () => r(true),
+          this.options.pollInterval
+        ) : r(true)
+      );
+    }
+  };
 };
 
 // src/task/helpers.ts
@@ -2309,6 +2335,12 @@ var defaultRunnerOptions = {
   batchPollingTimeout: DEFAULT_BATCH_POLLING_TIMEOUT
 };
 var TaskRunner = class {
+  taskResource;
+  worker;
+  logger;
+  options;
+  errorHandler;
+  poller;
   constructor({
     worker,
     taskResource,
@@ -2316,91 +2348,6 @@ var TaskRunner = class {
     logger = noopLogger,
     onError: errorHandler = noopErrorHandler
   }) {
-    /**
-     * Starts polling for work
-     */
-    this.startPolling = () => {
-      this.poller.startPolling();
-      this.logger.info(
-        `TaskWorker ${this.worker.taskDefName} initialized with concurrency of ${this.poller.options.concurrency} and poll interval of ${this.poller.options.pollInterval}`
-      );
-    };
-    /**
-     * Stops Polling for work
-     */
-    this.stopPolling = async () => {
-      await this.poller.stopPolling();
-    };
-    this.batchPoll = async (count) => {
-      const { workerID } = this.options;
-      const tasks = await this.taskResource.batchPoll(
-        this.worker.taskDefName,
-        workerID,
-        this.worker.domain ?? this.options.domain,
-        count,
-        this.options.batchPollingTimeout ?? 100
-        // default batch poll defined in the method
-      );
-      return tasks;
-    };
-    this.updateTaskWithRetry = async (task, taskResult) => {
-      const { workerID } = this.options;
-      let retryCount = 0;
-      while (retryCount < MAX_RETRIES) {
-        try {
-          await this.taskResource.updateTask1({
-            ...taskResult,
-            workerId: workerID
-          });
-          return;
-        } catch (error) {
-          this.errorHandler(error, task);
-          this.logger.error(
-            `Error updating task ${taskResult.taskId} on retry ${retryCount}`,
-            error
-          );
-          retryCount++;
-          await new Promise((r) => setTimeout(() => r(true), retryCount * 10));
-        }
-      }
-      this.logger.error(
-        `Unable to update task ${taskResult.taskId} after ${retryCount} retries`
-      );
-    };
-    this.executeTask = async (task) => {
-      try {
-        const result = await this.worker.execute(task);
-        await this.updateTaskWithRetry(task, {
-          ...result,
-          workflowInstanceId: task.workflowInstanceId,
-          taskId: task.taskId
-        });
-        this.logger.debug(`Task has executed successfully ${task.taskId}`);
-      } catch (error) {
-        await this.updateTaskWithRetry(task, {
-          workflowInstanceId: task.workflowInstanceId,
-          taskId: task.taskId,
-          reasonForIncompletion: error?.message ?? DEFAULT_ERROR_MESSAGE,
-          status: "FAILED",
-          outputData: {}
-        });
-        this.errorHandler(error, task);
-        this.logger.error(`Error executing ${task.taskId}`, error);
-      }
-    };
-    this.handleUnknownError = (unknownError) => {
-      let message = "";
-      let stack = "";
-      if (unknownError.stack) {
-        stack = unknownError.stack;
-      }
-      if (unknownError.message) {
-        message = unknownError.message;
-      }
-      this.logger.error(
-        `Error for ${this.worker.taskDefName}: error: ${message}, stack: ${stack}`
-      );
-    };
     this.taskResource = taskResource;
     this.logger = logger;
     this.worker = worker;
@@ -2420,6 +2367,21 @@ var TaskRunner = class {
   get isPolling() {
     return this.poller.isPolling;
   }
+  /**
+   * Starts polling for work
+   */
+  startPolling = () => {
+    this.poller.startPolling();
+    this.logger.info(
+      `TaskWorker ${this.worker.taskDefName} initialized with concurrency of ${this.poller.options.concurrency} and poll interval of ${this.poller.options.pollInterval}`
+    );
+  };
+  /**
+   * Stops Polling for work
+   */
+  stopPolling = async () => {
+    await this.poller.stopPolling();
+  };
   updateOptions(options) {
     const newOptions = { ...this.options, ...options };
     const isOptionsUpdated = !optionEquals(this.options, newOptions);
@@ -2437,6 +2399,76 @@ var TaskRunner = class {
   get getOptions() {
     return this.options;
   }
+  batchPoll = async (count) => {
+    const { workerID } = this.options;
+    const tasks = await this.taskResource.batchPoll(
+      this.worker.taskDefName,
+      workerID,
+      this.worker.domain ?? this.options.domain,
+      count,
+      this.options.batchPollingTimeout ?? 100
+      // default batch poll defined in the method
+    );
+    return tasks;
+  };
+  updateTaskWithRetry = async (task, taskResult) => {
+    const { workerID } = this.options;
+    let retryCount = 0;
+    while (retryCount < MAX_RETRIES) {
+      try {
+        await this.taskResource.updateTask1({
+          ...taskResult,
+          workerId: workerID
+        });
+        return;
+      } catch (error) {
+        this.errorHandler(error, task);
+        this.logger.error(
+          `Error updating task ${taskResult.taskId} on retry ${retryCount}`,
+          error
+        );
+        retryCount++;
+        await new Promise((r) => setTimeout(() => r(true), retryCount * 10));
+      }
+    }
+    this.logger.error(
+      `Unable to update task ${taskResult.taskId} after ${retryCount} retries`
+    );
+  };
+  executeTask = async (task) => {
+    try {
+      const result = await this.worker.execute(task);
+      await this.updateTaskWithRetry(task, {
+        ...result,
+        workflowInstanceId: task.workflowInstanceId,
+        taskId: task.taskId
+      });
+      this.logger.debug(`Task has executed successfully ${task.taskId}`);
+    } catch (error) {
+      await this.updateTaskWithRetry(task, {
+        workflowInstanceId: task.workflowInstanceId,
+        taskId: task.taskId,
+        reasonForIncompletion: error?.message ?? DEFAULT_ERROR_MESSAGE,
+        status: "FAILED",
+        outputData: {}
+      });
+      this.errorHandler(error, task);
+      this.logger.error(`Error executing ${task.taskId}`, error);
+    }
+  };
+  handleUnknownError = (unknownError) => {
+    let message = "";
+    let stack = "";
+    if (unknownError.stack) {
+      stack = unknownError.stack;
+    }
+    if (unknownError.message) {
+      message = unknownError.message;
+    }
+    this.logger.error(
+      `Error for ${this.worker.taskDefName}: error: ${message}, stack: ${stack}`
+    );
+  };
 };
 
 // src/task/TaskManager.ts
@@ -2452,84 +2484,14 @@ function workerId(options) {
   return options.workerID ?? os.hostname();
 }
 var TaskManager = class {
+  workerRunners = /* @__PURE__ */ new Map();
+  client;
+  logger;
+  errorHandler;
+  workers;
+  options;
+  polling = false;
   constructor(client, workers, config = {}) {
-    this.workerRunners = /* @__PURE__ */ new Map();
-    this.polling = false;
-    this.workerManagerWorkerOptions = (worker) => {
-      return {
-        ...this.options,
-        concurrency: worker.concurrency ?? this.options.concurrency,
-        pollInterval: worker.pollInterval ?? this.options.pollInterval,
-        domain: worker.domain ?? this.options.domain
-      };
-    };
-    this.updatePollingOptionForWorker = (workerTaskDefName, options) => {
-      const maybeRunner = this.workerRunners.get(workerTaskDefName);
-      if (maybeRunner != null) {
-        maybeRunner.updateOptions(options);
-      } else {
-        this.logger.info(
-          `No runner found for worker with taskDefName: ${workerTaskDefName}`
-        );
-      }
-    };
-    /**
-     * new options will get merged to existing options
-     * @param options new options to update polling options
-     */
-    this.updatePollingOptions = (options) => {
-      this.workers.forEach((worker) => {
-        const newOptions = {
-          ...this.workerManagerWorkerOptions(worker),
-          ...options
-        };
-        this.updatePollingOptionForWorker(worker.taskDefName, newOptions);
-      });
-      this.options.concurrency = options.concurrency ?? this.options.concurrency;
-      this.options.pollInterval = options.pollInterval ?? this.options.pollInterval;
-    };
-    this.sanityCheck = () => {
-      if (this.workers.length === 0) {
-        throw new Error("No workers supplied to TaskManager");
-      }
-      const workerIDs = /* @__PURE__ */ new Set();
-      for (const item of this.workers) {
-        if (workerIDs.has(item.taskDefName)) {
-          throw new Error(`Duplicate worker taskDefName: ${item.taskDefName}`);
-        }
-        workerIDs.add(item.taskDefName);
-      }
-    };
-    /**
-     * Start polling for tasks
-     */
-    this.startPolling = () => {
-      this.sanityCheck();
-      this.workers.forEach((worker) => {
-        const options = this.workerManagerWorkerOptions(worker);
-        const runner = new TaskRunner({
-          worker,
-          options,
-          taskResource: this.client.taskResource,
-          logger: this.logger,
-          onError: this.errorHandler
-        });
-        runner.startPolling();
-        this.workerRunners.set(worker.taskDefName, runner);
-      });
-      this.polling = true;
-    };
-    /**
-     * Stops polling for tasks
-     */
-    this.stopPolling = async () => {
-      for (const [workerTaskDefName, runner] of this.workerRunners) {
-        this.logger.debug(`Stopping taskDefName=${workerTaskDefName}`);
-        await runner.stopPolling();
-        this.workerRunners.delete(workerTaskDefName);
-      }
-      this.polling = false;
-    };
     if (!workers) {
       throw new Error(
         "No workers supplied to TaskManager. Please pass an array of workers."
@@ -2546,13 +2508,90 @@ var TaskManager = class {
       workerID: workerId(providedOptions)
     };
   }
+  workerManagerWorkerOptions = (worker) => {
+    return {
+      ...this.options,
+      concurrency: worker.concurrency ?? this.options.concurrency,
+      pollInterval: worker.pollInterval ?? this.options.pollInterval,
+      domain: worker.domain ?? this.options.domain
+    };
+  };
   get isPolling() {
     return this.polling;
   }
+  updatePollingOptionForWorker = (workerTaskDefName, options) => {
+    const maybeRunner = this.workerRunners.get(workerTaskDefName);
+    if (maybeRunner != null) {
+      maybeRunner.updateOptions(options);
+    } else {
+      this.logger.info(
+        `No runner found for worker with taskDefName: ${workerTaskDefName}`
+      );
+    }
+  };
+  /**
+   * new options will get merged to existing options
+   * @param options new options to update polling options
+   */
+  updatePollingOptions = (options) => {
+    this.workers.forEach((worker) => {
+      const newOptions = {
+        ...this.workerManagerWorkerOptions(worker),
+        ...options
+      };
+      this.updatePollingOptionForWorker(worker.taskDefName, newOptions);
+    });
+    this.options.concurrency = options.concurrency ?? this.options.concurrency;
+    this.options.pollInterval = options.pollInterval ?? this.options.pollInterval;
+  };
+  sanityCheck = () => {
+    if (this.workers.length === 0) {
+      throw new Error("No workers supplied to TaskManager");
+    }
+    const workerIDs = /* @__PURE__ */ new Set();
+    for (const item of this.workers) {
+      if (workerIDs.has(item.taskDefName)) {
+        throw new Error(`Duplicate worker taskDefName: ${item.taskDefName}`);
+      }
+      workerIDs.add(item.taskDefName);
+    }
+  };
+  /**
+   * Start polling for tasks
+   */
+  startPolling = () => {
+    this.sanityCheck();
+    this.workers.forEach((worker) => {
+      const options = this.workerManagerWorkerOptions(worker);
+      const runner = new TaskRunner({
+        worker,
+        options,
+        taskResource: this.client.taskResource,
+        logger: this.logger,
+        onError: this.errorHandler
+      });
+      runner.startPolling();
+      this.workerRunners.set(worker.taskDefName, runner);
+    });
+    this.polling = true;
+  };
+  /**
+   * Stops polling for tasks
+   */
+  stopPolling = async () => {
+    for (const [workerTaskDefName, runner] of this.workerRunners) {
+      this.logger.debug(`Stopping taskDefName=${workerTaskDefName}`);
+      await runner.stopPolling();
+      this.workerRunners.delete(workerTaskDefName);
+    }
+    this.polling = false;
+  };
 };
 
 // src/core/types.ts
 var ConductorError = class extends Error {
+  _trace;
+  __proto__;
   constructor(message, innerError) {
     super(message);
     this._trace = innerError;
@@ -2587,6 +2626,7 @@ function reverseFind(array, predicate) {
 var RETRY_TIME_IN_MILLISECONDS = 1e4;
 var completedTaskMatchingType = (taskType) => (task) => task.status === "COMPLETED" && task.taskType === taskType;
 var WorkflowExecutor = class {
+  _client;
   constructor(client) {
     this._client = client;
   }
@@ -2892,6 +2932,7 @@ var EMPTY_SEARCH = {
 };
 var DEFAULT_POLL_INTERVAL2 = { pollInterval: 100, maxPollTimes: 20 };
 var HumanExecutor = class {
+  _client;
   constructor(client) {
     this._client = client;
   }
@@ -3536,105 +3577,73 @@ var workflow = (name, tasks) => ({
   timeoutSeconds: 0
 });
 
-// src/orkes/request/fetchCatchDns/DnsResolver.ts
-import { promises } from "dns";
-var DEFAULT_OPTIONS = {
-  logger: noopLogger,
-  resolver: promises.resolve4
-};
-var dnsResolver = async (host, { resolver = promises.resolve4, logger = console } = DEFAULT_OPTIONS) => {
-  try {
-    const addresses = await resolver(host);
-    if (addresses.length > 0)
-      return addresses[0];
-  } catch (e) {
-    logger.error("Could not resolve host: " + host + " error: " + e);
-  }
-  return void 0;
-};
-
-// src/orkes/request/fetchCatchDns/DnsCache.ts
-var DnsCacheResolver = class {
-  constructor({ initialCache = /* @__PURE__ */ new Map() } = {}) {
-    this._cache = /* @__PURE__ */ new Map();
-    this._cache = initialCache;
+// src/orkes/BaseOrkesConductorClient.ts
+var defaultRequestHandler2 = (request3, config, options) => request3(config, options);
+var REFRESH_TOKEN_IN_MILLISECONDS = 30 * 60 * 1e3;
+var AuthConductorClient = class extends ConductorClient {
+  intervalId;
+  constructor(config, requestHandler = defaultRequestHandler2) {
+    super(config, requestHandler);
   }
-  async resolve(host) {
-    const cachedIp = this._cache.get(host);
-    if (cachedIp) {
-      return cachedIp;
-    }
-    const ip = await dnsResolver(host);
-    if (ip != void 0) {
-      this._cache.set(host, ip);
+  /**
+   * Stops the interval that refreshes the token
+   */
+  stop() {
+    if (this.intervalId != null) {
+      clearInterval(this.intervalId);
     }
-    return ip;
-  }
-  clearCache() {
-    this._cache.clear();
   }
-  removeCache(host) {
-    this._cache.delete(host);
-  }
-  get cache() {
-    return this._cache;
-  }
-};
-
-// src/orkes/request/fetchCatchDns/fetchCatchDns.ts
-import { isIP } from "net";
-var isEmpty = (value) => {
-  return value === void 0 || value.trim().length === 0;
-};
-var toMaybeUrl = (originalUrl, modifiedParams) => {
-  const urlToHit = new URL(originalUrl.toString());
-  urlToHit.host = isEmpty(modifiedParams.port) ? `${modifiedParams.host}:${modifiedParams.port}` : modifiedParams.host;
-  return urlToHit;
 };
-var DEFAULT_OPTIONS2 = {
-  dnsCache: new DnsCacheResolver(),
-  headerFactory: (headers) => new Headers(headers || {})
-};
-var fetchCatchDns = (fetch3, {
-  dnsCache = new DnsCacheResolver(),
-  headerFactory = (headers) => new Headers(headers || {})
-} = DEFAULT_OPTIONS2) => {
-  const fetchWithDns = async (input, options) => {
-    const parsedUrl = new URL(input.toString());
-    const { hostname, host, port } = parsedUrl;
-    if (isIP(hostname)) {
-      return await fetch3(input, options);
-    }
-    const maybeTargetIp = await dnsCache.resolve(hostname);
-    if (isEmpty(maybeTargetIp)) {
-      return await fetch3(input, options);
-    }
-    const target = toMaybeUrl(input, {
-      ...parsedUrl,
-      host: maybeTargetIp,
-      port
-    });
-    const headersOverride = headerFactory(options?.headers ?? {});
-    if (!headersOverride.has("Host")) {
-      headersOverride.set("Host", host);
-    }
-    const optionsOverride = {
-      ...options,
-      headers: headersOverride
-    };
-    try {
-      const res = await fetch3(target.toString(), optionsOverride);
-      return res;
-    } catch (e) {
-      if (e && e?.code === "ETIMEDOUT") {
-        dnsCache.removeCache(hostname);
+var baseOrkesConductorClient = (fetchFn, baseRequestHandler = defaultRequestHandler2) => {
+  const requestTokenForKeySecret = (keyId, keySecret, tokenUrl) => fetchFn(tokenUrl, {
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    body: JSON.stringify({ keyId, keySecret }),
+    method: "POST"
+  });
+  return async (config, requestHandler = baseRequestHandler) => {
+    if (config?.keySecret != null && config?.keyId != null) {
+      const {
+        serverUrl,
+        keyId,
+        keySecret,
+        refreshTokenInterval = REFRESH_TOKEN_IN_MILLISECONDS
+      } = config;
+      const tokenUrl = `${serverUrl}/token`;
+      const res = await requestTokenForKeySecret(keyId, keySecret, tokenUrl);
+      const { token } = await res.json();
+      const conductorClientInstance = new AuthConductorClient(
+        { ...config, TOKEN: token },
+        requestHandler
+      );
+      if (token != null && refreshTokenInterval > 0) {
+        const intervalId = setInterval(async () => {
+          const res2 = await requestTokenForKeySecret(
+            keyId,
+            keySecret,
+            tokenUrl
+          );
+          const { token: token2 } = await res2.json();
+          conductorClientInstance.token = token2;
+        }, refreshTokenInterval);
+        conductorClientInstance.intervalId = intervalId;
       }
-      throw e;
+      return conductorClientInstance;
+    } else {
+      return new ConductorClient(config, requestHandler);
     }
   };
-  return fetchWithDns;
 };
 
+// src/orkes/OrkesConductorClient.ts
+var defaultRequestHandler3 = (request3, config, options) => request3(config, options);
+var orkesConductorClient = baseOrkesConductorClient(
+  fetch,
+  defaultRequestHandler3
+);
+
 // src/orkes/request/request.ts
 var isDefined2 = (value) => {
   return value !== void 0 && value !== null;
@@ -3870,91 +3879,104 @@ var request2 = (config, options, fetchFn = fetch) => {
   });
 };
 
-// src/orkes/BaseOrkesConductorClient.ts
-var defaultRequestHandler2 = (request3, config, options) => request3(config, options);
-var REFRESH_TOKEN_IN_MILLISECONDS = 30 * 60 * 1e3;
-var AuthConductorClient = class extends ConductorClient {
-  constructor(config, requestHandler = defaultRequestHandler2) {
-    super(config, requestHandler);
+// src/orkes/request/fetchCatchDns/DnsResolver.ts
+import { promises } from "dns";
+var DEFAULT_OPTIONS = {
+  logger: noopLogger,
+  resolver: promises.resolve4
+};
+var dnsResolver = async (host, { resolver = promises.resolve4, logger = console } = DEFAULT_OPTIONS) => {
+  try {
+    const addresses = await resolver(host);
+    if (addresses.length > 0)
+      return addresses[0];
+  } catch (e) {
+    logger.error("Could not resolve host: " + host + " error: " + e);
   }
-  /**
-   * Stops the interval that refreshes the token
-   */
-  stop() {
-    if (this.intervalId != null) {
-      clearInterval(this.intervalId);
+  return void 0;
+};
+
+// src/orkes/request/fetchCatchDns/DnsCache.ts
+var DnsCacheResolver = class {
+  _cache = /* @__PURE__ */ new Map();
+  constructor({ initialCache = /* @__PURE__ */ new Map() } = {}) {
+    this._cache = initialCache;
+  }
+  async resolve(host) {
+    const cachedIp = this._cache.get(host);
+    if (cachedIp) {
+      return cachedIp;
     }
+    const ip = await dnsResolver(host);
+    if (ip != void 0) {
+      this._cache.set(host, ip);
+    }
+    return ip;
+  }
+  clearCache() {
+    this._cache.clear();
+  }
+  removeCache(host) {
+    this._cache.delete(host);
+  }
+  get cache() {
+    return this._cache;
   }
 };
-var baseOrkesConductorClient = (fetchFn, baseRequestHandler = defaultRequestHandler2) => {
-  const requestTokenForKeySecret = (keyId, keySecret, tokenUrl) => fetchFn(tokenUrl, {
-    headers: {
-      "Content-Type": "application/json",
-      Accept: "application/json"
-    },
-    body: JSON.stringify({ keyId, keySecret }),
-    method: "POST"
-  });
-  return async (config, requestHandler = baseRequestHandler) => {
-    if (config?.keySecret != null && config?.keyId != null) {
-      const {
-        serverUrl,
-        keyId,
-        keySecret,
-        refreshTokenInterval = REFRESH_TOKEN_IN_MILLISECONDS
-      } = config;
-      const tokenUrl = `${serverUrl}/token`;
-      const res = await requestTokenForKeySecret(keyId, keySecret, tokenUrl);
-      const { token } = await res.json();
-      const conductorClientInstance = new AuthConductorClient(
-        { ...config, TOKEN: token },
-        requestHandler
-      );
-      if (token != null && refreshTokenInterval > 0) {
-        const intervalId = setInterval(async () => {
-          const res2 = await requestTokenForKeySecret(
-            keyId,
-            keySecret,
-            tokenUrl
-          );
-          const { token: token2 } = await res2.json();
-          conductorClientInstance.token = token2;
-        }, refreshTokenInterval);
-        conductorClientInstance.intervalId = intervalId;
+
+// src/orkes/request/fetchCatchDns/fetchCatchDns.ts
+import { isIP } from "net";
+var isEmpty = (value) => {
+  return value === void 0 || value.trim().length === 0;
+};
+var toMaybeUrl = (originalUrl, modifiedParams) => {
+  const urlToHit = new URL(originalUrl.toString());
+  urlToHit.host = isEmpty(modifiedParams.port) ? `${modifiedParams.host}:${modifiedParams.port}` : modifiedParams.host;
+  return urlToHit;
+};
+var DEFAULT_OPTIONS2 = {
+  dnsCache: new DnsCacheResolver(),
+  headerFactory: (headers) => new Headers(headers || {})
+};
+var fetchCatchDns = (fetch2, {
+  dnsCache = new DnsCacheResolver(),
+  headerFactory = (headers) => new Headers(headers || {})
+} = DEFAULT_OPTIONS2) => {
+  const fetchWithDns = async (input, options) => {
+    const parsedUrl = new URL(input.toString());
+    const { hostname, host, port } = parsedUrl;
+    if (isIP(hostname)) {
+      return await fetch2(input, options);
+    }
+    const maybeTargetIp = await dnsCache.resolve(hostname);
+    if (isEmpty(maybeTargetIp)) {
+      return await fetch2(input, options);
+    }
+    const target = toMaybeUrl(input, {
+      ...parsedUrl,
+      host: maybeTargetIp,
+      port
+    });
+    const headersOverride = headerFactory(options?.headers ?? {});
+    if (!headersOverride.has("Host")) {
+      headersOverride.set("Host", host);
+    }
+    const optionsOverride = {
+      ...options,
+      headers: headersOverride
+    };
+    try {
+      const res = await fetch2(target.toString(), optionsOverride);
+      return res;
+    } catch (e) {
+      if (e && e?.code === "ETIMEDOUT") {
+        dnsCache.removeCache(hostname);
       }
-      return conductorClientInstance;
-    } else {
-      return new ConductorClient(config, requestHandler);
+      throw e;
     }
   };
+  return fetchWithDns;
 };
-
-// src/orkes/OrkesConductorClient.ts
-import fetch2, { Headers as Headers2 } from "node-fetch";
-import http from "http";
-import https from "https";
-var httpAgent = new http.Agent({ keepAlive: true });
-var httpsAgent = new https.Agent({ keepAlive: true });
-var agent = (_parsedURL) => _parsedURL.protocol == "http:" ? httpAgent : httpsAgent;
-var nodeFetchWrapper = async (input, options = {}) => {
-  const res = await fetch2(input.toString(), {
-    ...options,
-    agent
-  });
-  return res;
-};
-var fetchCache = fetchCatchDns(
-  nodeFetchWrapper,
-  {
-    //@ts-ignore
-    headerFactory: (headers) => new Headers2(headers || {})
-  }
-);
-var defaultRequestHandler3 = (__request, config, options) => request2(config, options, fetchCache);
-var orkesConductorClient = baseOrkesConductorClient(
-  fetchCache,
-  defaultRequestHandler3
-);
 export {
   ApiError,
   AuthConductorClient,