@synnaxlabs/freighter 0.1.0

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

@@ -0,0 +1,73 @@
+"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 errors_1 = require("./errors");
+const url_1 = __importDefault(require("./url"));
+const websocket_1 = require("./websocket");
+const url = new url_1.default({
+    host: '127.0.0.1',
+    port: 8080,
+});
+const MessageSchema = zod_1.z.object({
+    id: zod_1.z.number().optional(),
+    message: zod_1.z.string().optional(),
+});
+const client = new websocket_1.WebSocketClient(new encoder_1.JSONEncoderDecoder(), url);
+class MyCustomError extends errors_1.BaseTypedError {
+    constructor(message, code) {
+        super(message, 'integration.error');
+        this.code = code;
+    }
+}
+const encodeTestError = (err) => {
+    if (!(err instanceof MyCustomError)) {
+        throw new Error('Unexpected error type');
+    }
+    return `${err.code},${err.message}`;
+};
+const decodeTestError = (encoded) => {
+    const [code, message] = encoded.split(',');
+    return new MyCustomError(message, parseInt(code, 10));
+};
+(0, errors_1.registerError)({
+    type: 'integration.error',
+    encode: encodeTestError,
+    decode: decodeTestError,
+});
+(0, ava_1.default)('basic exchange', async (t) => {
+    const stream = await client.stream('ws/echo', MessageSchema, MessageSchema);
+    for (let i = 0; i < 10; i++) {
+        stream.send({ id: i, message: 'hello' });
+        const [response, error] = await stream.receive();
+        t.is(error, undefined);
+        t.is(response === null || response === void 0 ? void 0 : response.id, i + 1);
+        t.is(response === null || response === void 0 ? void 0 : response.message, 'hello');
+    }
+    stream.closeSend();
+    const [response, error] = await stream.receive();
+    t.deepEqual(error, new errors_1.EOF());
+    t.is(response, undefined);
+});
+(0, ava_1.default)('receive message after close', async (t) => {
+    const stream = await client.stream('ws/sendMessageAfterClientClose', MessageSchema, MessageSchema);
+    await stream.closeSend();
+    let [response, error] = await stream.receive();
+    t.is(error, undefined);
+    t.is(response === null || response === void 0 ? void 0 : response.id, 0);
+    t.is(response === null || response === void 0 ? void 0 : response.message, 'Close Acknowledged');
+    [response, error] = await stream.receive();
+    t.deepEqual(error, new errors_1.EOF());
+});
+(0, ava_1.default)('receive error', async (t) => {
+    const stream = await client.stream('ws/receiveAndExitWithErr', MessageSchema, MessageSchema);
+    stream.send({ id: 0, message: 'hello' });
+    const [response, error] = await stream.receive();
+    t.deepEqual(error, new MyCustomError('unexpected error', 1));
+    t.is(response, undefined);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid3Muc3BlYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvd3Muc3BlYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLDhDQUF1QjtBQUN2Qiw2QkFBd0I7QUFFeEIsdUNBQStDO0FBQy9DLHFDQUEwRTtBQUMxRSxnREFBd0I7QUFDeEIsMkNBQThDO0FBRTlDLE1BQU0sR0FBRyxHQUFHLElBQUksYUFBRyxDQUFDO0lBQ2xCLElBQUksRUFBRSxXQUFXO0lBQ2pCLElBQUksRUFBRSxJQUFJO0NBQ1gsQ0FBQyxDQUFDO0FBRUgsTUFBTSxhQUFhLEdBQUcsT0FBQyxDQUFDLE1BQU0sQ0FBQztJQUM3QixFQUFFLEVBQUUsT0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFDLFFBQVEsRUFBRTtJQUN6QixPQUFPLEVBQUUsT0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFDLFFBQVEsRUFBRTtDQUMvQixDQUFDLENBQUM7QUFFSCxNQUFNLE1BQU0sR0FBRyxJQUFJLDJCQUFlLENBQUMsSUFBSSw0QkFBa0IsRUFBRSxFQUFFLEdBQUcsQ0FBQyxDQUFDO0FBRWxFLE1BQU0sYUFBYyxTQUFRLHVCQUFjO0lBR3hDLFlBQVksT0FBZSxFQUFFLElBQVk7UUFDdkMsS0FBSyxDQUFDLE9BQU8sRUFBRSxtQkFBbUIsQ0FBQyxDQUFDO1FBQ3BDLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO0lBQ25CLENBQUM7Q0FDRjtBQUVELE1BQU0sZUFBZSxHQUFHLENBQUMsR0FBZSxFQUFVLEVBQUU7SUFDbEQsSUFBSSxDQUFDLENBQUMsR0FBRyxZQUFZLGFBQWEsQ0FBQyxFQUFFO1FBQ25DLE1BQU0sSUFBSSxLQUFLLENBQUMsdUJBQXVCLENBQUMsQ0FBQztLQUMxQztJQUNELE9BQU8sR0FBRyxHQUFHLENBQUMsSUFBSSxJQUFJLEdBQUcsQ0FBQyxPQUFPLEVBQUUsQ0FBQztBQUN0QyxDQUFDLENBQUM7QUFFRixNQUFNLGVBQWUsR0FBRyxDQUFDLE9BQWUsRUFBYyxFQUFFO0lBQ3RELE1BQU0sQ0FBQyxJQUFJLEVBQUUsT0FBTyxDQUFDLEdBQUcsT0FBTyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUMzQyxPQUFPLElBQUksYUFBYSxDQUFDLE9BQU8sRUFBRSxRQUFRLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUM7QUFDeEQsQ0FBQyxDQUFDO0FBRUYsSUFBQSxzQkFBYSxFQUFDO0lBQ1osSUFBSSxFQUFFLG1CQUFtQjtJQUN6QixNQUFNLEVBQUUsZUFBZTtJQUN2QixNQUFNLEVBQUUsZUFBZTtDQUN4QixDQUFDLENBQUM7QUFFSCxJQUFBLGFBQUksRUFBQyxnQkFBZ0IsRUFBRSxLQUFLLEVBQUUsQ0FBQyxFQUFFLEVBQUU7SUFDakMsTUFBTSxNQUFNLEdBQUcsTUFBTSxNQUFNLENBQUMsTUFBTSxDQUFDLFNBQVMsRUFBRSxhQUFhLEVBQUUsYUFBYSxDQUFDLENBQUM7SUFDNUUsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLEVBQUUsRUFBRTtRQUMzQixNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsRUFBRSxFQUFFLENBQUMsRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQztRQUN6QyxNQUFNLENBQUMsUUFBUSxFQUFFLEtBQUssQ0FBQyxHQUFHLE1BQU0sTUFBTSxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ2pELENBQUMsQ0FBQyxFQUFFLENBQUMsS0FBSyxFQUFFLFNBQVMsQ0FBQyxDQUFDO1FBQ3ZCLENBQUMsQ0FBQyxFQUFFLENBQUMsUUFBUSxhQUFSLFFBQVEsdUJBQVIsUUFBUSxDQUFFLEVBQUUsRUFBRSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7UUFDMUIsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxRQUFRLGFBQVIsUUFBUSx1QkFBUixRQUFRLENBQUUsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0tBQ2xDO0lBQ0QsTUFBTSxDQUFDLFNBQVMsRUFBRSxDQUFDO0lBQ25CLE1BQU0sQ0FBQyxRQUFRLEVBQUUsS0FBSyxDQUFDLEdBQUcsTUFBTSxNQUFNLENBQUMsT0FBTyxFQUFFLENBQUM7SUFDakQsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxLQUFLLEVBQUUsSUFBSSxZQUFHLEVBQUUsQ0FBQyxDQUFDO0lBQzlCLENBQUMsQ0FBQyxFQUFFLENBQUMsUUFBUSxFQUFFLFNBQVMsQ0FBQyxDQUFDO0FBQzVCLENBQUMsQ0FBQyxDQUFDO0FBRUgsSUFBQSxhQUFJLEVBQUMsNkJBQTZCLEVBQUUsS0FBSyxFQUFFLENBQUMsRUFBRSxFQUFFO0lBQzlDLE1BQU0sTUFBTSxHQUFHLE1BQU0sTUFBTSxDQUFDLE1BQU0sQ0FDaEMsZ0NBQWdDLEVBQ2hDLGFBQWEsRUFDYixhQUFhLENBQ2QsQ0FBQztJQUNGLE1BQU0sTUFBTSxDQUFDLFNBQVMsRUFBRSxDQUFDO0lBQ3pCLElBQUksQ0FBQyxRQUFRLEVBQUUsS0FBSyxDQUFDLEdBQUcsTUFBTSxNQUFNLENBQUMsT0FBTyxFQUFFLENBQUM7SUFDL0MsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxLQUFLLEVBQUUsU0FBUyxDQUFDLENBQUM7SUFDdkIsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxRQUFRLGFBQVIsUUFBUSx1QkFBUixRQUFRLENBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ3RCLENBQUMsQ0FBQyxFQUFFLENBQUMsUUFBUSxhQUFSLFFBQVEsdUJBQVIsUUFBUSxDQUFFLE9BQU8sRUFBRSxvQkFBb0IsQ0FBQyxDQUFDO0lBQzlDLENBQUMsUUFBUSxFQUFFLEtBQUssQ0FBQyxHQUFHLE1BQU0sTUFBTSxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQzNDLENBQUMsQ0FBQyxTQUFTLENBQUMsS0FBSyxFQUFFLElBQUksWUFBRyxFQUFFLENBQUMsQ0FBQztBQUNoQyxDQUFDLENBQUMsQ0FBQztBQUVILElBQUEsYUFBSSxFQUFDLGVBQWUsRUFBRSxLQUFLLEVBQUUsQ0FBQyxFQUFFLEVBQUU7SUFDaEMsTUFBTSxNQUFNLEdBQUcsTUFBTSxNQUFNLENBQUMsTUFBTSxDQUNoQywwQkFBMEIsRUFDMUIsYUFBYSxFQUNiLGFBQWEsQ0FDZCxDQUFDO0lBQ0YsTUFBTSxDQUFDLElBQUksQ0FBQyxFQUFFLEVBQUUsRUFBRSxDQUFDLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDLENBQUM7SUFDekMsTUFBTSxDQUFDLFFBQVEsRUFBRSxLQUFLLENBQUMsR0FBRyxNQUFNLE1BQU0sQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUNqRCxDQUFDLENBQUMsU0FBUyxDQUFDLEtBQUssRUFBRSxJQUFJLGFBQWEsQ0FBQyxrQkFBa0IsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQzdELENBQUMsQ0FBQyxFQUFFLENBQUMsUUFBUSxFQUFFLFNBQVMsQ0FBQyxDQUFDO0FBQzVCLENBQUMsQ0FBQyxDQUFDIn0=

package/build/module/index.d.ts

@@ -0,0 +1,7 @@
+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/module/index.js

@@ -0,0 +1,6 @@
+export { WebSocketClient } from './lib/websocket';
+export { MsgpackEncoderDecoder, JSONEncoderDecoder, registerCustomTypeEncoder, ENCODERS, } from './lib/encoder';
+export { HTTPClientFactory } from './lib/http';
+export { default as URL } from './lib/url';
+export { encodeError, decodeError, registerError, BaseTypedError, ErrorPayloadSchema, EOF, StreamClosed, Unreachable, } from './lib/errors';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ2xELE9BQU8sRUFDTCxxQkFBcUIsRUFDckIsa0JBQWtCLEVBQ2xCLHlCQUF5QixFQUN6QixRQUFRLEdBQ1QsTUFBTSxlQUFlLENBQUM7QUFHdkIsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sWUFBWSxDQUFDO0FBQy9DLE9BQU8sRUFBRSxPQUFPLElBQUksR0FBRyxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBQzNDLE9BQU8sRUFDTCxXQUFXLEVBQ1gsV0FBVyxFQUNYLGFBQWEsRUFDYixjQUFjLEVBR2Qsa0JBQWtCLEVBQ2xCLEdBQUcsRUFDSCxZQUFZLEVBQ1osV0FBVyxHQUNaLE1BQU0sY0FBYyxDQUFDIn0=

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

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

package/build/module/lib/caseconv.js

@@ -0,0 +1,9 @@
+import { camelKeys as _camelKeys, snakeKeys as _snakeKeys, } from 'js-convert-case';
+const options = {
+    recursive: true,
+    recursiveInArray: true,
+    keepTypesOnRecursion: [Number, String, Uint8Array],
+};
+export const snakeKeys = (entity) => _snakeKeys(entity, options);
+export const camelKeys = (entity) => _camelKeys(entity, options);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FzZWNvbnYuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2Nhc2Vjb252LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxTQUFTLElBQUksVUFBVSxFQUN2QixTQUFTLElBQUksVUFBVSxHQUN4QixNQUFNLGlCQUFpQixDQUFDO0FBRXpCLE1BQU0sT0FBTyxHQUFHO0lBQ2QsU0FBUyxFQUFFLElBQUk7SUFDZixnQkFBZ0IsRUFBRSxJQUFJO0lBQ3RCLG9CQUFvQixFQUFFLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRSxVQUFVLENBQUM7Q0FDbkQsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBRyxDQUFDLE1BQWUsRUFBRSxFQUFFLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxPQUFPLENBQUMsQ0FBQztBQUMxRSxNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUcsQ0FBQyxNQUFlLEVBQUUsRUFBRSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsT0FBTyxDQUFDLENBQUMifQ==

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

@@ -0,0 +1,60 @@
+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/module/lib/encoder.js

@@ -0,0 +1,51 @@
+import { addExtension, pack, unpack } from 'msgpackr';
+import { camelKeys, snakeKeys } from './caseconv';
+/***
+ * MsgpackEncoderDecoder is a msgpack implementation of EncoderDecoder.
+ */
+export class MsgpackEncoderDecoder {
+    contentType = 'application/msgpack';
+    encode(payload) {
+        return pack(snakeKeys(payload));
+    }
+    decode(data, schema) {
+        return schema.parse(camelKeys(unpack(new Uint8Array(data))));
+    }
+    static registerCustomType(encoder) {
+        addExtension({ type: 0, ...encoder });
+    }
+}
+/**
+ * JSONEncoderDecoder is a JSON implementation of EncoderDecoder.
+ */
+export class JSONEncoderDecoder {
+    contentType = 'application/json';
+    encode(payload) {
+        const json = JSON.stringify(snakeKeys(payload), (_, v) => {
+            if (ArrayBuffer.isView(v))
+                return Array.from(v);
+            return v;
+        });
+        return new TextEncoder().encode(json);
+    }
+    decode(data, schema) {
+        return schema.parse(camelKeys(JSON.parse(new TextDecoder().decode(data))));
+    }
+    static registerCustomType() {
+        return;
+    }
+}
+export const ENCODERS = [
+    new MsgpackEncoderDecoder(),
+    new JSONEncoderDecoder(),
+];
+export const ENCODER_CLASSES = [
+    MsgpackEncoderDecoder,
+    JSONEncoderDecoder,
+];
+export const registerCustomTypeEncoder = (encoder) => {
+    ENCODER_CLASSES.forEach((encoderClass) => {
+        encoderClass.registerCustomType(encoder);
+    });
+};
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/encoder.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,21 @@
+import test from 'ava';
+import { z } from 'zod';
+import { ENCODERS } from './encoder';
+const SampleSchema = z.object({
+    channelKey: z.string(),
+    timeStamp: z.number(),
+    value: z.unknown(),
+});
+ENCODERS.forEach((encoder) => {
+    test(`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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5jb2Rlci5zcGVjLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi9lbmNvZGVyLnNwZWMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxJQUFJLE1BQU0sS0FBSyxDQUFDO0FBQ3ZCLE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEIsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUVyQyxNQUFNLFlBQVksR0FBRyxDQUFDLENBQUMsTUFBTSxDQUFDO0lBQzVCLFVBQVUsRUFBRSxDQUFDLENBQUMsTUFBTSxFQUFFO0lBQ3RCLFNBQVMsRUFBRSxDQUFDLENBQUMsTUFBTSxFQUFFO0lBQ3JCLEtBQUssRUFBRSxDQUFDLENBQUMsT0FBTyxFQUFFO0NBQ25CLENBQUMsQ0FBQztBQUVILFFBQVEsQ0FBQyxPQUFPLENBQUMsQ0FBQyxPQUFPLEVBQUUsRUFBRTtJQUMzQixJQUFJLENBQUMsV0FBVyxPQUFPLENBQUMsV0FBVyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEVBQUUsRUFBRTtRQUMzQyxNQUFNLE1BQU0sR0FBRztZQUNiLFVBQVUsRUFBRSxNQUFNO1lBQ2xCLFNBQVMsRUFBRSxHQUFHO1lBQ2QsS0FBSyxFQUFFLElBQUksVUFBVSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztTQUNqQyxDQUFDO1FBQ0YsTUFBTSxPQUFPLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUN2QyxNQUFNLE9BQU8sR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDLE9BQU8sRUFBRSxZQUFZLENBQUMsQ0FBQztRQUN0RCxDQUFDLENBQUMsU0FBUyxDQUFDLE9BQU8sRUFBRSxPQUFPLENBQUMsQ0FBQztJQUNoQyxDQUFDLENBQUMsQ0FBQztBQUNMLENBQUMsQ0FBQyxDQUFDIn0=

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

@@ -0,0 +1,77 @@
+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 {};

package/build/module/lib/errors.js

@@ -0,0 +1,160 @@
+import { z } from 'zod';
+export class BaseTypedError extends Error {
+    discriminator = 'FreighterError';
+    type;
+    constructor(message, type) {
+        super(message);
+        this.type = type;
+    }
+}
+export const isTypedError = (error) => {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const typedError = error;
+    if (typedError.discriminator !== 'FreighterError') {
+        return false;
+    }
+    if (!('type' in typedError)) {
+        throw new Error(`Freighter error is missing its type property: ${typedError}`);
+    }
+    return true;
+};
+export const assertErrorType = (type, error) => {
+    if (!error) {
+        throw new Error(`Expected error of type ${type} but got nothing instead`);
+    }
+    if (!isTypedError(error)) {
+        throw new Error(`Expected a typed error, got: ${error}`);
+    }
+    if (error.type !== type) {
+        throw new Error(`Expected error of type ${type}, got ${error.type}: ${error}`);
+    }
+    return error;
+};
+export const UNKNOWN = 'unknown';
+export const NONE = 'nil';
+export const FREIGHTER = 'freighter';
+export const ErrorPayloadSchema = z.object({
+    type: z.string(),
+    data: z.string(),
+});
+class Registry {
+    entries;
+    constructor() {
+        this.entries = {};
+    }
+    register(_type, provider) {
+        if (this.entries[_type]) {
+            throw new Error(`Error type ${_type} is already registered`);
+        }
+        this.entries[_type] = provider;
+    }
+    encode(error) {
+        if (!error) {
+            return { type: NONE, data: '' };
+        }
+        if (isTypedError(error) && this.entries[error.type]) {
+            return { type: error.type, data: this.entries[error.type].encode(error) };
+        }
+        return { type: UNKNOWN, data: JSON.stringify(error) };
+    }
+    decode(payload) {
+        if (payload.type === NONE) {
+            return undefined;
+        }
+        if (payload.type === UNKNOWN) {
+            return new UnknownError(payload.data);
+        }
+        const provider = this.entries[payload.type];
+        if (!provider) {
+            return new UnknownError(payload.data);
+        }
+        return provider.decode(payload.data);
+    }
+}
+const REGISTRY = new Registry();
+/**
+ * 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 const registerError = ({ type, encode, decode, }) => {
+    REGISTRY.register(type, { encode, decode });
+};
+/**
+ * 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 const encodeError = (error) => {
+    return REGISTRY.encode(error);
+};
+/**
+ * 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 const decodeError = (payload) => {
+    return REGISTRY.decode(payload);
+};
+export class UnknownError extends BaseTypedError {
+    constructor(message) {
+        super(message, UNKNOWN);
+    }
+}
+/** Thrown/returned when a stream closed normally. */
+export class EOF extends BaseTypedError {
+    constructor() {
+        super('EOF', FREIGHTER);
+    }
+}
+/** Thrown/returned when a stream is closed abnormally. */
+export class StreamClosed extends BaseTypedError {
+    constructor() {
+        super('StreamClosed', FREIGHTER);
+    }
+}
+/** Thrown when a target is unreachable. */
+export class Unreachable extends BaseTypedError {
+    constructor() {
+        super('Unreachable', FREIGHTER);
+    }
+}
+const freighterErrorEncoder = (error) => {
+    if (error instanceof EOF) {
+        return 'EOF';
+    }
+    if (error instanceof StreamClosed) {
+        return 'StreamClosed';
+    }
+    if (error instanceof Unreachable) {
+        return 'Unreachable';
+    }
+    throw new Error(`Unknown error type: ${error}`);
+};
+const freighterErrorDecoder = (encoded) => {
+    switch (encoded) {
+        case 'EOF':
+            return new EOF();
+        case 'StreamClosed':
+            return new StreamClosed();
+        case 'Unreachable':
+            return new Unreachable();
+        default:
+            throw new Error(`Unknown error type: ${encoded}`);
+    }
+};
+registerError({
+    type: FREIGHTER,
+    encode: freighterErrorEncoder,
+    decode: freighterErrorDecoder,
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/errors.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/module/lib/errors.spec.js

@@ -0,0 +1,71 @@
+import test from 'ava';
+import { assertErrorType, BaseTypedError, decodeError, encodeError, EOF, FREIGHTER, isTypedError, NONE, registerError, StreamClosed, UNKNOWN, UnknownError, Unreachable, } from './errors';
+class MyCustomError extends BaseTypedError {
+    constructor(message) {
+        super(message, 'MyCustomError');
+    }
+}
+const myCustomErrorEncoder = (error) => {
+    return error.message;
+};
+const myCustomErrorDecoder = (encoded) => {
+    return new MyCustomError(encoded);
+};
+test('isTypedError', (t) => {
+    const error = new MyCustomError('test');
+    const fError = isTypedError(error);
+    t.is(fError, true);
+    t.is(error.type, 'MyCustomError');
+});
+test('encoding and decoding a custom error through registry', (t) => {
+    registerError({
+        type: 'MyCustomError',
+        encode: myCustomErrorEncoder,
+        decode: myCustomErrorDecoder,
+    });
+    const error = new MyCustomError('test');
+    const encoded = encodeError(error);
+    t.is(encoded.type, 'MyCustomError');
+    t.is(encoded.data, 'test');
+    const decoded = assertErrorType('MyCustomError', decodeError(encoded));
+    t.is(decoded.message, 'test');
+});
+test('encoding and decoding a null error', (t) => {
+    const encoded = encodeError(null);
+    t.is(encoded.type, NONE);
+    t.is(encoded.data, '');
+    const decoded = decodeError(encoded);
+    t.is(decoded, undefined);
+});
+test('encoding and decoding an unrecognized error', (t) => {
+    const error = new Error('test');
+    const encoded = encodeError(error);
+    t.is(encoded.type, UNKNOWN);
+    t.is(encoded.data, '{}');
+    const decoded = decodeError(encoded);
+    t.deepEqual(decoded, new UnknownError('{}'));
+});
+test('registering duplicate error should throw', (t) => {
+    registerError({
+        type: 'MyDuplicateError',
+        encode: myCustomErrorEncoder,
+        decode: myCustomErrorDecoder,
+    });
+    t.throws(() => {
+        registerError({
+            type: 'MyDuplicateError',
+            encode: myCustomErrorEncoder,
+            decode: myCustomErrorDecoder,
+        });
+    });
+});
+test('encoding and decoding freighter errors', (t) => {
+    [new EOF(), new StreamClosed(), new Unreachable()].forEach((error) => {
+        const encoded = encodeError(error);
+        t.is(encoded.type, FREIGHTER);
+        t.is(encoded.data, error.message);
+        const decoded = decodeError(encoded);
+        t.deepEqual(decoded, error);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/http.d.ts

@@ -0,0 +1,46 @@
+import { AxiosRequestConfig } from 'axios';
+import { ZodSchema } from 'zod';
+import { EncoderDecoder } from './encoder';
+import { UnaryClient } from './unary';
+import URL from './url';
+/**
+ * HTTPClientFactory provides a POST and GET implementation of the Unary protocol.
+ *
+ * @param url - The base URL of the API.
+ * @param encoder - The encoder/decoder to use for the request/response.
+ */
+export declare class HTTPClientFactory {
+    endpoint: URL;
+    encoder: EncoderDecoder;
+    constructor(endpoint: URL, encoder: EncoderDecoder);
+    getClient(): GETClient;
+    postClient(): POSTClient;
+}
+declare class Core {
+    endpoint: URL;
+    encoder: EncoderDecoder;
+    private static ERROR_ENCODING_HEADER_KEY;
+    private static ERROR_ENCODING_HEADER_VALUE;
+    private static CONTENT_TYPE_HEADER_KEY;
+    constructor(endpoint: URL, encoder: EncoderDecoder);
+    get headers(): {
+        [x: string]: string;
+    };
+    requestConfig(): AxiosRequestConfig;
+    execute<RS>(request: AxiosRequestConfig, resSchema: ZodSchema<RS>): Promise<[RS | undefined, Error | undefined]>;
+}
+/**
+ * Implementation of the UnaryClient protocol backed by HTTP GET requests. It
+ * should not be instantiated directly, but through the HTTPClientFactory.
+ */
+export declare class GETClient extends Core implements UnaryClient {
+    send<RQ, RS>(target: string, req: RQ, resSchema: ZodSchema<RS>): Promise<[RS | undefined, Error | undefined]>;
+}
+/**
+ * Implementation of the UnaryClient protocol backed by HTTP POST requests. It
+ * should not be instantiated directly, but through the HTTPClientFactory.
+ */
+export declare class POSTClient extends Core implements UnaryClient {
+    send<RQ, RS>(target: string, req: RQ, resSchema: ZodSchema<RS>): Promise<[RS | undefined, Error | undefined]>;
+}
+export {};