@hasna/recordings 0.3.13 → 0.5.0

package/dist/hosted/index.js

@@ -0,0 +1,266 @@
+// @bun
+import {
+  accountResponseParser,
+  healthResponseParser,
+  pageOptionsParser,
+  pasteInputParser,
+  pasteListParser,
+  pasteResponseParser,
+  pendingDeletionParser,
+  readyResponseParser,
+  recordingInputParser,
+  recordingListParser,
+  recordingResponseParser,
+  renameInputParser,
+  versionResponseParser
+} from "../hosted-v1-gdr9extc.js";
+import {
+  recordingIDParser
+} from "../hosted-v1-aavn7ktb.js";
+
+// src/hosted/transport.ts
+import { appendQuery, toV1BaseUrl } from "@hasna/contracts/client";
+var messages = {
+  invalid_configuration: "Choose a complete HTTPS v1 API base, or an explicit HTTP loopback v1 base, and valid bounds.",
+  invalid_input: "The operation input does not match the hosted Recordings contract.",
+  credential_unavailable: "A valid access credential is required for this hosted operation.",
+  aborted: "The hosted request was cancelled.",
+  timeout: "The hosted request exceeded its deadline.",
+  network_error: "The hosted API could not be reached.",
+  redirect_refused: "The hosted API returned a refused redirect.",
+  response_too_large: "The hosted response exceeded its byte limit. Request a smaller page.",
+  invalid_response: "The hosted API returned an unexpected response.",
+  unauthorized: "Sign in again to use this hosted session.",
+  forbidden: "This hosted account is not permitted to perform the operation.",
+  not_found: "The hosted resource was not found.",
+  recording_deleted: "The recording was permanently deleted.",
+  conflict: "The operation conflicts with existing hosted state.",
+  rate_limited: "The hosted usage or request limit was reached.",
+  http_error: "The hosted API refused the request."
+};
+
+class RecordingsSDKError extends Error {
+  code;
+  status;
+  requestId;
+  constructor(code, status, requestId) {
+    super(messages[code]);
+    this.code = code;
+    this.status = status;
+    this.requestId = requestId;
+    this.name = "RecordingsSDKError";
+  }
+}
+function input(schema, value) {
+  const parsed = schema.safeParse(value);
+  if (!parsed.success)
+    throw new RecordingsSDKError("invalid_input");
+  return parsed.data;
+}
+function abortable(value, signal) {
+  if (signal.aborted) {
+    value.catch(() => {});
+    return Promise.reject(new RecordingsSDKError("aborted"));
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(new RecordingsSDKError("aborted"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    value.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+
+class Transport {
+  base;
+  #fetch;
+  #credential;
+  #timeout;
+  #limit;
+  constructor(options) {
+    try {
+      const base = toV1BaseUrl(options.apiBase);
+      const original = new URL(options.apiBase.trim()), url = new URL(base);
+      if (!/\/v1\/?$/.test(original.pathname) || original.search || original.hash || url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname)))
+        throw Error();
+      this.base = base;
+      this.#timeout = options.timeoutMs ?? 20000;
+      this.#limit = options.maxResponseBytes ?? 4194304;
+      if (!Number.isInteger(this.#timeout) || this.#timeout < 10 || this.#timeout > 300000 || !Number.isInteger(this.#limit) || this.#limit < 1024 || this.#limit > 33554432)
+        throw Error();
+    } catch {
+      throw new RecordingsSDKError("invalid_configuration");
+    }
+    this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.#credential = options.credentialProvider;
+  }
+  async request(method, path, authenticated, statuses, body, options = {}, query) {
+    const controller = new AbortController;
+    let timedOut = false;
+    const onAbort = () => controller.abort();
+    if (options.signal?.aborted)
+      controller.abort();
+    else
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, this.#timeout);
+    let response;
+    try {
+      controller.signal.throwIfAborted();
+      const headers = new Headers({ accept: "application/json" });
+      const encoded = body === undefined ? undefined : JSON.stringify(body);
+      if (encoded !== undefined) {
+        if (new TextEncoder().encode(encoded).byteLength > 1048576)
+          throw new RecordingsSDKError("invalid_input");
+        headers.set("content-type", "application/json");
+      }
+      if (authenticated) {
+        let token;
+        try {
+          if (!this.#credential)
+            throw Error();
+          token = await abortable(Promise.resolve(this.#credential(Object.freeze({ apiBase: this.base, signal: controller.signal }))), controller.signal);
+          if (typeof token !== "string" || !/^[A-Za-z0-9._~+\/-]{1,16000}={0,2}$/.test(token))
+            throw Error();
+        } catch {
+          throw new RecordingsSDKError("credential_unavailable");
+        }
+        controller.signal.throwIfAborted();
+        headers.set("authorization", "Bearer " + token);
+      }
+      const url = this.base + appendQuery(path, query);
+      response = await abortable(this.#fetch(url, { method, headers, body: encoded, redirect: "manual", credentials: "omit", cache: "no-store", signal: controller.signal }), controller.signal);
+      if (response.status >= 300 && response.status < 400 || response.redirected || response.url && response.url !== url)
+        throw new RecordingsSDKError("redirect_refused");
+      if (!statuses.includes(response.status)) {
+        const codes = { 401: "unauthorized", 403: "forbidden", 404: "not_found", 410: "recording_deleted", 409: "conflict", 429: "rate_limited" };
+        const requestID = response.headers.get("x-request-id");
+        throw new RecordingsSDKError(codes[response.status] ?? "http_error", response.status, recordingIDParser.safeParse(requestID).success ? requestID : undefined);
+      }
+      if (response.status === 204)
+        return { status: 204 };
+      if (!/^application\/json(?:\s*;.*)?$/i.test(response.headers.get("content-type") ?? ""))
+        throw new RecordingsSDKError("invalid_response");
+      const encoding = response.headers.get("content-encoding");
+      const declared = !encoding || encoding === "identity" ? response.headers.get("content-length") : null;
+      if (declared !== null && (!/^\d+$/.test(declared) || Number(declared) > this.#limit))
+        throw new RecordingsSDKError("response_too_large");
+      const reader = response.body?.getReader();
+      if (!reader)
+        throw new RecordingsSDKError("invalid_response");
+      let bytes = new Uint8Array(Math.min(16384, this.#limit)), length = 0;
+      try {
+        while (true) {
+          const { done, value } = await abortable(reader.read(), controller.signal);
+          if (done)
+            break;
+          if (value.byteLength > this.#limit - length)
+            throw new RecordingsSDKError("response_too_large");
+          const required = length + value.byteLength;
+          if (required > bytes.byteLength) {
+            const grown = new Uint8Array(Math.min(this.#limit, Math.max(required, bytes.byteLength * 2)));
+            grown.set(bytes.subarray(0, length));
+            bytes = grown;
+          }
+          bytes.set(value, length);
+          length = required;
+        }
+      } finally {
+        reader.cancel().catch(() => {});
+        reader.releaseLock();
+      }
+      if (declared !== null && Number(declared) !== length)
+        throw new RecordingsSDKError("invalid_response");
+      try {
+        return { status: response.status, data: JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, length))) };
+      } catch {
+        throw new RecordingsSDKError("invalid_response");
+      }
+    } catch (error) {
+      if (controller.signal.aborted)
+        throw new RecordingsSDKError(timedOut ? "timeout" : "aborted");
+      if (error instanceof RecordingsSDKError)
+        throw error;
+      throw new RecordingsSDKError("network_error");
+    } finally {
+      clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+      response?.body?.cancel().catch(() => {});
+    }
+  }
+}
+function output(schema, data) {
+  const parsed = schema.safeParse(data);
+  if (!parsed.success)
+    throw new RecordingsSDKError("invalid_response");
+  return parsed.data;
+}
+
+// src/hosted/index.ts
+var recordingCursor = (last) => ({ before: last.createdAt, beforeId: last.id });
+var pasteCursor = (last) => ({ before: last.occurredAt, beforeId: last.id });
+
+class HostedRecordingsClient {
+  #transport;
+  constructor(options) {
+    this.#transport = new Transport(options);
+  }
+  get apiBase() {
+    return this.#transport.base;
+  }
+  async health(options) {
+    return output(healthResponseParser, (await this.#transport.request("GET", "/health", false, [200], undefined, options)).data);
+  }
+  async version(options) {
+    return output(versionResponseParser, (await this.#transport.request("GET", "/version", false, [200], undefined, options)).data);
+  }
+  async ready(options) {
+    return output(readyResponseParser, (await this.#transport.request("GET", "/ready", true, [200], undefined, options)).data);
+  }
+  async account(options) {
+    return output(accountResponseParser, (await this.#transport.request("GET", "/account", true, [200], undefined, options)).data);
+  }
+  async bootstrap(options) {
+    return output(accountResponseParser, (await this.#transport.request("POST", "/account/bootstrap", true, [200], {}, options)).data);
+  }
+  async logout(options) {
+    await this.#transport.request("POST", "/auth/logout", true, [204], undefined, options);
+  }
+  async listRecordings(page = {}, options) {
+    return output(recordingListParser, (await this.#transport.request("GET", "/recordings", true, [200], undefined, options, { ...input(pageOptionsParser, page) })).data);
+  }
+  async getRecording(id, options) {
+    return output(recordingResponseParser, (await this.#transport.request("GET", "/recordings/" + input(recordingIDParser, id), true, [200], undefined, options)).data);
+  }
+  async saveRecording(value, options) {
+    return output(recordingResponseParser, (await this.#transport.request("POST", "/recordings", true, [201], input(recordingInputParser, value), options)).data);
+  }
+  async renameRecording(id, title, options) {
+    return output(recordingResponseParser, (await this.#transport.request("PATCH", "/recordings/" + input(recordingIDParser, id), true, [200], input(renameInputParser, { title }), options)).data);
+  }
+  async deleteRecording(id, options) {
+    const response = await this.#transport.request("DELETE", "/recordings/" + input(recordingIDParser, id), true, [202, 204], undefined, options);
+    if (response.status === 204)
+      return { state: "removed" };
+    output(pendingDeletionParser, response.data);
+    return { state: "pending" };
+  }
+  async listPasteReceipts(page = {}, options) {
+    return output(pasteListParser, (await this.#transport.request("GET", "/paste-history", true, [200], undefined, options, { ...input(pageOptionsParser, page) })).data);
+  }
+  async savePasteReceipt(value, options) {
+    return output(pasteResponseParser, (await this.#transport.request("POST", "/paste-history", true, [201], input(pasteInputParser, value), options)).data);
+  }
+  async deletePasteReceipt(id, options) {
+    await this.#transport.request("DELETE", "/paste-history/" + input(recordingIDParser, id), true, [204], undefined, options);
+  }
+  async clearPasteHistory(options) {
+    await this.#transport.request("DELETE", "/paste-history", true, [204], undefined, options);
+  }
+}
+export {
+  recordingCursor,
+  pasteCursor,
+  RecordingsSDKError,
+  HostedRecordingsClient
+};

package/dist/hosted/transport.d.ts

@@ -0,0 +1,36 @@
+import { type ContractParser } from "../contracts/stream-v1.js";
+export type CredentialProvider = (context: Readonly<{
+    apiBase: string;
+    signal: AbortSignal;
+}>) => string | Promise<string>;
+export type SDKErrorCode = "invalid_configuration" | "invalid_input" | "credential_unavailable" | "aborted" | "timeout" | "network_error" | "redirect_refused" | "response_too_large" | "invalid_response" | "unauthorized" | "forbidden" | "not_found" | "recording_deleted" | "conflict" | "rate_limited" | "http_error";
+/** Never retains a token, request/response body, URL, native Error cause or server message. */
+export declare class RecordingsSDKError extends Error {
+    readonly code: SDKErrorCode;
+    readonly status?: number | undefined;
+    readonly requestId?: string | undefined;
+    constructor(code: SDKErrorCode, status?: number | undefined, requestId?: string | undefined);
+}
+export interface ClientOptions {
+    apiBase: string;
+    credentialProvider?: CredentialProvider;
+    /** Trusted injection for tests/custom runtimes; must honor manual redirects and AbortSignal. */
+    fetch?: typeof globalThis.fetch;
+    timeoutMs?: number;
+    maxResponseBytes?: number;
+}
+export interface RequestOptions {
+    signal?: AbortSignal;
+}
+export declare function input<T>(schema: ContractParser<T>, value: unknown): T;
+export declare class Transport {
+    #private;
+    readonly base: string;
+    constructor(options: ClientOptions);
+    request(method: string, path: string, authenticated: boolean, statuses: readonly number[], body?: unknown, options?: RequestOptions, query?: Record<string, string | number | undefined>): Promise<{
+        status: number;
+        data?: unknown;
+    }>;
+}
+export declare function output<T>(schema: ContractParser<T>, data: unknown): T;
+//# sourceMappingURL=transport.d.ts.map

package/dist/hosted/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/hosted/transport.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAEnF,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,CAAA;CAAE,CAAC,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;AAC3H,MAAM,MAAM,YAAY,GAAG,uBAAuB,GAAG,eAAe,GAAG,wBAAwB,GAAG,SAAS,GAAG,SAAS,GACrH,eAAe,GAAG,kBAAkB,GAAG,oBAAoB,GAAG,kBAAkB,GAAG,cAAc,GAAG,WAAW,GAC/G,WAAW,GAAG,mBAAmB,GAAG,UAAU,GAAG,cAAc,GAAG,YAAY,CAAC;AAajF,+FAA+F;AAC/F,qBAAa,kBAAmB,SAAQ,KAAK;IAC/B,QAAQ,CAAC,IAAI,EAAE,YAAY;IAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM;IAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM;gBAAzE,IAAI,EAAE,YAAY,EAAW,MAAM,CAAC,EAAE,MAAM,YAAA,EAAW,SAAS,CAAC,EAAE,MAAM,YAAA;CAG/F;AACD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC,gGAAgG;IAChG,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AACD,MAAM,WAAW,cAAc;IAAG,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE;AACxD,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC,CAIrE;AAcD,qBAAa,SAAS;;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAKV,OAAO,EAAE,aAAa;IAe5B,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,EACjF,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,GAAE,cAAmB,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CAqE9J;AACD,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC,CAIrE"}