@darwinso/sdk 0.1.0

package/generated/cjs/core/fetcher/makeRequest.js

@@ -0,0 +1,106 @@
+'use strict';
+var __awaiter =
+  (this && this.__awaiter) ||
+  function (thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P
+        ? value
+        : new P(function (resolve) {
+            resolve(value);
+          });
+    }
+    return new (P || (P = Promise))(function (resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator['throw'](value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function step(result) {
+        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.makeRequest = void 0;
+exports.isCacheNoStoreSupported = isCacheNoStoreSupported;
+exports.resetCacheNoStoreSupported = resetCacheNoStoreSupported;
+const signals_js_1 = require('./signals.js');
+/**
+ * Cached result of checking whether the current runtime supports
+ * the `cache` option in `Request`. Some runtimes (e.g. Cloudflare Workers)
+ * throw a TypeError when this option is used.
+ */
+let _cacheNoStoreSupported;
+function isCacheNoStoreSupported() {
+  if (_cacheNoStoreSupported != null) {
+    return _cacheNoStoreSupported;
+  }
+  try {
+    new Request('http://localhost', { cache: 'no-store' });
+    _cacheNoStoreSupported = true;
+  } catch (_a) {
+    _cacheNoStoreSupported = false;
+  }
+  return _cacheNoStoreSupported;
+}
+/**
+ * Reset the cached result of `isCacheNoStoreSupported`. Exposed for testing only.
+ */
+function resetCacheNoStoreSupported() {
+  _cacheNoStoreSupported = undefined;
+}
+const makeRequest = (
+  fetchFn,
+  url,
+  method,
+  headers,
+  requestBody,
+  timeoutMs,
+  abortSignal,
+  withCredentials,
+  duplex,
+  disableCache,
+) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    const signals = [];
+    let timeoutAbortId;
+    if (timeoutMs != null) {
+      const { signal, abortId } = (0, signals_js_1.getTimeoutSignal)(timeoutMs);
+      timeoutAbortId = abortId;
+      signals.push(signal);
+    }
+    if (abortSignal != null) {
+      signals.push(abortSignal);
+    }
+    const newSignals = (0, signals_js_1.anySignal)(signals);
+    const response = yield fetchFn(
+      url,
+      Object.assign(
+        {
+          method: method,
+          headers,
+          body: requestBody,
+          signal: newSignals,
+          credentials: withCredentials ? 'include' : undefined,
+          // @ts-ignore
+          duplex,
+        },
+        disableCache && isCacheNoStoreSupported() ? { cache: 'no-store' } : {},
+      ),
+    );
+    if (timeoutAbortId != null) {
+      clearTimeout(timeoutAbortId);
+    }
+    return response;
+  });
+exports.makeRequest = makeRequest;

package/generated/cjs/core/fetcher/redactUrl.d.ts

@@ -0,0 +1,2 @@
+export declare const SENSITIVE_QUERY_PARAMS: Set<string>;
+export declare function redactUrl(url: string): string;

package/generated/cjs/core/fetcher/redactUrl.js

@@ -0,0 +1,89 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.SENSITIVE_QUERY_PARAMS = void 0;
+exports.redactUrl = redactUrl;
+exports.SENSITIVE_QUERY_PARAMS = new Set([
+  'api_key',
+  'api-key',
+  'apikey',
+  'token',
+  'access_token',
+  'access-token',
+  'auth_token',
+  'auth-token',
+  'password',
+  'passwd',
+  'secret',
+  'api_secret',
+  'api-secret',
+  'apisecret',
+  'key',
+  'session',
+  'session_id',
+  'session-id',
+]);
+function redactUrl(url) {
+  const protocolIndex = url.indexOf('://');
+  if (protocolIndex === -1) return url;
+  const afterProtocol = protocolIndex + 3;
+  // Find the first delimiter that marks the end of the authority section
+  const pathStart = url.indexOf('/', afterProtocol);
+  let queryStart = url.indexOf('?', afterProtocol);
+  let fragmentStart = url.indexOf('#', afterProtocol);
+  const firstDelimiter = Math.min(
+    pathStart === -1 ? url.length : pathStart,
+    queryStart === -1 ? url.length : queryStart,
+    fragmentStart === -1 ? url.length : fragmentStart,
+  );
+  // Find the LAST @ before the delimiter (handles multiple @ in credentials)
+  let atIndex = -1;
+  for (let i = afterProtocol; i < firstDelimiter; i++) {
+    if (url[i] === '@') {
+      atIndex = i;
+    }
+  }
+  if (atIndex !== -1) {
+    url = `${url.slice(0, afterProtocol)}[REDACTED]@${url.slice(atIndex + 1)}`;
+  }
+  // Recalculate queryStart since url might have changed
+  queryStart = url.indexOf('?');
+  if (queryStart === -1) return url;
+  fragmentStart = url.indexOf('#', queryStart);
+  const queryEnd = fragmentStart !== -1 ? fragmentStart : url.length;
+  const queryString = url.slice(queryStart + 1, queryEnd);
+  if (queryString.length === 0) return url;
+  // FAST PATH: Quick check if any sensitive keywords present
+  // Using indexOf is faster than regex for simple substring matching
+  const lower = queryString.toLowerCase();
+  const hasSensitive =
+    lower.includes('token') ||
+    lower.includes('key') ||
+    lower.includes('password') ||
+    lower.includes('passwd') ||
+    lower.includes('secret') ||
+    lower.includes('session') ||
+    lower.includes('auth');
+  if (!hasSensitive) {
+    return url;
+  }
+  // SLOW PATH: Parse and redact
+  const redactedParams = [];
+  const params = queryString.split('&');
+  for (const param of params) {
+    const equalIndex = param.indexOf('=');
+    if (equalIndex === -1) {
+      redactedParams.push(param);
+      continue;
+    }
+    const key = param.slice(0, equalIndex);
+    let shouldRedact = exports.SENSITIVE_QUERY_PARAMS.has(key.toLowerCase());
+    if (!shouldRedact && key.includes('%')) {
+      try {
+        const decodedKey = decodeURIComponent(key);
+        shouldRedact = exports.SENSITIVE_QUERY_PARAMS.has(decodedKey.toLowerCase());
+      } catch (_a) {}
+    }
+    redactedParams.push(shouldRedact ? `${key}=[REDACTED]` : param);
+  }
+  return url.slice(0, queryStart + 1) + redactedParams.join('&') + url.slice(queryEnd);
+}

package/generated/cjs/core/fetcher/requestWithRetries.d.ts

@@ -0,0 +1 @@
+export declare function requestWithRetries(requestFn: () => Promise<Response>, maxRetries?: number): Promise<Response>;

package/generated/cjs/core/fetcher/requestWithRetries.js

@@ -0,0 +1,91 @@
+'use strict';
+var __awaiter =
+  (this && this.__awaiter) ||
+  function (thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P
+        ? value
+        : new P(function (resolve) {
+            resolve(value);
+          });
+    }
+    return new (P || (P = Promise))(function (resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator['throw'](value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function step(result) {
+        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.requestWithRetries = requestWithRetries;
+const INITIAL_RETRY_DELAY = 1000; // in milliseconds
+const MAX_RETRY_DELAY = 60000; // in milliseconds
+const DEFAULT_MAX_RETRIES = 2;
+const JITTER_FACTOR = 0.2; // 20% random jitter
+function isRetryableStatusCode(statusCode) {
+  return [408, 429].includes(statusCode) || statusCode >= 500;
+}
+function addPositiveJitter(delay) {
+  const jitterMultiplier = 1 + Math.random() * JITTER_FACTOR;
+  return delay * jitterMultiplier;
+}
+function addSymmetricJitter(delay) {
+  const jitterMultiplier = 1 + (Math.random() - 0.5) * JITTER_FACTOR;
+  return delay * jitterMultiplier;
+}
+function getRetryDelayFromHeaders(response, retryAttempt) {
+  const retryAfter = response.headers.get('Retry-After');
+  if (retryAfter) {
+    const retryAfterSeconds = parseInt(retryAfter, 10);
+    if (!Number.isNaN(retryAfterSeconds) && retryAfterSeconds > 0) {
+      return Math.min(retryAfterSeconds * 1000, MAX_RETRY_DELAY);
+    }
+    const retryAfterDate = new Date(retryAfter);
+    if (!Number.isNaN(retryAfterDate.getTime())) {
+      const delay = retryAfterDate.getTime() - Date.now();
+      if (delay > 0) {
+        return Math.min(Math.max(delay, 0), MAX_RETRY_DELAY);
+      }
+    }
+  }
+  const rateLimitReset = response.headers.get('X-RateLimit-Reset');
+  if (rateLimitReset) {
+    const resetTime = parseInt(rateLimitReset, 10);
+    if (!Number.isNaN(resetTime)) {
+      const delay = resetTime * 1000 - Date.now();
+      if (delay > 0) {
+        return addPositiveJitter(Math.min(delay, MAX_RETRY_DELAY));
+      }
+    }
+  }
+  return addSymmetricJitter(Math.min(INITIAL_RETRY_DELAY * Math.pow(2, retryAttempt), MAX_RETRY_DELAY));
+}
+function requestWithRetries(requestFn_1) {
+  return __awaiter(this, arguments, void 0, function* (requestFn, maxRetries = DEFAULT_MAX_RETRIES) {
+    let response = yield requestFn();
+    for (let i = 0; i < maxRetries; ++i) {
+      if (isRetryableStatusCode(response.status)) {
+        const delay = getRetryDelayFromHeaders(response, i);
+        yield new Promise((resolve) => setTimeout(resolve, delay));
+        response = yield requestFn();
+      } else {
+        break;
+      }
+    }
+    return response;
+  });
+}

package/generated/cjs/core/fetcher/signals.d.ts

@@ -0,0 +1,5 @@
+export declare function getTimeoutSignal(timeoutMs: number): {
+  signal: AbortSignal;
+  abortId: ReturnType<typeof setTimeout>;
+};
+export declare function anySignal(...args: AbortSignal[] | [AbortSignal[]]): AbortSignal;

package/generated/cjs/core/fetcher/signals.js

@@ -0,0 +1,36 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.getTimeoutSignal = getTimeoutSignal;
+exports.anySignal = anySignal;
+const TIMEOUT = 'timeout';
+function getTimeoutSignal(timeoutMs) {
+  const controller = new AbortController();
+  const abortId = setTimeout(() => controller.abort(TIMEOUT), timeoutMs);
+  return { signal: controller.signal, abortId };
+}
+function anySignal(...args) {
+  const signals = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+  const controller = new AbortController();
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort(signal === null || signal === void 0 ? void 0 : signal.reason);
+      return controller.signal;
+    }
+    signal.addEventListener(
+      'abort',
+      () => controller.abort(signal === null || signal === void 0 ? void 0 : signal.reason),
+      {
+        signal: controller.signal,
+      },
+    );
+    // Re-check after adding listener: the signal may have aborted
+    // between the initial `signal.aborted` check and the `addEventListener`
+    // call above. If it did, the abort event was already dispatched and
+    // the listener will never fire — we must manually abort.
+    if (signal.aborted) {
+      controller.abort(signal === null || signal === void 0 ? void 0 : signal.reason);
+      return controller.signal;
+    }
+  }
+  return controller.signal;
+}

package/generated/cjs/core/headers.d.ts

@@ -0,0 +1,6 @@
+export declare function mergeHeaders(
+  ...headersArray: (Record<string, unknown> | null | undefined)[]
+): Record<string, unknown>;
+export declare function mergeOnlyDefinedHeaders(
+  ...headersArray: (Record<string, unknown> | null | undefined)[]
+): Record<string, unknown>;

package/generated/cjs/core/headers.js

@@ -0,0 +1,30 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.mergeHeaders = mergeHeaders;
+exports.mergeOnlyDefinedHeaders = mergeOnlyDefinedHeaders;
+function mergeHeaders(...headersArray) {
+  const result = {};
+  for (const [key, value] of headersArray
+    .filter((headers) => headers != null)
+    .flatMap((headers) => Object.entries(headers))) {
+    const insensitiveKey = key.toLowerCase();
+    if (value != null) {
+      result[insensitiveKey] = value;
+    } else if (insensitiveKey in result) {
+      delete result[insensitiveKey];
+    }
+  }
+  return result;
+}
+function mergeOnlyDefinedHeaders(...headersArray) {
+  const result = {};
+  for (const [key, value] of headersArray
+    .filter((headers) => headers != null)
+    .flatMap((headers) => Object.entries(headers))) {
+    const insensitiveKey = key.toLowerCase();
+    if (value != null) {
+      result[insensitiveKey] = value;
+    }
+  }
+  return result;
+}

package/generated/cjs/core/index.d.ts

@@ -0,0 +1,6 @@
+export * from './auth/index.js';
+export * from './base64.js';
+export * from './fetcher/index.js';
+export * as logging from './logging/index.js';
+export * from './runtime/index.js';
+export * as url from './url/index.js';

package/generated/cjs/core/index.js

@@ -0,0 +1,66 @@
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v });
+      }
+    : function (o, v) {
+        o['default'] = v;
+      });
+var __exportStar =
+  (this && this.__exportStar) ||
+  function (m, exports) {
+    for (var p in m)
+      if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+  };
+var __importStar =
+  (this && this.__importStar) ||
+  (function () {
+    var ownKeys = function (o) {
+      ownKeys =
+        Object.getOwnPropertyNames ||
+        function (o) {
+          var ar = [];
+          for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+          return ar;
+        };
+      return ownKeys(o);
+    };
+    return function (mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null)
+        for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== 'default') __createBinding(result, mod, k[i]);
+      __setModuleDefault(result, mod);
+      return result;
+    };
+  })();
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.url = exports.logging = void 0;
+__exportStar(require('./auth/index.js'), exports);
+__exportStar(require('./base64.js'), exports);
+__exportStar(require('./fetcher/index.js'), exports);
+exports.logging = __importStar(require('./logging/index.js'));
+__exportStar(require('./runtime/index.js'), exports);
+exports.url = __importStar(require('./url/index.js'));

