@settlemint/dalp-sdk 3.1.10 → 3.1.11-main.33538712635

package/dist/chunk-y0d2c7kp.js

@@ -0,0 +1,54 @@
+// src/errors/sdk-error.ts
+var DALP_SDK_ERROR_CODE = "DALP_SDK_ERROR";
+var DALP_SDK_ERROR_CATEGORY = "sdk.configuration";
+
+class DalpSdkError extends Error {
+  code;
+  category;
+  status;
+  retryable;
+  why;
+  fix;
+  details;
+  retryAfterSeconds;
+  constructor(options) {
+    super(options.message, { cause: options.cause });
+    this.name = "DalpSdkError";
+    this.code = options.code ?? DALP_SDK_ERROR_CODE;
+    this.category = options.category;
+    this.status = options.status;
+    this.retryable = options.retryable;
+    this.why = options.why;
+    this.fix = options.fix;
+    this.details = options.details;
+    this.retryAfterSeconds = options.retryAfterSeconds;
+  }
+  toJSON() {
+    return {
+      name: "DalpSdkError",
+      code: this.code,
+      category: this.category,
+      retryable: this.retryable,
+      message: this.message,
+      why: this.why,
+      fix: this.fix,
+      ...this.status === undefined ? {} : { status: this.status },
+      ...this.details === undefined ? {} : { details: this.details },
+      ...this.retryAfterSeconds === undefined ? {} : { retryAfterSeconds: this.retryAfterSeconds }
+    };
+  }
+}
+function createDalpSdkConfigurationError(input) {
+  return new DalpSdkError({
+    code: DALP_SDK_ERROR_CODE,
+    category: DALP_SDK_ERROR_CATEGORY,
+    status: 400,
+    retryable: false,
+    message: input.message,
+    why: input.why,
+    fix: input.fix,
+    cause: input.cause
+  });
+}
+
+export { DalpSdkError, createDalpSdkConfigurationError };

package/dist/client/conditional-request.d.ts

@@ -0,0 +1,16 @@
+import type { Client } from "../generated/client/types.gen.ts";
+/** Drop every held ETag/body for this client. Call on sign-out and organization switch. */
+export declare function clearConditionalRequestStore(client: Client): void;
+/**
+ * Install one per-client If-None-Match / 304 rewrite pair for conditional GET.
+ *
+ * Server ETags must be strong content digests computed after authorization
+ * inside the requester's partition. The dapi response cache guarantees this:
+ * `encodeResponseCacheEntry` sets `etag` to the SHA-256 of the serialized
+ * body after the request-context middleware has authenticated the session.
+ * Version-stamp ETags (generation counters, watermarks, table versions) are
+ * forbidden for conditional-request adopters — a stamp can collide across
+ * tenants or lag a body change and would let this store serve another
+ * partition's bytes as a 200.
+ */
+export declare function installConditionalRequestInterceptors(client: Client): void;

package/dist/client/factory.d.ts

@@ -0,0 +1,39 @@
+import type { Client } from "../generated/client/types.gen.ts";
+import { Secret } from "../secret.ts";
+import { type DalpFetch } from "./ssr-fetch.ts";
+export type { DalpFetch } from "./ssr-fetch.ts";
+export interface DalpClientContext {
+    readonly organizationId?: string;
+    readonly participant?: string;
+    readonly executor?: "eoa" | "smart-wallet";
+    readonly chainId?: number | string;
+    readonly selectedSigners?: ReadonlyArray<string>;
+    readonly idempotencyKey?: string;
+}
+export interface DalpSsrOptions {
+    readonly requestHeaders: HeadersInit;
+    readonly allowedOrigins?: ReadonlyArray<string | URL>;
+}
+export interface CreateDalpClientOptions {
+    readonly baseUrl: string | URL;
+    readonly apiKey?: string | Secret;
+    readonly context?: DalpClientContext;
+    readonly fetch?: DalpFetch;
+    readonly runtime?: "browser" | "server";
+    readonly ssr?: DalpSsrOptions;
+}
+/** Build per-operation headers which override an instance's default acting context. */
+export declare function createDalpContextHeaders(context: DalpClientContext): Headers;
+/**
+ * Create one generated client instance for one caller or SSR request.
+ *
+ * Credential ownership matrix:
+ *
+ * | Credential | Owner | Client policy |
+ * | --- | --- | --- |
+ * | Session cookie | Browser and session server | Browsers use `credentials: include`; SSR forwards only the current inbound cookie. The SDK never parses, stores, or rewrites `Set-Cookie`, so Secure, HttpOnly, SameSite, expiry, and logout stay server-owned. |
+ * | API key | Server or CLI process | Injected from this per-instance factory only; never place it in a browser bundle. |
+ * | Webhook and bundler secret | Server integration | Not accepted by this REST client; the owning integration keeps rotation sets. |
+ * | Test key | Test fixture | Use a dedicated throwaway key, never a production credential. |
+ */
+export declare function createDalpClient(options: CreateDalpClientOptions): Client;

