@io-orkes/conductor-javascript 1.2.0-rc.1 → 1.2.0-rc.3

package/dist/index.mjs

@@ -1,53 +1,243 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
 // src/common/ConductorLogger.ts
-var LOG_LEVELS = {
-  DEBUG: 10,
-  INFO: 30,
-  ERROR: 60
-};
-var DefaultLogger = class {
-  constructor(config = {}) {
-    this.info = (...args) => {
-      this.log("INFO", ...args);
+var LOG_LEVELS, DefaultLogger, noopLogger;
+var init_ConductorLogger = __esm({
+  "src/common/ConductorLogger.ts"() {
+    "use strict";
+    LOG_LEVELS = {
+      DEBUG: 10,
+      INFO: 30,
+      ERROR: 60
+    };
+    DefaultLogger = class {
+      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) {
+          this.level = LOG_LEVELS[level];
+        } else {
+          this.level = LOG_LEVELS.INFO;
+        }
+      }
+      log(level, ...args) {
+        let resolvedLevel;
+        let name = level;
+        if (level in LOG_LEVELS) {
+          resolvedLevel = LOG_LEVELS[level];
+        } else {
+          name = "INFO";
+          resolvedLevel = LOG_LEVELS.INFO;
+        }
+        if (resolvedLevel >= this.level) {
+          console.log(name, ...this.tags, ...args);
+        }
+      }
     };
-    this.debug = (...args) => {
-      this.log("DEBUG", ...args);
+    noopLogger = {
+      //eslint-disable-next-line
+      debug: (...args) => {
+      },
+      //eslint-disable-next-line
+      info: (...args) => {
+      },
+      //eslint-disable-next-line
+      error: (...args) => {
+      }
     };
-    this.error = (...args) => {
-      this.log("ERROR", ...args);
+  }
+});
+
+// src/orkes/request/fetchCatchDns/DnsResolver.ts
+import { promises } from "dns";
+var DEFAULT_OPTIONS, dnsResolver;
+var init_DnsResolver = __esm({
+  "src/orkes/request/fetchCatchDns/DnsResolver.ts"() {
+    "use strict";
+    init_ConductorLogger();
+    DEFAULT_OPTIONS = {
+      logger: noopLogger,
+      resolver: promises.resolve4
+    };
+    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;
+var init_DnsCache = __esm({
+  "src/orkes/request/fetchCatchDns/DnsCache.ts"() {
+    "use strict";
+    init_DnsResolver();
+    DnsCacheResolver = class {
+      constructor({ initialCache = /* @__PURE__ */ new Map() } = {}) {
+        this._cache = /* @__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();
+      }
+      get cache() {
+        return this._cache;
+      }
+    };
+  }
+});
+
+// src/orkes/request/fetchCatchDns/fetchCatchDns.ts
+import { isIP } from "net";
+var isEmpty, toMaybeUrl, DEFAULT_OPTIONS2, fetchCatchDns;
+var init_fetchCatchDns = __esm({
+  "src/orkes/request/fetchCatchDns/fetchCatchDns.ts"() {
+    "use strict";
+    init_DnsCache();
+    isEmpty = (value) => {
+      return value === void 0 || value.trim().length === 0;
+    };
+    toMaybeUrl = (originalUrl, modifiedParams) => {
+      const urlToHit = new URL(originalUrl.toString());
+      urlToHit.host = isEmpty(modifiedParams.port) ? `${modifiedParams.host}:${modifiedParams.port}` : modifiedParams.host;
+      return urlToHit;
+    };
+    DEFAULT_OPTIONS2 = {
+      dnsCache: new DnsCacheResolver(),
+      headerFactory: (headers) => new Headers(headers || {})
+    };
+    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
+        };
+        const res = await fetch2(target.toString(), optionsOverride);
+        return res;
+      };
+      return fetchWithDns;
     };
-    const { level, tags = [] } = config;
-    this.tags = tags;
-    if (level && level in LOG_LEVELS) {
-      this.level = LOG_LEVELS[level];
-    } else {
-      this.level = LOG_LEVELS.INFO;
-    }
   }
-  log(level, ...args) {
-    let resolvedLevel;
-    let name = level;
-    if (level in LOG_LEVELS) {
-      resolvedLevel = LOG_LEVELS[level];
+});
+
+// src/orkes/request/fetchCatchDns/index.ts
+var fetchCatchDns_exports = {};
+__export(fetchCatchDns_exports, {
+  DnsCacheResolver: () => DnsCacheResolver,
+  fetchCatchDns: () => fetchCatchDns,
+  toMaybeUrl: () => toMaybeUrl
+});
+var init_fetchCatchDns2 = __esm({
+  "src/orkes/request/fetchCatchDns/index.ts"() {
+    "use strict";
+    init_DnsCache();
+    init_fetchCatchDns();
+  }
+});
+
+// src/orkes/fetchImplementation.js
+var require_fetchImplementation = __commonJS({
+  "src/orkes/fetchImplementation.js"(exports, module) {
+    "use strict";
+    var fetchCatchDns2 = (init_fetchCatchDns2(), __toCommonJS(fetchCatchDns_exports)).fetchCatchDns;
+    var fetchImplementation = fetch;
+    var nodeFetch = __require("node-fetch");
+    if (nodeFetch) {
+      const nodeFetchWrapper = async (input, options = {}) => {
+        const res = await fetch(input.toString(), options);
+        return res;
+      };
+      const fetchCache2 = fetchCatchDns2(nodeFetchWrapper, {
+        headerFactory: (headers) => new nodeFetch.Headers(headers || {})
+      });
+      fetchImplementation = fetchCache2;
+      console.log("Using node fetch");
     } else {
-      name = "INFO";
-      resolvedLevel = LOG_LEVELS.INFO;
-    }
-    if (resolvedLevel >= this.level) {
-      console.log(name, ...this.tags, ...args);
+      fetchImplementation = fetchCatchDns2(fetch);
+      console.log("Using native fetch");
     }
+    module.exports = fetchImplementation;
   }
-};
-var noopLogger = {
-  //eslint-disable-next-line
-  debug: (...args) => {
-  },
-  //eslint-disable-next-line
-  info: (...args) => {
-  },
-  //eslint-disable-next-line
-  error: (...args) => {
-  }
-};
+});
+
+// src/common/index.ts
+init_ConductorLogger();
 
 // src/common/types.ts
 var TaskType = /* @__PURE__ */ ((TaskType2) => {
@@ -2156,7 +2346,11 @@ var ConductorClient = class {
     this.request = {
       config: resolvedConfig,
       request: (apiConfig) => {
-        return requestHandler(request, resolvedConfig, apiConfig);
+        return requestHandler(
+          request,
+          { ...resolvedConfig, TOKEN: this.token },
+          apiConfig
+        );
       }
     };
     this.token = config?.TOKEN;
@@ -2171,6 +2365,8 @@ var ConductorClient = class {
     this.humanTask = new HumanTaskService(this.request);
     this.humanTaskResource = new HumanTaskResourceService(this.request);
   }
+  stop() {
+  }
 };
 
 // src/common/open-api/core/BaseHttpRequest.ts
@@ -3362,95 +3558,6 @@ 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;
-  }
-  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();
-  }
-  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 = (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
-    };
-    const res = await fetch2(target.toString(), optionsOverride);
-    return res;
-  };
-  return fetchWithDns;
-};
-
 // src/orkes/request/request.ts
 var isDefined2 = (value) => {
   return value !== void 0 && value !== null;
@@ -3688,21 +3795,57 @@ 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);
+  }
+  /**
+   * Stops the interval that refreshes the token
+   */
+  stop() {
+    if (this.intervalId != null) {
+      clearInterval(this.intervalId);
+    }
+  }
+};
 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 } = config;
+      const {
+        serverUrl,
+        keyId,
+        keySecret,
+        refreshTokenInterval = REFRESH_TOKEN_IN_MILLISECONDS
+      } = config;
       const tokenUrl = `${serverUrl}/token`;
-      const res = await fetchFn(tokenUrl, {
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "application/json"
-        },
-        body: JSON.stringify({ keyId, keySecret }),
-        method: "POST"
-      });
+      const res = await requestTokenForKeySecret(keyId, keySecret, tokenUrl);
       const { token } = await res.json();
-      return new ConductorClient({ ...config, TOKEN: token }, requestHandler);
+      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;
+      }
+      return conductorClientInstance;
     } else {
       return new ConductorClient(config, requestHandler);
     }
@@ -3710,14 +3853,19 @@ var baseOrkesConductorClient = (fetchFn, baseRequestHandler = defaultRequestHand
 };
 
 // src/orkes/OrkesConductorClient.ts
-var fetchCache = fetchCatchDns(fetch);
-var defaultRequestHandler3 = (__request, config, options) => request2(config, options, fetchCache);
+var fetchCache = require_fetchImplementation();
+var defaultRequestHandler3 = (__request, config, options) => request2(config, options, fetch);
 var orkesConductorClient = baseOrkesConductorClient(
+  //@ts-ignore
   fetchCache,
   defaultRequestHandler3
 );
+
+// src/orkes/index.ts
+init_fetchCatchDns2();
 export {
   ApiError,
+  AuthConductorClient,
   BaseHttpRequest,
   CancelError,
   CancelablePromise,