@io-orkes/conductor-javascript 1.2.0-rc.4 → 1.2.0-rc.5

package/dist/index.mjs

@@ -1,249 +1,53 @@
-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, 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);
-        }
-      }
-    };
-    noopLogger = {
-      //eslint-disable-next-line
-      debug: (...args) => {
-      },
-      //eslint-disable-next-line
-      info: (...args) => {
-      },
-      //eslint-disable-next-line
-      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;
-      }
+var LOG_LEVELS = {
+  DEBUG: 10,
+  INFO: 30,
+  ERROR: 60
+};
+var DefaultLogger = class {
+  constructor(config = {}) {
+    this.info = (...args) => {
+      this.log("INFO", ...args);
     };
-  }
-});
-
-// 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;
+    this.debug = (...args) => {
+      this.log("DEBUG", ...args);
     };
-    toMaybeUrl = (originalUrl, modifiedParams) => {
-      const urlToHit = new URL(originalUrl.toString());
-      urlToHit.host = isEmpty(modifiedParams.port) ? `${modifiedParams.host}:${modifiedParams.port}` : modifiedParams.host;
-      return urlToHit;
+    this.error = (...args) => {
+      this.log("ERROR", ...args);
     };
-    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;
-    };
-  }
-});
-
-// 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 nodeFetchAvailable = false;
-    try {
-      __require.resolve("node-fetch");
-      nodeFetchAvailable = true;
-    } catch (e) {
+    const { level, tags = [] } = config;
+    this.tags = tags;
+    if (level && level in LOG_LEVELS) {
+      this.level = LOG_LEVELS[level];
+    } else {
+      this.level = LOG_LEVELS.INFO;
     }
-    if (nodeFetchAvailable) {
-      const nodeFetch = __require("node-fetch");
-      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");
+  }
+  log(level, ...args) {
+    let resolvedLevel;
+    let name = level;
+    if (level in LOG_LEVELS) {
+      resolvedLevel = LOG_LEVELS[level];
     } else {
-      fetchImplementation = fetchCatchDns2(fetch);
-      console.log("Using native fetch");
+      name = "INFO";
+      resolvedLevel = LOG_LEVELS.INFO;
+    }
+    if (resolvedLevel >= this.level) {
+      console.log(name, ...this.tags, ...args);
     }
-    module.exports = fetchImplementation;
   }
-});
-
-// src/common/index.ts
-init_ConductorLogger();
+};
+var noopLogger = {
+  //eslint-disable-next-line
+  debug: (...args) => {
+  },
+  //eslint-disable-next-line
+  info: (...args) => {
+  },
+  //eslint-disable-next-line
+  error: (...args) => {
+  }
+};
 
 // src/common/types.ts
 var TaskType = /* @__PURE__ */ ((TaskType2) => {
@@ -3564,6 +3368,95 @@ 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 = (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
+    };
+    const res = await fetch3(target.toString(), optionsOverride);
+    return res;
+  };
+  return fetchWithDns;
+};
+
 // src/orkes/request/request.ts
 var isDefined2 = (value) => {
   return value !== void 0 && value !== null;
@@ -3859,16 +3752,23 @@ var baseOrkesConductorClient = (fetchFn, baseRequestHandler = defaultRequestHand
 };
 
 // src/orkes/OrkesConductorClient.ts
-var fetchCache = require_fetchImplementation();
-var defaultRequestHandler3 = (__request, config, options) => request2(config, options, fetch);
+import fetch2, { Headers as Headers2 } from "node-fetch";
+var nodeFetchWrapper = async (input, options = {}) => {
+  const res = await fetch2(input.toString(), options);
+  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(
-  //@ts-ignore
   fetchCache,
   defaultRequestHandler3
 );
-
-// src/orkes/index.ts
-init_fetchCatchDns2();
 export {
   ApiError,
   AuthConductorClient,