@synnaxlabs/freighter 0.1.0 → 0.4.1

package/src/websocket.spec.ts

@@ -0,0 +1,119 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { URL, binary } from "@synnaxlabs/x";
+import { describe, expect, test } from "vitest";
+import { z } from "zod";
+
+import {
+  BaseTypedError,
+  EOF,
+  type TypedError,
+  registerError,
+  type ErrorPayload,
+} from "@/errors";
+import { type Context } from "@/middleware";
+import { WebSocketClient } from "@/websocket";
+
+const url = new URL({
+  host: "127.0.0.1",
+  port: 8080,
+});
+
+const MessageSchema = z.object({
+  id: z.number().optional(),
+  message: z.string().optional(),
+});
+
+const client = new WebSocketClient(url, new binary.JSONEncoderDecoder());
+
+class MyCustomError extends BaseTypedError {
+  code: number;
+
+  constructor(message: string, code: number) {
+    super(message, "integration.error");
+    this.code = code;
+  }
+}
+
+const encodeTestError = (err: TypedError): ErrorPayload => {
+  if (!(err instanceof MyCustomError)) {
+    throw new Error("Unexpected error type");
+  }
+  return { type: "integration.error", data: `${err.code},${err.message}` };
+};
+
+const decodeTestError = (encoded: ErrorPayload): TypedError | null => {
+  if (encoded.type !== "integration.error") return null;
+  const [code, message] = encoded.data.split(",");
+  return new MyCustomError(message, parseInt(code, 10));
+};
+
+registerError({
+  encode: encodeTestError,
+  decode: decodeTestError,
+});
+
+describe("websocket", () => {
+  test("basic exchange", async () => {
+    const stream = await client.stream("stream/echo", MessageSchema, MessageSchema);
+    for (let i = 0; i < 10; i++) {
+      stream.send({ id: i, message: "hello" });
+      const [response, error] = await stream.receive();
+      expect(error).toBeNull();
+      expect(response?.id).toEqual(i + 1);
+      expect(response?.message).toEqual("hello");
+    }
+    stream.closeSend();
+    const [response, error] = await stream.receive();
+    expect(error).toEqual(new EOF());
+    expect(response).toBeNull();
+  });
+
+  test("receive message after close", async () => {
+    const stream = await client.stream(
+      "stream/sendMessageAfterClientClose",
+      MessageSchema,
+      MessageSchema,
+    );
+    stream.closeSend();
+    let [response, error] = await stream.receive();
+    expect(error).toBeNull();
+    expect(response?.id).toEqual(0);
+    expect(response?.message).toEqual("Close Acknowledged");
+    [, error] = await stream.receive();
+    expect(error).toEqual(new EOF());
+  });
+
+  test("receive error", async () => {
+    const stream = await client.stream(
+      "stream/receiveAndExitWithErr",
+      MessageSchema,
+      MessageSchema,
+    );
+    stream.send({ id: 0, message: "hello" });
+    const [response, error] = await stream.receive();
+    expect(error).toEqual(new MyCustomError("unexpected error", 1));
+    expect(response).toBeNull();
+  });
+
+  test("middleware", async () => {
+    const myClient = new WebSocketClient(url, new binary.JSONEncoderDecoder());
+    let c = 0;
+    myClient.use(async (md, next): Promise<[Context, Error | null]> => {
+      if (md.params !== undefined) {
+        c++;
+        md.params.Test = "test";
+      }
+      return await next(md);
+    });
+    await myClient.stream("stream/middlewareCheck", MessageSchema, MessageSchema);
+    expect(c).toEqual(1);
+  });
+});

package/src/websocket.ts

