npm - @kontor/kontor-sdk - Versions diffs - 1.0.0-alpha.0 - Mend

@kontor/kontor-sdk 1.0.0-alpha.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1096) hide show

package/src/sdk/utils/rpc/http.ts ADDED Viewed

@@ -0,0 +1,176 @@
+import {
+  HttpRequestError,
+  type HttpRequestErrorType as HttpRequestErrorType_,
+  TimeoutError,
+  type TimeoutErrorType,
+} from "../../errors/request.js";
+import type { ErrorType } from "../../errors/utils.js";
+import type { RpcRequest, RpcResponse } from "../../types/rpc.js";
+import type { MaybePromise } from "../../types/utils.js";
+import {
+  type WithTimeoutErrorType,
+  withTimeout,
+} from "../promise/with-timeout.js";
+import { stringify } from "../stringify.js";
+import { idCache } from "./id.js";
+export type HttpRpcClientOptions = {
+  /** Override for the fetch function used to make requests. */
+  fetchFn?:
+    | ((input: string | URL | Request, init?: RequestInit) => Promise<Response>)
+    | undefined;
+  /** Request configuration to pass to `fetch`. */
+  fetchOptions?: Omit<RequestInit, "body"> | undefined;
+  /** A callback to handle the request. */
+  onRequest?:
+    | ((
+        request: Request,
+        init: RequestInit,
+      ) => MaybePromise<
+        void | undefined | (RequestInit & { url?: string | undefined })
+      >)
+    | undefined;
+  /** A callback to handle the response. */
+  onResponse?: ((response: Response) => Promise<void> | void) | undefined;
+  /** The timeout (in ms) for the request. */
+  timeout?: number | undefined;
+};
+export type HttpRpcRequestParameters<
+  body extends RpcRequest | RpcRequest[] = RpcRequest,
+> = {
+  /** The RPC request body. */
+  body: body;
+  /** Override for the fetch function used to make requests. */
+  fetchFn?: HttpRpcClientOptions["fetchFn"] | undefined;
+  /** Request configuration to pass to `fetch`. */
+  fetchOptions?: HttpRpcClientOptions["fetchOptions"] | undefined;
+  /** A callback to handle the response. */
+  onRequest?:
+    | ((
+        request: Request,
+        init: RequestInit,
+      ) => MaybePromise<
+        void | undefined | (RequestInit & { url?: string | undefined })
+      >)
+    | undefined;
+  /** A callback to handle the response. */
+  onResponse?: ((response: Response) => Promise<void> | void) | undefined;
+  /** The timeout (in ms) for the request. */
+  timeout?: HttpRpcClientOptions["timeout"] | undefined;
+};
+export type HttpRpcRequestReturnType<
+  body extends RpcRequest | RpcRequest[] = RpcRequest,
+> = body extends RpcRequest[] ? RpcResponse[] : RpcResponse;
+export type HttpRpcRequestErrorType =
+  | HttpRequestErrorType_
+  | TimeoutErrorType
+  | WithTimeoutErrorType
+  | ErrorType;
+export type HttpRpcClient = {
+  request<body extends RpcRequest | RpcRequest[]>(
+    params: HttpRpcRequestParameters<body>,
+  ): Promise<HttpRpcRequestReturnType<body>>;
+};
+export function getHttpRpcClient(
+  url: string,
+  options: HttpRpcClientOptions = {},
+): HttpRpcClient {
+  return {
+    async request(params) {
+      const {
+        body,
+        fetchFn = options.fetchFn ?? fetch,
+        onRequest = options.onRequest,
+        onResponse = options.onResponse,
+        timeout = options.timeout ?? 10_000,
+      } = params;
+      const fetchOptions = {
+        ...(options.fetchOptions ?? {}),
+        ...(params.fetchOptions ?? {}),
+      };
+      const { headers, method, signal: signal_ } = fetchOptions;
+      try {
+        const response = await withTimeout(
+          async ({ signal }) => {
+            const init: RequestInit = {
+              ...fetchOptions,
+              body: Array.isArray(body)
+                ? stringify(
+                    body.map((body) => ({
+                      jsonrpc: "2.0",
+                      id: body.id ?? idCache.take(),
+                      ...body,
+                    })),
+                  )
+                : stringify({
+                    jsonrpc: "2.0",
+                    id: body.id ?? idCache.take(),
+                    ...body,
+                  }),
+              headers: {
+                "Content-Type": "application/json",
+                ...headers,
+              },
+              method: method || "POST",
+              signal: signal_ || (timeout > 0 ? signal : null),
+            };
+            const request = new Request(url, init);
+            const args = (await onRequest?.(request, init)) ?? { ...init, url };
+            const response = await fetchFn(args.url ?? url, args);
+            return response;
+          },
+          {
+            errorInstance: new TimeoutError({ body, url }),
+            timeout,
+            signal: true,
+          },
+        );
+        if (onResponse) await onResponse(response);
+        let data: any;
+        if (
+          response.headers.get("Content-Type")?.startsWith("application/json")
+        )
+          data = await response.json();
+        else {
+          data = await response.text();
+          try {
+            data = JSON.parse(data || "{}");
+          } catch (err) {
+            if (response.ok) throw err;
+            data = { error: data };
+          }
+        }
+        if (!response.ok) {
+          throw new HttpRequestError({
+            body,
+            details: stringify(data.error) || response.statusText,
+            headers: response.headers,
+            status: response.status,
+            url,
+          });
+        }
+        return data;
+      } catch (err) {
+        if (err instanceof HttpRequestError) throw err;
+        if (err instanceof TimeoutError) throw err;
+        throw new HttpRequestError({
+          body,
+          cause: err as Error,
+          url,
+        });
+      }
+    },
+  };
+}