package/dist/client/query-serializer.d.ts

@@ -0,0 +1,2 @@
+/** Serialize generated SDK query objects with recursive OpenAPI deepObject keys. */
+export declare function serializeDalpQuery(query: unknown): string;

package/dist/client/request-compression.d.ts

@@ -0,0 +1,47 @@
+import type { DalpFetch } from "./ssr-fetch.ts";
+/**
+ * Request-body compression for DALP server/CLI clients.
+ *
+ * Bun 1.4 added a `compress` fetch option: it compresses a buffered body
+ * before sending and sets `Content-Encoding` on the wire. This wrapper opts
+ * eligible outgoing bodies into gzip so big JSON payloads shrink in transit;
+ * the receiving DAPI host decodes them at its boundary
+ * (`@dapi/server/request-body-decoding`), so callers need no per-route work.
+ *
+ * Eligibility mirrors what the transport can actually do:
+ *
+ * - Only body-bearing methods (`GET`/`HEAD` never).
+ * - Bodies already carrying `Content-Encoding`, or an explicit caller
+ *   `compress`, pass through untouched.
+ * - With `(url, init)` the body must be one of Bun's buffered types
+ *   (string, ArrayBuffer, TypedArray/DataView, Blob) and fall inside the
+ *   size window — gzip framing dominates tiny payloads, and huge explicitly
+ *   sized bodies stay uncompressed (the DAPI decode cap mirrors this bound).
+ * - Streams, `FormData`, and `URLSearchParams` pass through: the transport
+ *   forwards streaming bodies unchanged.
+ * - A `Request` instance is measured through a bounded clone before compression.
+ */
+/** Bodies smaller than this stay uncompressed; gzip framing dominates tiny JSON. */
+export declare const DALP_SDK_REQUEST_COMPRESSION_MIN_BODY_BYTES = 1024;
+/** Explicitly-sized bodies larger than this are sent uncompressed. */
+export declare const DALP_SDK_REQUEST_COMPRESSION_MAX_BODY_BYTES = 16777216;
+/**
+ * Bun's `compress` fetch option. bun-types 1.4.0 still types `RequestInit`
+ * from lib.dom without it, so the field is declared here and set through one
+ * narrow cast at the transport seam.
+ */
+export type FetchRequestCompression = true | "gzip" | "deflate" | "br" | "zstd";
+export interface CompressionRequestInit extends RequestInit {
+    readonly compress?: FetchRequestCompression;
+}
+export interface RequestBodyCompressionOptions {
+    /** Test seam overriding DALP_SDK_REQUEST_COMPRESSION_MIN_BODY_BYTES. */
+    readonly minBodyBytes?: number;
+    /** Test seam overriding DALP_SDK_REQUEST_COMPRESSION_MAX_BODY_BYTES. */
+    readonly maxBodyBytes?: number;
+}
+/**
+ * Wrap a fetch seam so eligible request bodies travel gzip-compressed.
+ * Ineligible calls forward the original arguments untouched.
+ */
+export declare function withRequestBodyCompression(fetchImpl: DalpFetch, options?: RequestBodyCompressionOptions): DalpFetch;

package/dist/client/ssr-fetch.d.ts

@@ -0,0 +1,12 @@
+/** Minimal fetch shape — Bun's `typeof fetch` also requires `preconnect`. */
+export type DalpFetch = ((input: RequestInfo | URL, init?: RequestInit) => Promise<Response>) & {
+    readonly preconnect?: typeof fetch.preconnect;
+};
+export interface CreateSsrFetchOptions {
+    readonly allowedOrigins?: ReadonlyArray<string | URL>;
+    readonly baseUrl: string | URL;
+    readonly fetch: DalpFetch;
+    readonly requestHeaders: HeadersInit;
+}
+/** Direct destinations must be approved; unapproved redirects lose all caller credentials and context. */
+export declare function createSsrFetch(options: CreateSsrFetchOptions): DalpFetch;