package/generated/cjs/core/json.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Serialize a value to JSON
+ * @param value A JavaScript value, usually an object or array, to be converted.
+ * @param replacer A function that transforms the results.
+ * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+ * @returns JSON string
+ */
+export declare const toJson: (
+  value: unknown,
+  replacer?: (this: unknown, key: string, value: unknown) => unknown,
+  space?: string | number,
+) => string;
+/**
+ * Parse JSON string to object, array, or other type
+ * @param text A valid JSON string.
+ * @param reviver A function that transforms the results. This function is called for each member of the object. If a member contains nested objects, the nested objects are transformed before the parent object is.
+ * @returns Parsed object, array, or other type
+ */
+export declare function fromJson<T = unknown>(
+  text: string,
+  reviver?: (this: unknown, key: string, value: unknown) => unknown,
+): T;

package/generated/cjs/core/json.js

@@ -0,0 +1,24 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.toJson = void 0;
+exports.fromJson = fromJson;
+/**
+ * Serialize a value to JSON
+ * @param value A JavaScript value, usually an object or array, to be converted.
+ * @param replacer A function that transforms the results.
+ * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+ * @returns JSON string
+ */
+const toJson = (value, replacer, space) => {
+  return JSON.stringify(value, replacer, space);
+};
+exports.toJson = toJson;
+/**
+ * Parse JSON string to object, array, or other type
+ * @param text A valid JSON string.
+ * @param reviver A function that transforms the results. This function is called for each member of the object. If a member contains nested objects, the nested objects are transformed before the parent object is.
+ * @returns Parsed object, array, or other type
+ */
+function fromJson(text, reviver) {
+  return JSON.parse(text, reviver);
+}