package/src/sdk/utils/rpc/id.ts ADDED Viewed

@@ -0,0 +1,13 @@
+function createIdStore() {
+  return {
+    current: 0,
+    take() {
+      return this.current++;
+    },
+    reset() {
+      this.current = 0;
+    },
+  };
+}
+export const idCache = /*#__PURE__*/ createIdStore();

package/src/sdk/utils/stringify.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import type { ErrorType } from "../errors/utils.js";
+export type StringifyErrorType = ErrorType;
+export const stringify: typeof JSON.stringify = (value, replacer, space) =>
+  JSON.stringify(
+    value,
+    (key, value_) => {
+      const value = typeof value_ === "bigint" ? value_.toString() : value_;
+      return typeof replacer === "function" ? replacer(key, value) : value;
+    },
+    space,
+  );

package/src/sdk/utils/uid.ts ADDED Viewed

@@ -0,0 +1,14 @@
+const size = 256;
+let index = size;
+let buffer: string;
+export function uid(length = 11) {
+  if (!buffer || index + length > size * 2) {
+    buffer = "";
+    index = 0;
+    for (let i = 0; i < size; i++) {
+      buffer += ((256 + Math.random() * 256) | 0).toString(16).substring(1);
+    }
+  }
+  return buffer.substring(index, index++ + length);
+}

package/src/sdk/utils/wait.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export async function wait(time: number) {
+  return new Promise((res) => setTimeout(res, time));
+}

package/src/sdk/utils/wit/codecs/decimal.ts ADDED Viewed