package/dist/errors/api-error.d.ts

@@ -0,0 +1,29 @@
+import { findCurrentError } from "./find-current-error.ts";
+export type DalpApiErrorCategory = "client" | "auth" | "permission" | "domain" | "contract" | "dependency" | "operational" | "config" | "unknown";
+export interface DalpApiErrorOptions {
+    readonly message: string;
+    readonly cause?: unknown;
+    readonly id?: string;
+    readonly code: string;
+    readonly category: DalpApiErrorCategory;
+    readonly status?: number;
+    readonly retryable: boolean;
+    readonly why: string;
+    readonly fix: string;
+    readonly retryAfterSeconds?: number;
+}
+export declare class DalpApiError extends Error {
+    readonly id?: string;
+    readonly code: string;
+    readonly category: DalpApiErrorCategory;
+    readonly status?: number;
+    readonly retryable: boolean;
+    readonly why: string;
+    readonly fix: string;
+    readonly retryAfterSeconds?: number;
+    constructor(options: DalpApiErrorOptions);
+    static make(options: DalpApiErrorOptions): DalpApiError;
+}
+export declare const isDalpApiError: (error: unknown) => error is DalpApiError;
+export declare const findDalpSdkError: typeof findCurrentError;
+export declare const makeDalpApiError: (error: unknown) => DalpApiError;

package/dist/errors/find-current-error.d.ts

@@ -0,0 +1,8 @@
+import { DalpSdkError } from "./sdk-error.ts";
+/**
+ * Walk a nested SDK error graph and return the first DalpSdkError.
+ *
+ * Follows `cause` and `reasons[].error` / `reasons[].defect`. Stops after
+ * `maxNodes` so a cyclic wrapper cannot loop forever.
+ */
+export declare const findCurrentError: (error: unknown, maxNodes?: number) => DalpSdkError | undefined;

package/dist/errors/sdk-error.d.ts

@@ -0,0 +1,52 @@
+export interface DalpSdkErrorOptions {
+    readonly code?: string;
+    readonly category: string;
+    readonly status?: number;
+    readonly retryable: boolean;
+    readonly message: string;
+    readonly why: string;
+    readonly fix: string;
+    readonly details?: DalpSdkErrorDetails;
+    readonly retryAfterSeconds?: number;
+    readonly cause?: unknown;
+}
+/** JSON-compatible value attached to a serialized SDK error. */
+export type DalpSdkJsonValue = null | boolean | number | string | ReadonlyArray<DalpSdkJsonValue> | DalpSdkJsonObject;
+/** JSON object attached to a serialized SDK error. */
+export interface DalpSdkJsonObject {
+    readonly [key: string]: DalpSdkJsonValue;
+}
+export type DalpSdkErrorDetails = DalpSdkJsonObject;
+export interface DalpSdkConfigurationErrorInput {
+    readonly message: string;
+    readonly why: string;
+    readonly fix: string;
+    readonly cause?: unknown;
+}
+export interface DalpSdkErrorJson {
+    readonly name: "DalpSdkError";
+    readonly code: string;
+    readonly category: string;
+    readonly status?: number;
+    readonly retryable: boolean;
+    readonly message: string;
+    readonly why: string;
+    readonly fix: string;
+    readonly details?: DalpSdkErrorDetails;
+    readonly retryAfterSeconds?: number;
+}
+/** SDK-owned configuration or auxiliary-adapter failure. API calls expose route errors directly. */
+export declare class DalpSdkError extends Error {
+    readonly code: string;
+    readonly category: string;
+    readonly status?: number;
+    readonly retryable: boolean;
+    readonly why: string;
+    readonly fix: string;
+    readonly details?: DalpSdkErrorDetails;
+    readonly retryAfterSeconds?: number;
+    constructor(options: Readonly<DalpSdkErrorOptions>);
+    toJSON(): DalpSdkErrorJson;
+}
+/** Build the one SDK-owned error used for invalid client construction. */
+export declare function createDalpSdkConfigurationError(input: Readonly<DalpSdkConfigurationErrorInput>): DalpSdkError;

package/dist/errors/sdk-error.js

@@ -0,0 +1,8 @@
+import {
+  DalpSdkError,
+  createDalpSdkConfigurationError
+} from "../chunk-y0d2c7kp.js";
+export {
+  DalpSdkError,
+  createDalpSdkConfigurationError
+};