@settlemint/dalp-sdk 3.1.18-main.33808370488 → 3.1.18

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

@@ -1,47 +0,0 @@
-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

@@ -1,12 +0,0 @@
-/** 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/effect.d.ts

@@ -1,69 +0,0 @@
-/**
- * The Effect call surface.
- *
- * The same namespaced tree as the root entry, returning `Effect` values instead
- * of promises. It exists because the CLI and other code under our control want
- * Effect, and hiding it behind promises there would mean unwrapping and
- * rewrapping at every boundary.
- *
- * This entry is deliberately absent from `PUBLISHED_ENTRIES` in
- * `scripts/check-zero-effect.ts`. That gate walks the import graph from every
- * listed entry and fails on any reachable `effect` module, and Bun's transpiler
- * reports a type-only import exactly like a value one. Keeping this entry off
- * the list is what lets the root stay provably Effect-free while this one uses
- * Effect freely.
- *
- * Errors are tagged from the wire envelope rather than decoded from per-route
- * schemas. The envelope is identical across every route (`code`, `status`,
- * `message`, and a `data` carrying the stable DALP id), so one reader covers
- * 759 routes, and no runtime schema ships.
- *
- * @module
- */
-import * as Effect from "effect/Effect";
-import type { DalpApi, DalpRouteId, DalpRouteTypes } from "./generated/api-types.d.ts";
-import { type CallOptions } from "./proxy/builder.ts";
-import { type CreateDalpClientOptions } from "./proxy/transport.ts";
-/** The failure channel every route call carries. */
-export declare class DalpRequestError extends Error {
-    readonly _tag = "DalpRequestError";
-    /** Stable DALP error id when the platform supplied one, else the SDK code. */
-    readonly id: string;
-    readonly status: number | undefined;
-    readonly retryable: boolean;
-    readonly routeId: string;
-    constructor(routeId: string, cause: unknown);
-}
-/** The Effect-shaped mirror of `DalpApi`. */
-export type DalpEffectApi = DalpEffectApiNode<DalpApi>;
-/**
- * A stream leaf answers with its frame sequence rather than one body, so it is
- * matched before the promise leaf: its call signature returns an `AsyncIterable`
- * and would otherwise fall through to the recursive branch, which maps a call
- * signature to an object with no keys and leaves the route uncallable.
- */
-type DalpEffectApiNode<T> = {
-    readonly [K in keyof T]: T[K] extends (...args: infer Args) => AsyncIterable<infer Frame> ? (...args: Args) => Effect.Effect<AsyncIterable<Frame>, DalpRequestError> : T[K] extends (...args: infer Args) => Promise<infer A> ? (...args: Args) => Effect.Effect<A, DalpRequestError> : DalpEffectApiNode<T[K]>;
-};
-/** The routes that answer with `text/event-stream`, named by the route table. */
-export type DalpStreamingRouteId = {
-    [Id in DalpRouteId]: DalpRouteTypes[Id]["streaming"] extends true ? Id : never;
-}[DalpRouteId];
-export interface DalpEffectClient {
-    readonly api: DalpEffectApi;
-    /**
-     * Two signatures rather than one conditional return type. A caller generic over
-     * the streaming routes has to resolve the frame sequence from its own
-     * constraint, and a conditional keyed on `Id` stays unresolved until `Id` is a
-     * single route, which is what pushed every such caller into an assertion.
-     */
-    readonly execute: {
-        <Id extends DalpStreamingRouteId>(routeId: Id, input?: DalpRouteTypes[Id]["request"], options?: CallOptions): Effect.Effect<AsyncIterable<DalpRouteTypes[Id]["response"]>, DalpRequestError>;
-        <Id extends DalpRouteId>(routeId: Id, input?: DalpRouteTypes[Id]["request"], options?: CallOptions): Effect.Effect<DalpRouteTypes[Id]["response"], DalpRequestError>;
-    };
-}
-/** Create the Effect client. Same routes, same transport, different channel. */
-export declare function createDalpEffectClient(options: CreateDalpClientOptions): DalpEffectClient;
-export type { CallOptions } from "./proxy/builder.ts";
-export type { CreateDalpClientOptions } from "./proxy/transport.ts";
-export type { DalpRouteId, DalpRouteTypes } from "./generated/api-types.d.ts";

package/dist/effect.js

@@ -1,82 +0,0 @@
-import {
-  buildProxy,
-  findRoute
-} from "./chunk-f4t1bm86.js";
-import {
-  DalpApiError,
-  createTransport,
-  queryKeyFor,
-  sendRequest,
-  streamRequest
-} from "./chunk-def7rqy6.js";
-import"./chunk-fjnq61hj.js";
-import {
-  data
-} from "./chunk-9k284df4.js";
-import"./chunk-h12fatty.js";
-import"./chunk-y0d2c7kp.js";
-
-// src/effect.ts
-import * as Effect from "effect/Effect";
-class DalpRequestError extends Error {
-  _tag = "DalpRequestError";
-  id;
-  status;
-  retryable;
-  routeId;
-  constructor(routeId, cause) {
-    const api = cause instanceof DalpApiError ? cause : undefined;
-    super(api?.message ?? `DALP request failed for ${routeId}`, { cause });
-    this.name = "DalpRequestError";
-    this._tag = "DalpRequestError";
-    this.routeId = routeId;
-    this.id = api?.code ?? "sdk.transport.REQUEST_FAILED";
-    this.status = api?.status;
-    this.retryable = api?.retryable ?? true;
-  }
-}
-function runRoute(transport, route, id, input, options) {
-  return Effect.callback((resume) => {
-    const controller = new AbortController;
-    const signal = options?.signal ?? controller.signal;
-    const run = async () => {
-      try {
-        resume(Effect.succeed(route.serializer === "sse" ? streamRequest(transport, route, input, { ...options, signal }) : await sendRequest(transport, route, input, { ...options, signal })));
-      } catch (error) {
-        resume(Effect.fail(new DalpRequestError(id, error)));
-      }
-    };
-    run();
-    return Effect.sync(() => {
-      controller.abort();
-    });
-  });
-}
-function createDalpEffectClient(options) {
-  const transport = createTransport(options);
-  const executor = (route, id, input, callOptions) => runRoute(transport, route, id, input, callOptions);
-  const factories = {
-    queryOptions: (route, id, input, callOptions) => ({
-      queryKey: queryKeyFor(id, input),
-      queryFn: () => runRoute(transport, route, id, input, callOptions)
-    }),
-    mutationOptions: (route, id, callOptions) => ({
-      mutationKey: ["dalp", id],
-      mutationFn: (input) => runRoute(transport, route, id, input, callOptions)
-    })
-  };
-  return {
-    api: buildProxy(data, executor, factories),
-    execute: (routeId, input, callOptions) => {
-      const route = findRoute(data, routeId);
-      if (route === undefined) {
-        return Effect.fail(new DalpRequestError(routeId, new TypeError(`Unknown DALP route \`${routeId}\``)));
-      }
-      return runRoute(transport, route, routeId, input, callOptions);
-    }
-  };
-}
-export {
-  DalpRequestError,
-  createDalpEffectClient
-};

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

@@ -1,29 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

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