@cuylabs/agent-runtime-dapr 0.5.0

package/dist/chunk-A34CHK2E.js

@@ -0,0 +1,283 @@
+// src/client.ts
+var _otelClient = null;
+async function tryGetOtelPropagation() {
+  if (_otelClient === false) return null;
+  if (_otelClient) return _otelClient;
+  try {
+    _otelClient = await import("@opentelemetry/api");
+    return _otelClient;
+  } catch {
+    _otelClient = false;
+    return null;
+  }
+}
+var DEFAULT_DAPR_HTTP_ENDPOINT = "http://127.0.0.1:3500";
+var DEFAULT_REQUEST_TIMEOUT_MS = 15e3;
+var DEFAULT_MAX_REQUEST_RETRIES = 2;
+var DEFAULT_VERIFY_SIDECAR_ON_START = true;
+var DaprHttpError = class extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.name = "DaprHttpError";
+    this.status = status;
+  }
+};
+function trimTrailingSlash(input) {
+  return input.replace(/\/+$/, "");
+}
+function ensureNonEmpty(input, label) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error(`${label} must not be empty`);
+  }
+  return trimmed;
+}
+function ensurePositiveInt(input, label) {
+  if (!Number.isFinite(input)) {
+    throw new Error(`${label} must be a finite number`);
+  }
+  const normalized = Math.floor(input);
+  if (normalized <= 0) {
+    throw new Error(`${label} must be greater than zero`);
+  }
+  return normalized;
+}
+function ensureNonNegativeInt(input, label) {
+  if (!Number.isFinite(input)) {
+    throw new Error(`${label} must be a finite number`);
+  }
+  const normalized = Math.floor(input);
+  if (normalized < 0) {
+    throw new Error(`${label} must be zero or greater`);
+  }
+  return normalized;
+}
+function parseJson(text) {
+  if (!text) {
+    return void 0;
+  }
+  return JSON.parse(text);
+}
+function isRetryableStatusCode(status) {
+  return [408, 425, 429, 500, 502, 503, 504].includes(status);
+}
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+function isRetryableError(error) {
+  if (isAbortError(error)) {
+    return true;
+  }
+  if (error instanceof TypeError) {
+    return true;
+  }
+  return false;
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function isDaprConflictError(error) {
+  return error instanceof DaprHttpError && error.status === 409;
+}
+var DaprSidecarClient = class {
+  stateStoreName;
+  daprHttpEndpoint;
+  apiToken;
+  fetchImpl;
+  requestTimeoutMs;
+  maxRequestRetries;
+  verifySidecarOnStart;
+  constructor(options) {
+    this.daprHttpEndpoint = trimTrailingSlash(
+      options.daprHttpEndpoint ?? DEFAULT_DAPR_HTTP_ENDPOINT
+    );
+    this.stateStoreName = options.stateStoreName ? ensureNonEmpty(options.stateStoreName, "stateStoreName") : void 0;
+    this.apiToken = options.apiToken?.trim() || void 0;
+    this.requestTimeoutMs = ensurePositiveInt(
+      options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
+      "requestTimeoutMs"
+    );
+    this.maxRequestRetries = ensureNonNegativeInt(
+      options.maxRequestRetries ?? DEFAULT_MAX_REQUEST_RETRIES,
+      "maxRequestRetries"
+    );
+    this.verifySidecarOnStart = options.verifySidecarOnStart ?? DEFAULT_VERIFY_SIDECAR_ON_START;
+    if (options.fetch) {
+      this.fetchImpl = options.fetch;
+    } else if (typeof globalThis.fetch === "function") {
+      this.fetchImpl = globalThis.fetch.bind(globalThis);
+    } else {
+      throw new Error(
+        "No fetch implementation available. Provide options.fetch."
+      );
+    }
+  }
+  async verifySidecar() {
+    if (!this.verifySidecarOnStart) {
+      return;
+    }
+    try {
+      await this.request("/v1.0/metadata", { method: "GET" }, [200]);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Failed to verify Dapr sidecar on start at ${this.daprHttpEndpoint}: ${detail}`
+      );
+    }
+  }
+  async getStateEntry(key) {
+    const stateStoreName = this.requireStateStoreName();
+    const response = await this.request(
+      `/v1.0/state/${encodeURIComponent(stateStoreName)}/${encodeURIComponent(key)}`,
+      { method: "GET" },
+      [200, 204, 404]
+    );
+    if (response.status === 404 || response.status === 204) {
+      return {};
+    }
+    const text = await response.text();
+    if (!text.trim()) {
+      return {};
+    }
+    return {
+      value: parseJson(text),
+      etag: response.headers.get("etag")?.trim() || response.headers.get("ETag")?.trim() || void 0
+    };
+  }
+  async getState(key) {
+    return (await this.getStateEntry(key)).value;
+  }
+  async saveState(key, value, options = {}) {
+    const stateStoreName = this.requireStateStoreName();
+    const payload = [
+      {
+        key,
+        value,
+        ...options.etag ? { etag: options.etag } : {},
+        ...options.concurrency ? { options: { concurrency: options.concurrency } } : {}
+      }
+    ];
+    await this.request(
+      `/v1.0/state/${encodeURIComponent(stateStoreName)}`,
+      {
+        method: "POST",
+        body: JSON.stringify(payload)
+      },
+      [200, 201, 204],
+      true
+    );
+  }
+  async deleteState(key) {
+    const stateStoreName = this.requireStateStoreName();
+    await this.request(
+      `/v1.0/state/${encodeURIComponent(stateStoreName)}/${encodeURIComponent(key)}`,
+      { method: "DELETE" },
+      [200, 204, 404]
+    );
+  }
+  async queryState(query) {
+    const stateStoreName = this.requireStateStoreName();
+    return await this.requestJson(
+      `/v1.0-alpha1/state/${encodeURIComponent(stateStoreName)}/query`,
+      {
+        method: "POST",
+        body: JSON.stringify(query)
+      },
+      [200, 204]
+    );
+  }
+  async requestJson(path, init, allowedStatusCodes) {
+    const response = await this.request(path, init, allowedStatusCodes, true);
+    const text = await response.text();
+    if (!text.trim()) {
+      return void 0;
+    }
+    return parseJson(text);
+  }
+  async request(path, init, allowedStatusCodes, withJsonContentType = false) {
+    const headers = new Headers(init.headers);
+    if (withJsonContentType && !headers.has("content-type")) {
+      headers.set("content-type", "application/json");
+    }
+    if (this.apiToken && !headers.has("dapr-api-token")) {
+      headers.set("dapr-api-token", this.apiToken);
+    }
+    const otelMod = await tryGetOtelPropagation();
+    if (otelMod) {
+      otelMod.propagation.inject(otelMod.context.active(), headers, {
+        set(carrier, key, value) {
+          carrier.set(key, value);
+        }
+      });
+    }
+    const method = (init.method ?? "GET").toUpperCase();
+    for (let attempt = 0; attempt <= this.maxRequestRetries; attempt += 1) {
+      const timeoutController = new AbortController();
+      const timeout = setTimeout(() => {
+        timeoutController.abort();
+      }, this.requestTimeoutMs);
+      timeout.unref?.();
+      try {
+        const response = await this.fetchImpl(
+          `${this.daprHttpEndpoint}${path}`,
+          {
+            ...init,
+            method,
+            headers,
+            signal: timeoutController.signal
+          }
+        );
+        if (allowedStatusCodes.includes(response.status)) {
+          return response;
+        }
+        const body = await response.text().catch(() => "");
+        const retryable = isRetryableStatusCode(response.status);
+        if (retryable && attempt < this.maxRequestRetries) {
+          await sleep(100 * 2 ** attempt);
+          continue;
+        }
+        throw new DaprHttpError(
+          response.status,
+          `Dapr request failed (${response.status}) ${method} ${path}${body ? `: ${body}` : ""}`
+        );
+      } catch (error) {
+        if (isAbortError(error)) {
+          if (attempt < this.maxRequestRetries) {
+            await sleep(100 * 2 ** attempt);
+            continue;
+          }
+          throw new Error(
+            `Dapr request timed out after ${this.requestTimeoutMs}ms: ${method} ${path}`
+          );
+        }
+        if (isRetryableError(error) && attempt < this.maxRequestRetries) {
+          await sleep(100 * 2 ** attempt);
+          continue;
+        }
+        if (error instanceof Error) {
+          throw error;
+        }
+        throw new Error(String(error));
+      } finally {
+        clearTimeout(timeout);
+      }
+    }
+    throw new Error(`Dapr request failed after retries: ${method} ${path}`);
+  }
+  requireStateStoreName() {
+    if (!this.stateStoreName) {
+      throw new Error(
+        "This DaprSidecarClient instance was created without a stateStoreName."
+      );
+    }
+    return this.stateStoreName;
+  }
+};
+
+export {
+  isDaprConflictError,
+  DaprSidecarClient
+};