@@ -0,0 +1,203 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { runtime, type URL, buildQueryString, type binary } from "@synnaxlabs/x";
+import { z } from "zod";
+
+import { EOF, errorZ, StreamClosed, decodeError } from "@/errors";
+import { CONTENT_TYPE_HEADER_KEY } from "@/http";
+import { MiddlewareCollector, type Context } from "@/middleware";
+import type { Stream, StreamClient } from "@/stream";
+
+const resolveWebSocketConstructor = (): ((target: string) => WebSocket) => {
+  if (runtime.RUNTIME !== "node") return (t) => new WebSocket(t);
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  return (t) => new (require("ws").WebSocket)(t, { rejectUnauthorized: false });
+};
+
+const MessageSchema = z.object({
+  type: z.union([z.literal("data"), z.literal("close")]),
+  payload: z.unknown().optional(),
+  error: z.optional(errorZ),
+});
+
+type Message = z.infer<typeof MessageSchema>;
+
+type ReceiveCallbacksQueue = Array<{
+  resolve: (msg: Message) => void;
+  reject: (reason: unknown) => void;
+}>;
+
+/** WebSocketStream is an implementation of Stream that is backed by a websocket. */
+class WebSocketStream<RQ extends z.ZodTypeAny, RS extends z.ZodTypeAny = RQ>
+  implements Stream<RQ, RS>
+{
+  private readonly encoder: binary.EncoderDecoder;
+  private readonly reqSchema: RQ;
+  private readonly resSchema: RS;
+  private readonly ws: WebSocket;
+  private serverClosed: Error | null;
+  private sendClosed: boolean;
+  private readonly receiveDataQueue: Message[] = [];
+  private readonly receiveCallbacksQueue: ReceiveCallbacksQueue = [];
+
+  constructor(
+    ws: WebSocket,
+    encoder: binary.EncoderDecoder,
+    reqSchema: RQ,
+    resSchema: RS,
+  ) {
+    this.encoder = encoder;
+    this.reqSchema = reqSchema;
+    this.resSchema = resSchema;
+    this.ws = ws;
+    this.sendClosed = false;
+    this.serverClosed = null;
+    this.listenForMessages();
+  }
+
+  /** Implements the Stream protocol */
+  send(req: z.input<RQ>): Error | null {
+    if (this.serverClosed != null) return new EOF();
+    if (this.sendClosed) throw new StreamClosed();
+    this.ws.send(this.encoder.encode({ type: "data", payload: req }));
+    return null;
+  }
+
+  /** Implements the Stream protocol */
+  async receive(): Promise<[z.output<RS> | null, Error | null]> {
+    if (this.serverClosed != null) return [null, this.serverClosed];
+    const msg = await this.receiveMsg();
+    if (msg.type === "close") {
+      if (msg.error == null) throw new Error("Message error must be defined");
+      this.serverClosed = decodeError(msg.error);
+      return [null, this.serverClosed];
+    }
+    return [this.resSchema.parse(msg.payload), null];
+  }
+
+  /** Implements the Stream protocol */
+  received(): boolean {
+    return this.receiveDataQueue.length !== 0;
+  }
+
+  /** Implements the Stream protocol */
+  closeSend(): void {
+    if (this.sendClosed || this.serverClosed != null) return undefined;
+    const msg: Message = { type: "close" };
+    try {
+      this.ws.send(this.encoder.encode(msg));
+    } finally {
+      this.sendClosed = true;
+    }
+    return undefined;
+  }
+
+  private async receiveMsg(): Promise<Message> {
+    const msg = this.receiveDataQueue.shift();
+    if (msg != null) return msg;
+    return await new Promise((resolve, reject) =>
+      this.receiveCallbacksQueue.push({ resolve, reject }),
+    );
+  }
+
+  private listenForMessages(): void {
+    this.ws.onmessage = (ev: MessageEvent<Uint8Array>) => {
+      const msg = this.encoder.decode(ev.data, MessageSchema);
+      const callback = this.receiveCallbacksQueue.shift();
+      if (callback != null) callback.resolve(msg);
+      else this.receiveDataQueue.push(msg);
+    };
+
+    this.ws.onclose = (ev: CloseEvent) => {
+      this.serverClosed = isNormalClosure(ev) ? new EOF() : new StreamClosed();
+    };
+  }
+}
+
+export const FREIGHTER_METADATA_PREFIX = "freighterctx";
+
+const CloseNormal = 1000;
+const CloseGoingAway = 1001;
+const NormalClosures = [CloseNormal, CloseGoingAway];
+
+const isNormalClosure = (ev: CloseEvent): boolean => NormalClosures.includes(ev.code);
+
+/**
+ * WebSocketClient is an implementation of StreamClient that is backed by
+ * websockets.
+ */
+export class WebSocketClient extends MiddlewareCollector implements StreamClient {
+  baseUrl: URL;
+  encoder: binary.EncoderDecoder;
+
+  static readonly MESSAGE_TYPE = "arraybuffer";
+
+  /**
+   * @param encoder - The encoder to use for encoding messages and decoding
+   *   responses.
+   * @param baseEndpoint - A base url to use as a prefix for all requests.
+   */
+  constructor(baseEndpoint: URL, encoder: binary.EncoderDecoder, secure = false) {
+    super();
+    this.baseUrl = baseEndpoint.replace({ protocol: secure ? "wss" : "ws" });
+    this.encoder = encoder;
+  }
+
+  /** Implements the StreamClient interface. */
+  async stream<RQ extends z.ZodTypeAny, RS extends z.ZodTypeAny = RQ>(
+    target: string,
+    reqSchema: RQ,
+    resSchema: RS,
+  ): Promise<Stream<RQ, RS>> {
+    const SocketConstructor = resolveWebSocketConstructor();
+    let stream: Stream<RQ, RS> | undefined;
+    const [, error] = await this.executeMiddleware(
+      { target, protocol: "websocket", params: {}, role: "client" },
+      async (ctx: Context): Promise<[Context, Error | null]> => {
+        const ws = SocketConstructor(this.buildURL(target, ctx));
+        const outCtx: Context = { ...ctx, params: {} };
+        ws.binaryType = WebSocketClient.MESSAGE_TYPE;
+        const streamOrErr = await this.wrapSocket(ws, reqSchema, resSchema);
+        if (streamOrErr instanceof Error) return [outCtx, streamOrErr];
+        stream = streamOrErr;
+        return [outCtx, null];
+      },
+    );
+    if (error != null) throw error;
+    return stream as Stream<RQ, RS>;
+  }
+
+  private buildURL(target: string, ctx: Context): string {
+    const qs = buildQueryString(
+      {
+        [CONTENT_TYPE_HEADER_KEY]: this.encoder.contentType,
+        ...ctx.params,
+      },
+      FREIGHTER_METADATA_PREFIX,
+    );
+    return this.baseUrl.child(target).toString() + qs;
+  }
+
+  private async wrapSocket<RQ extends z.ZodTypeAny, RS extends z.ZodTypeAny = RQ>(
+    ws: WebSocket,
+    reqSchema: RQ,
+    resSchema: RS,
+  ): Promise<WebSocketStream<RQ, RS> | Error> {
+    return await new Promise((resolve) => {
+      ws.onopen = () => {
+        resolve(new WebSocketStream<RQ, RS>(ws, this.encoder, reqSchema, resSchema));
+      };
+      ws.onerror = (ev: Event) => {
+        const ev_ = ev as ErrorEvent;
+        resolve(new Error(ev_.message));
+      };
+    });
+  }
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "@synnaxlabs/tsconfig/base.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*.ts"],
+}