package/generated/cjs/core/logging/exports.d.ts

@@ -0,0 +1,19 @@
+import * as logger from './logger.js';
+
+export declare namespace logging {
+  /**
+   * Configuration for logger instances.
+   */
+  type LogConfig = logger.LogConfig;
+  type LogLevel = logger.LogLevel;
+  const LogLevel: typeof logger.LogLevel;
+  type ILogger = logger.ILogger;
+  /**
+   * Console logger implementation that outputs to the console.
+   */
+  type ConsoleLogger = logger.ConsoleLogger;
+  /**
+   * Console logger implementation that outputs to the console.
+   */
+  const ConsoleLogger: typeof logger.ConsoleLogger;
+}

package/generated/cjs/core/logging/exports.js

@@ -0,0 +1,63 @@
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v });
+      }
+    : function (o, v) {
+        o['default'] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  (function () {
+    var ownKeys = function (o) {
+      ownKeys =
+        Object.getOwnPropertyNames ||
+        function (o) {
+          var ar = [];
+          for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+          return ar;
+        };
+      return ownKeys(o);
+    };
+    return function (mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null)
+        for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== 'default') __createBinding(result, mod, k[i]);
+      __setModuleDefault(result, mod);
+      return result;
+    };
+  })();
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.logging = void 0;
+const logger = __importStar(require('./logger.js'));
+var logging;
+(function (logging) {
+  logging.LogLevel = logger.LogLevel;
+  /**
+   * Console logger implementation that outputs to the console.
+   */
+  logging.ConsoleLogger = logger.ConsoleLogger;
+})(logging || (exports.logging = logging = {}));

package/generated/cjs/core/logging/index.d.ts

@@ -0,0 +1 @@
+export * from './logger.js';

package/generated/cjs/core/logging/index.js

@@ -0,0 +1,29 @@
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __exportStar =
+  (this && this.__exportStar) ||
+  function (m, exports) {
+    for (var p in m)
+      if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+__exportStar(require('./logger.js'), exports);