@@ -0,0 +1,215 @@
+import * as z from "zod";
+import type { CodecConstructor, CodecInstance, WaveExpr } from "./types.js";
+type Decimal_ = [bigint, number];
+const TARGET_SCALE = 18;
+const U64_MAX = (1n << 64n) - 1n;
+export const U64 = z
+  .bigint()
+  .min(0n, { message: "must be ≥ 0" })
+  .max(U64_MAX, { message: "must be ≤ 2^64-1" });
+function pow10n(n: number): bigint {
+  if (n < 0) throw new Error("pow10n expects n ≥ 0");
+  let p = 1n;
+  for (let i = 0; i < n; i++) p *= 10n;
+  return p;
+}
+// const fromLimbs = ({ r0, r1, r2, r3 }: _Decimal.T) =>
+//   (r3 << 192n) | (r2 << 128n) | (r1 << 64n) | r0;
+function splitToU64Limbs(x: bigint): {
+  r0: bigint;
+  r1: bigint;
+  r2: bigint;
+  r3: bigint;
+} {
+  const r0 = x & U64_MAX;
+  const r1 = (x >> 64n) & U64_MAX;
+  const r2 = (x >> 128n) & U64_MAX;
+  const r3 = (x >> 192n) & U64_MAX;
+  // overflow if any higher bits remain
+  if (x >> 256n !== 0n) {
+    throw new Error("decimal magnitude does not fit in 256 bits");
+  }
+  return { r0, r1, r2, r3 };
+}
+export namespace _Decimal {
+  export namespace Sign {
+    export const schema = z.enum(["plus", "minus"]);
+    export type T = z.infer<typeof schema>;
+  }
+  // Raw limbs + sign; limbs are real u64 (bigint), not JS numbers
+  export const schema = z.object({
+    r0: U64,
+    r1: U64,
+    r2: U64,
+    r3: U64,
+    sign: Sign.schema,
+  });
+  export type T = z.infer<typeof schema>;
+}
+/**
+ * Parses a wave-ish struct like:
+ *   "{ r0: 1337, r1: 0, r2: 0, r3: 0, sign: plus }"
+ * Returns a validated _Decimal.T with bigint limbs.
+ */
+export function parseDecimalWaveExpr(expr: string): _Decimal.T {
+  const trimmed = expr.trim();
+  // Optional braces; tolerate with or without
+  const inner = trimmed.replace(/^\{\s*/, "").replace(/\s*\}$/, "");
+  if (inner.length === 0) {
+    throw new Error("empty decimal expression");
+  }
+  // Split by commas that separate top-level pairs (no nesting expected here)
+  const parts = inner
+    .split(",")
+    .map((p) => p.trim())
+    .filter(Boolean);
+  const seen = new Set<string>();
+  // Default r1..r3 to 0 for ergonomics; require r0 + sign at minimum.
+  let out: Partial<_Decimal.T> & {
+    r0?: bigint;
+    r1?: bigint;
+    r2?: bigint;
+    r3?: bigint;
+  } = {
+    r1: 0n,
+    r2: 0n,
+    r3: 0n,
+  };
+  for (const part of parts) {
+    const idx = part.indexOf(":");
+    if (idx === -1) {
+      throw new Error(`expected "key: value" pair, got "${part}"`);
+    }
+    const keyRaw = part.slice(0, idx).trim();
+    const valRaw = part.slice(idx + 1).trim();
+    if (seen.has(keyRaw)) {
+      throw new Error(`duplicate key "${keyRaw}"`);
+    }
+    seen.add(keyRaw);
+    switch (keyRaw) {
+      case "r0":
+      case "r1":
+      case "r2":
+      case "r3": {
+        // allow underscores for readability, like Rust literals
+        const normalized = valRaw.replace(/_/g, "");
+        // BigInt constructor handles decimal strings; reject non-integers explicitly
+        if (!/^[+-]?\d+$/.test(normalized)) {
+          throw new Error(`invalid integer for ${keyRaw}: "${valRaw}"`);
+        }
+        const limb = BigInt(normalized);
+        // zod will re-validate bounds, but fail fast here for nicer messages
+        if (limb < 0n || limb > U64_MAX) {
+          throw new Error(`value for ${keyRaw} out of u64 range: ${valRaw}`);
+        }
+        (out as any)[keyRaw] = limb;
+        break;
+      }
+      case "sign": {
+        if (valRaw !== "plus" && valRaw !== "minus") {
+          throw new Error(`invalid sign "${valRaw}" (expected plus|minus)`);
+        }
+        (out as any).sign = valRaw;
+        break;
+      }
+      default:
+        throw new Error(`unexpected key "${keyRaw}"`);
+    }
+  }
+  // Require at least r0 and sign (r1..r3 default to 0 if not given)
+  if (out.r0 === undefined) {
+    throw new Error(`missing required key "r0"`);
+  }
+  if (!out.sign) {
+    throw new Error(`missing required key "sign"`);
+  }
+  // Final validation & typing
+  return _Decimal.schema.parse(out);
+}
+class _DecimalCodec implements CodecInstance<Decimal_> {
+  public readonly data: _Decimal.T;
+  constructor(data: _Decimal.T) {
+    this.data = data;
+  }
+  static fromJs(
+    value: Decimal_,
+    targetScale: number = TARGET_SCALE,
+  ): _DecimalCodec {
+    // dn.Dnum is effectively [coef, decimals]
+    const [coefRaw, decs] = value as unknown as Decimal_;
+    const sign: _Decimal.Sign.T = coefRaw < 0n ? "minus" : "plus";
+    const coefAbs = coefRaw < 0n ? -coefRaw : coefRaw;
+    if (decs > decs) {
+      // would require rounding; be strict
+      throw new Error(
+        `cannot downscale from ${decs} to ${targetScale} decimals without rounding`,
+      );
+    }
+    // upscale to target scale exactly
+    const scaleDelta = targetScale - decs;
+    const scaled = coefAbs * pow10n(scaleDelta);
+    const { r0, r1, r2, r3 } = splitToU64Limbs(scaled);
+    const out = _Decimal.schema.parse({ r0, r1, r2, r3, sign });
+    return new _DecimalCodec(out);
+  }
+  static fromKontor(data: _Decimal.T): _DecimalCodec {
+    return new _DecimalCodec(data);
+  }
+  static parseWave(expr: string): _Decimal.T {
+    return _Decimal.schema.parse(parseDecimalWaveExpr(expr));
+  }
+  toJs(): Decimal_ {
+    const mag =
+      (BigInt(this.data.r3) << 192n) |
+      (BigInt(this.data.r2) << 128n) |
+      (BigInt(this.data.r1) << 64n) |
+      BigInt(this.data.r0);
+    const signed = this.data.sign === "minus" ? -mag : mag;
+    return [signed, 18];
+  }
+  toWave(): WaveExpr {
+    // NOTE: adjust quoting on sign if your Wave syntax needs `"plus"` etc.
+    return `{r0: ${this.data.r0}, r1: ${this.data.r1}, r2: ${this.data.r2}, r3: ${this.data.r3}, sign: ${this.data.sign}}` as WaveExpr;
+  }
+}
+export const DecimalCodec = _DecimalCodec as unknown as CodecConstructor<
+  Decimal_,
+  _DecimalCodec,
+  _Decimal.T
+>;