package/tsconfig.vite.json

@@ -0,0 +1,4 @@
+{
+  "extends": "@synnaxlabs/tsconfig/vite.json",
+  "include": ["vite.config.ts"]
+}

package/vite.config.ts

@@ -0,0 +1,16 @@
+// Copyright 2023 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { defineConfig } from "vite";
+
+import { lib } from "@synnaxlabs/vite-plugin";
+
+export default defineConfig({
+  plugins: [lib({ name: "freighter" })],
+});

package/build/main/index.d.ts

@@ -1,7 +0,0 @@
-export { WebSocketClient } from './lib/websocket';
-export { MsgpackEncoderDecoder, JSONEncoderDecoder, registerCustomTypeEncoder, ENCODERS, } from './lib/encoder';
-export { StreamClient, Stream } from './lib/stream';
-export { UnaryClient } from './lib/unary';
-export { HTTPClientFactory } from './lib/http';
-export { default as URL } from './lib/url';
-export { encodeError, decodeError, registerError, BaseTypedError, TypedError, ErrorPayload, ErrorPayloadSchema, EOF, StreamClosed, Unreachable, } from './lib/errors';

package/build/main/index.js

@@ -1,27 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Unreachable = exports.StreamClosed = exports.EOF = exports.ErrorPayloadSchema = exports.BaseTypedError = exports.registerError = exports.decodeError = exports.encodeError = exports.URL = exports.HTTPClientFactory = exports.ENCODERS = exports.registerCustomTypeEncoder = exports.JSONEncoderDecoder = exports.MsgpackEncoderDecoder = exports.WebSocketClient = void 0;
-var websocket_1 = require("./lib/websocket");
-Object.defineProperty(exports, "WebSocketClient", { enumerable: true, get: function () { return websocket_1.WebSocketClient; } });
-var encoder_1 = require("./lib/encoder");
-Object.defineProperty(exports, "MsgpackEncoderDecoder", { enumerable: true, get: function () { return encoder_1.MsgpackEncoderDecoder; } });
-Object.defineProperty(exports, "JSONEncoderDecoder", { enumerable: true, get: function () { return encoder_1.JSONEncoderDecoder; } });
-Object.defineProperty(exports, "registerCustomTypeEncoder", { enumerable: true, get: function () { return encoder_1.registerCustomTypeEncoder; } });
-Object.defineProperty(exports, "ENCODERS", { enumerable: true, get: function () { return encoder_1.ENCODERS; } });
-var http_1 = require("./lib/http");
-Object.defineProperty(exports, "HTTPClientFactory", { enumerable: true, get: function () { return http_1.HTTPClientFactory; } });
-var url_1 = require("./lib/url");
-Object.defineProperty(exports, "URL", { enumerable: true, get: function () { return __importDefault(url_1).default; } });
-var errors_1 = require("./lib/errors");
-Object.defineProperty(exports, "encodeError", { enumerable: true, get: function () { return errors_1.encodeError; } });
-Object.defineProperty(exports, "decodeError", { enumerable: true, get: function () { return errors_1.decodeError; } });
-Object.defineProperty(exports, "registerError", { enumerable: true, get: function () { return errors_1.registerError; } });
-Object.defineProperty(exports, "BaseTypedError", { enumerable: true, get: function () { return errors_1.BaseTypedError; } });
-Object.defineProperty(exports, "ErrorPayloadSchema", { enumerable: true, get: function () { return errors_1.ErrorPayloadSchema; } });
-Object.defineProperty(exports, "EOF", { enumerable: true, get: function () { return errors_1.EOF; } });
-Object.defineProperty(exports, "StreamClosed", { enumerable: true, get: function () { return errors_1.StreamClosed; } });
-Object.defineProperty(exports, "Unreachable", { enumerable: true, get: function () { return errors_1.Unreachable; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEsNkNBQWtEO0FBQXpDLDRHQUFBLGVBQWUsT0FBQTtBQUN4Qix5Q0FLdUI7QUFKckIsZ0hBQUEscUJBQXFCLE9BQUE7QUFDckIsNkdBQUEsa0JBQWtCLE9BQUE7QUFDbEIsb0hBQUEseUJBQXlCLE9BQUE7QUFDekIsbUdBQUEsUUFBUSxPQUFBO0FBSVYsbUNBQStDO0FBQXRDLHlHQUFBLGlCQUFpQixPQUFBO0FBQzFCLGlDQUEyQztBQUFsQywyR0FBQSxPQUFPLE9BQU87QUFDdkIsdUNBV3NCO0FBVnBCLHFHQUFBLFdBQVcsT0FBQTtBQUNYLHFHQUFBLFdBQVcsT0FBQTtBQUNYLHVHQUFBLGFBQWEsT0FBQTtBQUNiLHdHQUFBLGNBQWMsT0FBQTtBQUdkLDRHQUFBLGtCQUFrQixPQUFBO0FBQ2xCLDZGQUFBLEdBQUcsT0FBQTtBQUNILHNHQUFBLFlBQVksT0FBQTtBQUNaLHFHQUFBLFdBQVcsT0FBQSJ9

package/build/main/lib/caseconv.d.ts

@@ -1,2 +0,0 @@
-export declare const snakeKeys: (entity: unknown) => object | null;
-export declare const camelKeys: (entity: unknown) => object | null;

package/build/main/lib/caseconv.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.camelKeys = exports.snakeKeys = void 0;
-const js_convert_case_1 = require("js-convert-case");
-const options = {
-    recursive: true,
-    recursiveInArray: true,
-    keepTypesOnRecursion: [Number, String, Uint8Array],
-};
-const snakeKeys = (entity) => (0, js_convert_case_1.snakeKeys)(entity, options);
-exports.snakeKeys = snakeKeys;
-const camelKeys = (entity) => (0, js_convert_case_1.camelKeys)(entity, options);
-exports.camelKeys = camelKeys;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FzZWNvbnYuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2Nhc2Vjb252LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHFEQUd5QjtBQUV6QixNQUFNLE9BQU8sR0FBRztJQUNkLFNBQVMsRUFBRSxJQUFJO0lBQ2YsZ0JBQWdCLEVBQUUsSUFBSTtJQUN0QixvQkFBb0IsRUFBRSxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsVUFBVSxDQUFDO0NBQ25ELENBQUM7QUFFSyxNQUFNLFNBQVMsR0FBRyxDQUFDLE1BQWUsRUFBRSxFQUFFLENBQUMsSUFBQSwyQkFBVSxFQUFDLE1BQU0sRUFBRSxPQUFPLENBQUMsQ0FBQztBQUE3RCxRQUFBLFNBQVMsYUFBb0Q7QUFDbkUsTUFBTSxTQUFTLEdBQUcsQ0FBQyxNQUFlLEVBQUUsRUFBRSxDQUFDLElBQUEsMkJBQVUsRUFBQyxNQUFNLEVBQUUsT0FBTyxDQUFDLENBQUM7QUFBN0QsUUFBQSxTQUFTLGFBQW9EIn0=

package/build/main/lib/encoder.d.ts

@@ -1,60 +0,0 @@
-import { ZodSchema } from 'zod';
-/**
- * CustomTypeEncoder is an interface for a class that needs to transform its
- * value before encoding.
- */
-interface CustomTypeEncoder {
-    /** The Class the custom encoder is set for */
-    Class: Function;
-    /**
-     * The function that transforms the value before encoding;
-     * @param instance - The instance of the class to transform.
-     * @returns The transformed value.
-     */
-    write<P>(instance: P): unknown;
-}
-/**
- * EncoderDecoder is an entity that encodes and decodes messages to and from
- * a binary format.
- */
-export interface EncoderDecoder {
-    /** The HTTP content type of the encoder */
-    contentType: string;
-    /**
-     * Encodes the given payload into a binary representation.
-     * @param payload - The payload to encode.
-     * @returns an ArrayBuffer containing the encoded payload.
-     */
-    encode(payload: unknown): ArrayBuffer;
-    /**
-     * Decodes the given binary representation into a type checked payload.
-     * @param data - The data to decode.
-     * @param schema - The schema to decode the data with.
-     */
-    decode<P>(data: Uint8Array | ArrayBuffer, schema: ZodSchema<P>): P;
-}
-interface StaticEncoderDecoder {
-    registerCustomType(encoder: CustomTypeEncoder): void;
-}
-/***
- * MsgpackEncoderDecoder is a msgpack implementation of EncoderDecoder.
- */
-export declare class MsgpackEncoderDecoder implements EncoderDecoder {
-    contentType: string;
-    encode(payload: unknown): ArrayBuffer;
-    decode<P>(data: Uint8Array, schema: ZodSchema<P>): P;
-    static registerCustomType(encoder: CustomTypeEncoder): void;
-}
-/**
- * JSONEncoderDecoder is a JSON implementation of EncoderDecoder.
- */
-export declare class JSONEncoderDecoder implements EncoderDecoder {
-    contentType: string;
-    encode(payload: unknown): ArrayBuffer;
-    decode<P>(data: Uint8Array, schema: ZodSchema<P>): P;
-    static registerCustomType(): void;
-}
-export declare const ENCODERS: EncoderDecoder[];
-export declare const ENCODER_CLASSES: StaticEncoderDecoder[];
-export declare const registerCustomTypeEncoder: (encoder: CustomTypeEncoder) => void;
-export {};

package/build/main/lib/encoder.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerCustomTypeEncoder = exports.ENCODER_CLASSES = exports.ENCODERS = exports.JSONEncoderDecoder = exports.MsgpackEncoderDecoder = void 0;
-const msgpackr_1 = require("msgpackr");
-const caseconv_1 = require("./caseconv");
-/***
- * MsgpackEncoderDecoder is a msgpack implementation of EncoderDecoder.
- */
-class MsgpackEncoderDecoder {
-    constructor() {
-        this.contentType = 'application/msgpack';
-    }
-    encode(payload) {
-        return (0, msgpackr_1.pack)((0, caseconv_1.snakeKeys)(payload));
-    }
-    decode(data, schema) {
-        return schema.parse((0, caseconv_1.camelKeys)((0, msgpackr_1.unpack)(new Uint8Array(data))));
-    }
-    static registerCustomType(encoder) {
-        (0, msgpackr_1.addExtension)(Object.assign({ type: 0 }, encoder));
-    }
-}
-exports.MsgpackEncoderDecoder = MsgpackEncoderDecoder;
-/**
- * JSONEncoderDecoder is a JSON implementation of EncoderDecoder.
- */
-class JSONEncoderDecoder {
-    constructor() {
-        this.contentType = 'application/json';
-    }
-    encode(payload) {
-        const json = JSON.stringify((0, caseconv_1.snakeKeys)(payload), (_, v) => {
-            if (ArrayBuffer.isView(v))
-                return Array.from(v);
-            return v;
-        });
-        return new TextEncoder().encode(json);
-    }
-    decode(data, schema) {
-        return schema.parse((0, caseconv_1.camelKeys)(JSON.parse(new TextDecoder().decode(data))));
-    }
-    static registerCustomType() {
-        return;
-    }
-}
-exports.JSONEncoderDecoder = JSONEncoderDecoder;
-exports.ENCODERS = [
-    new MsgpackEncoderDecoder(),
-    new JSONEncoderDecoder(),
-];
-exports.ENCODER_CLASSES = [
-    MsgpackEncoderDecoder,
-    JSONEncoderDecoder,
-];
-const registerCustomTypeEncoder = (encoder) => {
-    exports.ENCODER_CLASSES.forEach((encoderClass) => {
-        encoderClass.registerCustomType(encoder);
-    });
-};
-exports.registerCustomTypeEncoder = registerCustomTypeEncoder;
-//# sourceMappingURL=data:application/json;base64,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

package/build/main/lib/encoder.spec.js

@@ -1,26 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ava_1 = __importDefault(require("ava"));
-const zod_1 = require("zod");
-const encoder_1 = require("./encoder");
-const SampleSchema = zod_1.z.object({
-    channelKey: zod_1.z.string(),
-    timeStamp: zod_1.z.number(),
-    value: zod_1.z.unknown(),
-});
-encoder_1.ENCODERS.forEach((encoder) => {
-    (0, ava_1.default)(`encoder ${encoder.contentType}`, (t) => {
-        const sample = {
-            channelKey: 'test',
-            timeStamp: 123,
-            value: new Uint8Array([1, 2, 3]),
-        };
-        const encoded = encoder.encode(sample);
-        const decoded = encoder.decode(encoded, SampleSchema);
-        t.deepEqual(decoded, decoded);
-    });
-});
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5jb2Rlci5zcGVjLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi9lbmNvZGVyLnNwZWMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSw4Q0FBdUI7QUFDdkIsNkJBQXdCO0FBRXhCLHVDQUFxQztBQUVyQyxNQUFNLFlBQVksR0FBRyxPQUFDLENBQUMsTUFBTSxDQUFDO0lBQzVCLFVBQVUsRUFBRSxPQUFDLENBQUMsTUFBTSxFQUFFO0lBQ3RCLFNBQVMsRUFBRSxPQUFDLENBQUMsTUFBTSxFQUFFO0lBQ3JCLEtBQUssRUFBRSxPQUFDLENBQUMsT0FBTyxFQUFFO0NBQ25CLENBQUMsQ0FBQztBQUVILGtCQUFRLENBQUMsT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUU7SUFDM0IsSUFBQSxhQUFJLEVBQUMsV0FBVyxPQUFPLENBQUMsV0FBVyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEVBQUUsRUFBRTtRQUMzQyxNQUFNLE1BQU0sR0FBRztZQUNiLFVBQVUsRUFBRSxNQUFNO1lBQ2xCLFNBQVMsRUFBRSxHQUFHO1lBQ2QsS0FBSyxFQUFFLElBQUksVUFBVSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztTQUNqQyxDQUFDO1FBQ0YsTUFBTSxPQUFPLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUN2QyxNQUFNLE9BQU8sR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDLE9BQU8sRUFBRSxZQUFZLENBQUMsQ0FBQztRQUN0RCxDQUFDLENBQUMsU0FBUyxDQUFDLE9BQU8sRUFBRSxPQUFPLENBQUMsQ0FBQztJQUNoQyxDQUFDLENBQUMsQ0FBQztBQUNMLENBQUMsQ0FBQyxDQUFDIn0=

package/build/main/lib/errors.d.ts

@@ -1,77 +0,0 @@
-import { z } from 'zod';
-export interface TypedError extends Error {
-    discriminator: 'FreighterError';
-    /**
-     * @description Returns a unique type identifier for the error. Freighter uses this to
-     * determine the correct decoder to use on the other end of the freighter.
-     */
-    type: string;
-}
-export declare class BaseTypedError extends Error implements TypedError {
-    discriminator: 'FreighterError';
-    type: string;
-    constructor(message: string, type: string);
-}
-declare type ErrorDecoder = (encoded: string) => Error | undefined;
-declare type ErrorEncoder = (error: TypedError) => string;
-export declare const isTypedError: (error: unknown) => error is TypedError;
-export declare const assertErrorType: <T>(type: string, error?: Error) => T;
-export declare const UNKNOWN = "unknown";
-export declare const NONE = "nil";
-export declare const FREIGHTER = "freighter";
-export declare const ErrorPayloadSchema: z.ZodObject<{
-    type: z.ZodString;
-    data: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    type: string;
-    data: string;
-}, {
-    type: string;
-    data: string;
-}>;
-export declare type ErrorPayload = z.infer<typeof ErrorPayloadSchema>;
-/**
- * Registers a custom error type with the error registry, which allows it to be
- * encoded/decoded and sent over the network.
- *
- * @param type - A unique string identifier for the error type.
- * @param encode - A function that encodes the error into a string.
- * @param decode - A function that decodes the error from a string.
- */
-export declare const registerError: ({ type, encode, decode, }: {
-    type: string;
-    encode: ErrorEncoder;
-    decode: ErrorDecoder;
-}) => void;
-/**
- * Encodes an error into a payload that can be sent between a freighter server
- * and client.
- * @param error - The error to encode.
- * @returns The encoded error.
- */
-export declare const encodeError: (error: unknown) => ErrorPayload;
-/**
- * Decodes an error payload into an exception. If a custom decoder can be found
- * for the error type, it will be used. Otherwise, a generic Error containing
- * the error data is returned.
- *
- * @param payload - The encoded error payload.
- * @returns The decoded error.
- */
-export declare const decodeError: (payload: ErrorPayload) => Error | undefined;
-export declare class UnknownError extends BaseTypedError implements TypedError {
-    constructor(message: string);
-}
-/** Thrown/returned when a stream closed normally. */
-export declare class EOF extends BaseTypedError implements TypedError {
-    constructor();
-}
-/** Thrown/returned when a stream is closed abnormally. */
-export declare class StreamClosed extends BaseTypedError implements TypedError {
-    constructor();
-}
-/** Thrown when a target is unreachable. */
-export declare class Unreachable extends BaseTypedError implements TypedError {
-    constructor();
-}
-export {};