@gryt/core 0.13.0 → 0.15.0

package/dist/pairing/relayClient.d.ts

@@ -0,0 +1,45 @@
+import type { PairingFetch } from "./interfaces.js";
+/** A refusal from the relay: its status and the `error` it sent, or "network" when nothing came back. */
+export declare class PairingRelayError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string);
+}
+export interface RelayMessage {
+    seq: number;
+    type: "claim" | "reveal" | "sealed";
+    pkA?: string;
+    pkN?: string;
+    body?: string;
+}
+export interface PairingRelay {
+    create(commit: string): Promise<{
+        id: string;
+        code: string;
+        token: string;
+        expiresAt: string;
+    }>;
+    claim(by: {
+        id: string;
+    } | {
+        code: string;
+    }, pkA: string): Promise<{
+        id: string;
+        token: string;
+        commit: string;
+        location: string | null;
+        yourLocation: string | null;
+    }>;
+    post(id: string, token: string, message: {
+        type: "reveal";
+        pkN: string;
+    } | {
+        type: "sealed";
+        body: string;
+    }): Promise<void>;
+    /** The other side's messages after `after`, waiting up to `waitSeconds`. Asking past one acks it. */
+    poll(id: string, token: string, after: number, waitSeconds: number, signal?: AbortSignal): Promise<RelayMessage[]>;
+    close(id: string, token: string): Promise<void>;
+}
+/** The relay's HTTP API as auth#45 built it, under `{origin}/api/v1/pairing`. */
+export declare function createPairingRelay(origin: string, fetch: PairingFetch): PairingRelay;

package/dist/pairing/relayClient.js

@@ -0,0 +1,48 @@
+/** A refusal from the relay: its status and the `error` it sent, or "network" when nothing came back. */
+export class PairingRelayError extends Error {
+    status;
+    code;
+    constructor(status, code) {
+        super(`Pairing relay: ${status} ${code}`);
+        this.name = "PairingRelayError";
+        this.status = status;
+        this.code = code;
+    }
+}
+/** The relay's HTTP API as auth#45 built it, under `{origin}/api/v1/pairing`. */
+export function createPairingRelay(origin, fetch) {
+    const base = `${origin.replace(/\/+$/, "")}/api/v1/pairing/sessions`;
+    async function call(method, path, body, token, signal) {
+        const headers = {};
+        if (body !== undefined)
+            headers["content-type"] = "application/json";
+        if (token)
+            headers.authorization = `Bearer ${token}`;
+        let res;
+        try {
+            res = await fetch(`${base}${path}`, { method, headers, body: body === undefined ? undefined : JSON.stringify(body), signal });
+        }
+        catch (e) {
+            if (signal?.aborted)
+                throw e;
+            throw new PairingRelayError(0, "network");
+        }
+        if (res.status === 204)
+            return {};
+        const json = (await res.json().catch(() => null));
+        if (res.status >= 400 || !json)
+            throw new PairingRelayError(res.status, String(json?.error ?? "unknown"));
+        return json;
+    }
+    const path = (id) => `/${encodeURIComponent(id)}`;
+    return {
+        create: async (commit) => (await call("POST", "", { commit })),
+        claim: async (by, pkA) => (await call("POST", "/claim", { ...by, pkA })),
+        post: async (id, token, message) => void (await call("POST", `${path(id)}/messages`, message, token)),
+        poll: async (id, token, after, waitSeconds, signal) => {
+            const res = await call("GET", `${path(id)}/messages?after=${after}&wait=${waitSeconds}`, undefined, token, signal);
+            return (Array.isArray(res.messages) ? res.messages : []);
+        },
+        close: async (id, token) => void (await call("DELETE", path(id), undefined, token)),
+    };
+}

package/dist/testing.d.ts

@@ -0,0 +1 @@
+export { FakeDeliveryService, MemoryMlsStore } from "./mls/deliveryService.fake.js";

package/dist/testing.js

@@ -0,0 +1,3 @@
+/* For the apps' own tests: the in-memory delivery service and state store the driver's tests
+   use, so a session can run the real driver against it. Not for app code. */
+export { FakeDeliveryService, MemoryMlsStore } from "./mls/deliveryService.fake.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gryt/core",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "Gryt's shared application logic: one implementation of the things the desktop and mobile apps both do.",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -14,6 +14,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "default": "./dist/testing.js"
     }
   },
   "files": [
@@ -35,6 +39,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@gryt/crypto": "0.7.0"
+    "@gryt/crypto": "0.9.0",
+    "@noble/hashes": "^2.3.0"
   }
 }