package/src/sdk/utils/wit/codecs/enum.ts ADDED Viewed

@@ -0,0 +1,114 @@
+import * as z from "zod";
+export namespace Enum {
+  export namespace Parens {
+    export const schema = z.templateLiteral([
+      z.literal("("),
+      z.string(),
+      z.literal(")"),
+    ]);
+  }
+  export namespace Option {
+    // some(foo) or some( foo bar ) or even some()
+    // also allow just "some" ??? we'll decide below.
+    export const waveRegex =
+      /^(?<kind>some)(?:\((?<value>[\s\S]*?)\))$|^(?<none>none)$/;
+    // We'll keep these tiny sub-schemas because they're readable elsewhere.
+    export namespace None {
+      export const schema = z.literal("none");
+    }
+    export namespace Some {
+      // NOTE: we REQUIRE parens for "some(...)"
+      // If you want plain "some" to be valid, we could relax later.
+      export const schema = z.templateLiteral([
+        z.literal("some"),
+        Parens.schema,
+      ]);
+    }
+    // Raw union of the spellings we accept as input
+    // e.g. "none" or "some(<stuff>)"
+    const rawSchema = z.union([None.schema, Some.schema]);
+    // Transform raw string -> { kind: "none" | "some"; value: string | null }
+    // Then pipe into a discriminated union so .infer<> is nice & strict.
+    export const schema = rawSchema
+      .transform((expr) => {
+        const trimmed = expr.trim();
+        // Fast path for "none"
+        if (trimmed === "none") {
+          return {
+            kind: "none" as const,
+          };
+        }
+        // else parse "some(...)"
+        const match = /^some\((?<value>[\s\S]*?)\)$/.exec(trimmed);
+        if (!match?.groups) {
+          throw new Error(`invariant: invalid wave option expression: ${expr}`);
+        }
+        const value = match.groups.value?.trim() ?? "";
+        return {
+          kind: "some" as const,
+          value: value === "" ? null : value,
+        };
+      })
+      .pipe(
+        z.discriminatedUnion("kind", [
+          z.object({
+            kind: z.literal("none"),
+          }),
+          z.object({
+            kind: z.literal("some"),
+            value: z.string().nullable(), // raw value contents or null (for `some()`)
+          }),
+        ]),
+      );
+    export type T = z.infer<typeof schema>;
+  }
+  export namespace Result {
+    export const waveRegex = /^(?<_tag>ok|err)(?:\((?<value>[\s\S]*?)\))?$/;
+    export namespace Ok {
+      export const schema = z.literal("ok");
+    }
+    export namespace Err {
+      export const schema = z.literal("err");
+    }
+    export const schema = z
+      .templateLiteral([
+        z.union([Ok.schema, Err.schema]),
+        Parens.schema.optional(),
+      ])
+      .transform((expr) => {
+        const match = waveRegex.exec(expr.trim());
+        if (!match?.groups) {
+          throw new Error(`invariant: invalid wave expression: ${expr}`);
+        }
+        const { _tag, value } = match.groups;
+        return { _tag, value: value?.trim() || null };
+      })
+      .pipe(
+        // lock the output into a discriminated union so z.infer<> is nice
+        z.discriminatedUnion("_tag", [
+          z.object({
+            _tag: Ok.schema, // "ok"
+            value: z.string().nullable(), // raw value text (we haven't parsed r0..sign here)
+          }),
+          z.object({
+            _tag: Err.schema, // "err"
+            value: z.string().nullable(), // err(message("...")) -> 'message("...")' or null
+          }),
+        ]),
+      );
+    export type T = z.infer<typeof schema>;
+  }
+}