@arrirpc/client 0.45.0

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright 2024 Joshua Sosso
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# arri-client
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build arri-client` to build the library.
+
+## Running unit tests
+
+Run `nx test arri-client` to execute the unit tests via [Jest](https://jestjs.io).

package/dist/index.cjs

@@ -0,0 +1,465 @@
+'use strict';
+
+const ofetch = require('ofetch');
+const eventSourcePlus = require('event-source-plus');
+const NodeWebsocket = require('ws');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const NodeWebsocket__default = /*#__PURE__*/_interopDefaultCompat(NodeWebsocket);
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+function isArriError(input) {
+  if (typeof input !== "object" || input === null) {
+    return false;
+  }
+  if ("stack" in input && typeof input !== "string") {
+    return false;
+  }
+  if ("serverStack" in input && typeof input !== "string") {
+    return false;
+  }
+  return "code" in input && typeof input.code === "number" && "message" in input && typeof input.message === "string";
+}
+class ArriErrorInstance extends Error {
+  constructor(input) {
+    super(input.message);
+    __publicField$1(this, "code");
+    __publicField$1(this, "data");
+    __publicField$1(this, "serverStack");
+    __publicField$1(this, "_internalMessage");
+    this.code = input.code;
+    this.serverStack = input.stack;
+    this._internalMessage = input.message;
+    this.data = input.data;
+  }
+  toJSON() {
+    const stack = this.serverStack ?? this.stack;
+    return {
+      code: this.code,
+      message: this._internalMessage,
+      stack: stack?.split("\n").map((l) => l.trim()),
+      data: this.data
+    };
+  }
+  static fromJson(json) {
+    let parsedJson = json;
+    if (typeof parsedJson === "string") {
+      try {
+        parsedJson = JSON.parse(parsedJson);
+      } catch (_) {
+      }
+    }
+    if (typeof parsedJson !== "object" || parsedJson === null) {
+      return new ArriErrorInstance({
+        code: 500,
+        message: "Unknown error",
+        data: parsedJson
+      });
+    }
+    return new ArriErrorInstance({
+      code: "code" in parsedJson && typeof parsedJson.code === "number" ? parsedJson.code : 500,
+      message: "message" in parsedJson && typeof parsedJson.message === "string" ? parsedJson.message : "",
+      stack: "stack" in parsedJson && Array.isArray(parsedJson.stack) ? parsedJson.stack.join("\n") : void 0,
+      data: "data" in parsedJson ? parsedJson.data : void 0
+    });
+  }
+}
+
+async function arriRequest(opts) {
+  let url = opts.url;
+  let body;
+  let contentType;
+  switch (opts.method) {
+    case "get":
+    case "head":
+      if (opts.params && typeof opts.params === "object") {
+        const urlParts = [];
+        Object.keys(opts.params).forEach((key) => {
+          urlParts.push(`${key}=${opts.params[key]}`);
+        });
+        url = `${opts.url}?${urlParts.join("&")}`;
+      }
+      break;
+    default:
+      if (opts.params && typeof opts.params === "object") {
+        body = opts.serializer(opts.params);
+        contentType = "application/json";
+      }
+      break;
+  }
+  try {
+    let headers = {};
+    if (typeof opts.headers === "function") {
+      headers = opts.headers();
+    } else {
+      headers = opts.headers ?? {};
+    }
+    if (contentType)
+      headers["Content-Type"] = contentType;
+    if (opts.clientVersion)
+      headers["client-version"] = opts.clientVersion;
+    const result = await ofetch.ofetch(url, {
+      method: opts.method,
+      body,
+      headers
+    });
+    return opts.parser(result);
+  } catch (err) {
+    const error = err;
+    if (isArriError(error.data)) {
+      throw new ArriErrorInstance(error.data);
+    } else {
+      throw new ArriErrorInstance({
+        code: error.statusCode ?? 500,
+        message: error.statusMessage ?? error.message ?? `Error connecting to ${url}`,
+        data: error.data,
+        stack: error.stack
+      });
+    }
+  }
+}
+async function arriSafeRequest(opts) {
+  try {
+    const result = await arriRequest(opts);
+    return {
+      success: true,
+      value: result
+    };
+  } catch (err) {
+    if (err instanceof ArriErrorInstance) {
+      return {
+        success: false,
+        error: err
+      };
+    }
+    if (err instanceof ofetch.FetchError) {
+      return {
+        success: false,
+        error: new ArriErrorInstance({
+          code: err.statusCode ?? 0,
+          message: err.statusMessage ?? "",
+          stack: err.stack,
+          data: err.data
+        })
+      };
+    }
+    return {
+      success: false,
+      error: new ArriErrorInstance({
+        code: 500,
+        message: `Unknown error connecting to ${opts.url}`,
+        data: err
+      })
+    };
+  }
+}
+
+function arriSseRequest(opts, options) {
+  let url = opts.url;
+  let body;
+  switch (opts.method) {
+    case "get":
+    case "head":
+      if (opts.params && typeof opts.params === "object" && opts.params !== null) {
+        const urlParts = [];
+        Object.keys(opts.params).forEach((key) => {
+          urlParts.push(`${key}=${opts.params[key]}`);
+        });
+        url = `${opts.url}?${urlParts.join("&")}`;
+      }
+      break;
+    default:
+      if (opts.params && typeof opts.params === "object") {
+        body = opts.serializer(opts.params);
+      }
+      break;
+  }
+  const eventSource = new eventSourcePlus.EventSourcePlus(url, {
+    method: opts.method ?? "get",
+    headers: () => {
+      let headers;
+      if (typeof opts.headers === "function") {
+        headers = opts.headers();
+      } else {
+        headers = opts.headers ?? {};
+      }
+      if (opts.clientVersion) {
+        headers["client-version"] = opts.clientVersion;
+      }
+      return headers;
+    },
+    body,
+    maxRetryCount: options.maxRetryCount,
+    maxRetryInterval: options.maxRetryInterval
+  });
+  const controller = eventSource.listen({
+    onMessage(message) {
+      if (message.event === "message" || message.event === void 0 || message.event === "") {
+        options.onMessage?.(opts.parser(message.data));
+        return;
+      }
+      if (message.event === "error") {
+        options.onErrorMessage?.(
+          ArriErrorInstance.fromJson(message.data)
+        );
+        return;
+      }
+      if (message.event === "done") {
+        controller.abort();
+      }
+    },
+    onRequest(context) {
+      options.onRequest?.(context);
+    },
+    onRequestError(context) {
+      options.onRequestError?.({
+        ...context,
+        error: new ArriErrorInstance({
+          code: 0,
+          message: context.error.message,
+          data: context.error
+        })
+      });
+    },
+    onResponse(context) {
+      options.onResponse?.(context);
+    },
+    async onResponseError(context) {
+      if (!options.onResponseError) {
+        return;
+      }
+      try {
+        const arriError = ArriErrorInstance.fromJson(
+          await context.response.json()
+        );
+        options.onResponseError({
+          ...context,
+          error: arriError
+        });
+      } catch (_) {
+        const arriError = new ArriErrorInstance({
+          code: context.response.status ?? 0,
+          message: context.response.statusText
+        });
+        options.onResponseError({ ...context, error: arriError });
+      }
+    }
+  });
+  return controller;
+}
+function parseSseEvent(input, dataParser) {
+  let id;
+  let event;
+  let data;
+  const lines = input.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("id:")) {
+      id = line.substring(3).trim();
+      continue;
+    }
+    if (line.startsWith("event:")) {
+      event = line.substring(6).trim();
+      continue;
+    }
+    if (line.startsWith("data:")) {
+      data = dataParser(line.substring(5).trim());
+    }
+  }
+  if (!data) {
+    return void 0;
+  }
+  return {
+    id,
+    event,
+    data
+  };
+}
+function parseSseEvents(input, dataParser) {
+  const eventStrings = input.split("\n\n");
+  const events = [];
+  for (const str of eventStrings) {
+    const event = parseSseEvent(str, dataParser);
+    if (event) {
+      events.push(event);
+    }
+  }
+  return events;
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+function connectWebsocket(url, protocol) {
+  if (isBrowser()) {
+    return new WebSocket(url, protocol);
+  }
+  return new NodeWebsocket__default(url, {
+    protocol
+  });
+}
+function arriWsRequest(opts, retryCount = 0) {
+  let url = opts.url.replace("http://", "ws://").replace("https://", "wss://");
+  let headers;
+  if (typeof opts.headers === "function") {
+    headers = opts.headers();
+  } else {
+    headers = opts.headers;
+  }
+  if (headers) {
+    if (opts.clientVersion)
+      headers["client-version"] = opts.clientVersion;
+    const queryParts = [];
+    for (const key of Object.keys(headers)) {
+      queryParts.push(`${key}=${headers[key]}`);
+    }
+    url += `?${queryParts.join("&")}`;
+  }
+  try {
+    const controller = new WsController({
+      url,
+      parser: opts.parser,
+      serializer: opts.serializer ?? ((_) => ""),
+      onOpen: opts.onOpen,
+      onClose: opts.onClose,
+      onMessage: opts.onMessage,
+      onErrorMessage: opts.onError,
+      onConnectionError: opts.onConnectionError
+    });
+    return controller;
+  } catch (err) {
+    console.error(err);
+    if (opts.onConnectionError) {
+      opts.onConnectionError(err);
+    }
+    return arriWsRequest(opts, retryCount + 1);
+  }
+}
+class WsController {
+  constructor(opts) {
+    __publicField(this, "url");
+    __publicField(this, "_ws");
+    __publicField(this, "_serializer");
+    __publicField(this, "_parser");
+    __publicField(this, "onMessage");
+    __publicField(this, "onErrorMessage");
+    __publicField(this, "onConnectionError");
+    __publicField(this, "onOpen");
+    __publicField(this, "onClose");
+    this.url = opts.url;
+    this._serializer = opts.serializer;
+    this._parser = opts.parser;
+    this.onOpen = opts.onOpen;
+    this.onClose = opts.onClose;
+    this.onErrorMessage = opts.onErrorMessage;
+    this.onConnectionError = opts.onConnectionError;
+    this.onMessage = opts.onMessage;
+  }
+  connect() {
+    this._ws = connectWebsocket(this.url);
+    this._ws.onopen = () => {
+      this.onOpen?.();
+    };
+    this._ws.onclose = () => {
+      this.onClose?.();
+    };
+    this._ws.onmessage = (event) => {
+      this._handleMessage(event);
+    };
+    this._ws.onerror = (event) => {
+      this.onConnectionError?.(
+        new ArriErrorInstance({
+          code: "errno" in event.error && typeof event.error.errno === "number" ? event.error.errno : 0,
+          message: event.error instanceof Error ? event.error.message : `Error connecting to ${this.url}`,
+          data: event.error,
+          stack: event.error instanceof Error ? event.error.stack : void 0
+        })
+      );
+    };
+  }
+  readyState() {
+    return this._ws?.readyState ?? -1;
+  }
+  send(message) {
+    const payload = this._serializer(message);
+    this._ws?.send(payload);
+  }
+  close() {
+    this._ws?.close();
+  }
+  _handleMessage(msg) {
+    if (typeof msg.data !== "string") {
+      return;
+    }
+    const response = parsedWsResponse(msg.data);
+    switch (response.event) {
+      case "error": {
+        if (!this.onErrorMessage) {
+          return;
+        }
+        const err = ArriErrorInstance.fromJson(response.data);
+        this.onErrorMessage(err);
+        break;
+      }
+      case "message": {
+        if (!this.onMessage) {
+          return;
+        }
+        const msg2 = this._parser(response.data);
+        this.onMessage(msg2);
+        break;
+      }
+      default:
+        console.warn("Invalid response from server", msg);
+        break;
+    }
+  }
+}
+function parsedWsResponse(input) {
+  const lines = input.split("\n");
+  let event = "unknown";
+  let data = "";
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (trimmedLine.startsWith("event: ")) {
+      switch (trimmedLine.substring(6).trim()) {
+        case "error":
+          event = "error";
+          break;
+        case "message":
+          event = "message";
+          break;
+      }
+      continue;
+    }
+    if (trimmedLine.startsWith("data: ")) {
+      data = trimmedLine.substring(5).trim();
+      continue;
+    }
+  }
+  return {
+    event,
+    data
+  };
+}
+
+exports.ArriErrorInstance = ArriErrorInstance;
+exports.arriRequest = arriRequest;
+exports.arriSafeRequest = arriSafeRequest;
+exports.arriSseRequest = arriSseRequest;
+exports.arriWsRequest = arriWsRequest;
+exports.isArriError = isArriError;
+exports.parseSseEvent = parseSseEvent;
+exports.parseSseEvents = parseSseEvents;
+exports.parsedWsResponse = parsedWsResponse;

package/dist/index.d.cts

@@ -0,0 +1,129 @@
+import { HttpMethod, OnRequestContext, OnRequestErrorContext, OnResponseContext, OnResponseErrorContext, EventSourceController } from 'event-source-plus';
+
+interface ArriError {
+    code: number;
+    message: string;
+    data?: any;
+    stack?: string;
+    serverStack?: string;
+}
+declare function isArriError(input: unknown): input is ArriError;
+declare class ArriErrorInstance extends Error implements ArriError {
+    code: number;
+    data?: any;
+    serverStack?: string;
+    private readonly _internalMessage;
+    constructor(input: {
+        code: number;
+        message: string;
+        stack?: string;
+        data?: any;
+    });
+    toJSON(): {
+        code: number;
+        message: string;
+        stack: string[] | undefined;
+        data: any;
+    };
+    static fromJson(json: unknown): ArriErrorInstance;
+}
+
+interface ArriRequestOpts<TType, TParams extends Record<any, any> | undefined = undefined> {
+    url: string;
+    method: HttpMethod;
+    headers?: Record<string, string> | (() => Record<string, string>);
+    params?: TParams;
+    parser: (input: unknown) => TType;
+    serializer: (input: TParams) => TParams extends undefined ? undefined : string;
+    clientVersion?: string;
+}
+declare function arriRequest<TType, TParams extends Record<any, any> | undefined = undefined>(opts: ArriRequestOpts<TType, TParams>): Promise<TType>;
+declare function arriSafeRequest<TType, TParams extends Record<any, any> | undefined = undefined>(opts: ArriRequestOpts<TType, TParams>): Promise<SafeResponse<TType>>;
+type SafeResponse<T> = {
+    success: true;
+    value: T;
+} | {
+    success: false;
+    error: ArriErrorInstance;
+};
+
+interface SseEvent<TData = string> {
+    id?: string;
+    event?: string;
+    data: TData;
+}
+interface SseOptions<TData> {
+    onMessage?: (data: TData) => any;
+    onErrorMessage?: (error: ArriErrorInstance) => any;
+    onRequest?: (context: OnRequestContext) => any;
+    onRequestError?: (context: Omit<OnRequestErrorContext, "error"> & {
+        error: ArriErrorInstance;
+    }) => any;
+    onResponse?: (context: OnResponseContext) => any;
+    onResponseError?: (context: Omit<OnResponseErrorContext, "error"> & {
+        error: ArriErrorInstance;
+    }) => any;
+    onClose?: () => any;
+    maxRetryCount?: number;
+    maxRetryInterval?: number;
+}
+declare function arriSseRequest<TType, TParams extends Record<any, any> | undefined = undefined>(opts: ArriRequestOpts<TType, TParams>, options: SseOptions<TType>): EventSourceController;
+declare function parseSseEvent<TData = string>(input: string, dataParser: (input: string) => TData): SseEvent<TData> | undefined;
+declare function parseSseEvents<TData = string>(input: string, dataParser: (input: string) => TData): SseEvent<TData>[];
+
+interface WsControllerOptions<TParams, TResponse> {
+    url: string;
+    serializer: (input: TParams) => string;
+    parser: (input: unknown) => TResponse;
+    onMessage?: WsMessageHook<TResponse>;
+    onErrorMessage?: WsErrorHook;
+    onConnectionError?: WsErrorHook;
+    onOpen?: () => any;
+    onClose?: () => any;
+}
+interface WsOptions<TResponse> {
+    onMessage?: WsMessageHook<TResponse>;
+    onError?: WsErrorHook;
+    onConnectionError?: WsErrorHook;
+    onOpen?: () => any;
+    onClose?: () => any;
+}
+interface ArriWsRequestOptions<TParams = any, TResponse = any> {
+    url: string;
+    headers?: Record<string, string> | (() => Record<string, string>);
+    params?: TParams;
+    parser: (input: unknown) => TResponse;
+    serializer: (input: TParams) => string;
+    onMessage?: WsMessageHook<TResponse>;
+    onError?: WsErrorHook;
+    onConnectionError?: WsErrorHook;
+    onOpen?: () => any;
+    onClose?: () => any;
+    clientVersion?: string;
+}
+declare function arriWsRequest<TParams extends Record<any, any> | undefined = undefined, TResponse = any>(opts: ArriWsRequestOptions<TParams, TResponse>, retryCount?: number): WsController<TParams, TResponse>;
+type WsErrorHook = (err: ArriErrorInstance) => void;
+type WsMessageHook<TResponse> = (msg: TResponse) => any;
+declare class WsController<TParams, TResponse> {
+    url: string;
+    private _ws?;
+    private readonly _serializer;
+    private readonly _parser;
+    onMessage?: WsMessageHook<TResponse>;
+    onErrorMessage?: WsErrorHook;
+    onConnectionError?: WsErrorHook;
+    onOpen?: () => any;
+    onClose?: () => any;
+    constructor(opts: WsControllerOptions<TParams, TResponse>);
+    connect(): void;
+    readyState(): number;
+    send(message: TParams): void;
+    close(): void;
+    private _handleMessage;
+}
+declare function parsedWsResponse(input: string): {
+    event: "message" | "error" | "unknown";
+    data: string;
+};
+
+export { type ArriError, ArriErrorInstance, type ArriRequestOpts, type SafeResponse, type SseEvent, type SseOptions, type WsOptions, arriRequest, arriSafeRequest, arriSseRequest, arriWsRequest, isArriError, parseSseEvent, parseSseEvents, parsedWsResponse };

package/dist/index.d.mts

@@ -0,0 +1,129 @@
+import { HttpMethod, OnRequestContext, OnRequestErrorContext, OnResponseContext, OnResponseErrorContext, EventSourceController } from 'event-source-plus';
+
+interface ArriError {
+    code: number;
+    message: string;
+    data?: any;
+    stack?: string;
+    serverStack?: string;
+}
+declare function isArriError(input: unknown): input is ArriError;
+declare class ArriErrorInstance extends Error implements ArriError {
+    code: number;
+    data?: any;
+    serverStack?: string;
+    private readonly _internalMessage;
+    constructor(input: {
+        code: number;
+        message: string;
+        stack?: string;
+        data?: any;
+    });
+    toJSON(): {
+        code: number;
+        message: string;
+        stack: string[] | undefined;
+        data: any;
+    };
+    static fromJson(json: unknown): ArriErrorInstance;
+}
+
+interface ArriRequestOpts<TType, TParams extends Record<any, any> | undefined = undefined> {
+    url: string;
+    method: HttpMethod;
+    headers?: Record<string, string> | (() => Record<string, string>);
+    params?: TParams;
+    parser: (input: unknown) => TType;
+    serializer: (input: TParams) => TParams extends undefined ? undefined : string;
+    clientVersion?: string;
+}
+declare function arriRequest<TType, TParams extends Record<any, any> | undefined = undefined>(opts: ArriRequestOpts<TType, TParams>): Promise<TType>;
+declare function arriSafeRequest<TType, TParams extends Record<any, any> | undefined = undefined>(opts: ArriRequestOpts<TType, TParams>): Promise<SafeResponse<TType>>;
+type SafeResponse<T> = {
+    success: true;
+    value: T;
+} | {
+    success: false;
+    error: ArriErrorInstance;
+};
+
+interface SseEvent<TData = string> {
+    id?: string;
+    event?: string;
+    data: TData;
+}
+interface SseOptions<TData> {
+    onMessage?: (data: TData) => any;
+    onErrorMessage?: (error: ArriErrorInstance) => any;
+    onRequest?: (context: OnRequestContext) => any;
+    onRequestError?: (context: Omit<OnRequestErrorContext, "error"> & {
+        error: ArriErrorInstance;
+    }) => any;
+    onResponse?: (context: OnResponseContext) => any;
+    onResponseError?: (context: Omit<OnResponseErrorContext, "error"> & {
+        error: ArriErrorInstance;
+    }) => any;
+    onClose?: () => any;
+    maxRetryCount?: number;
+    maxRetryInterval?: number;
+}
+declare function arriSseRequest<TType, TParams extends Record<any, any> | undefined = undefined>(opts: ArriRequestOpts<TType, TParams>, options: SseOptions<TType>): EventSourceController;
+declare function parseSseEvent<TData = string>(input: string, dataParser: (input: string) => TData): SseEvent<TData> | undefined;
+declare function parseSseEvents<TData = string>(input: string, dataParser: (input: string) => TData): SseEvent<TData>[];
+
+interface WsControllerOptions<TParams, TResponse> {
+    url: string;
+    serializer: (input: TParams) => string;
+    parser: (input: unknown) => TResponse;
+    onMessage?: WsMessageHook<TResponse>;
+    onErrorMessage?: WsErrorHook;
+    onConnectionError?: WsErrorHook;
+    onOpen?: () => any;
+    onClose?: () => any;
+}
+interface WsOptions<TResponse> {
+    onMessage?: WsMessageHook<TResponse>;
+    onError?: WsErrorHook;
+    onConnectionError?: WsErrorHook;
+    onOpen?: () => any;
+    onClose?: () => any;
+}
+interface ArriWsRequestOptions<TParams = any, TResponse = any> {
+    url: string;
+    headers?: Record<string, string> | (() => Record<string, string>);
+    params?: TParams;
+    parser: (input: unknown) => TResponse;
+    serializer: (input: TParams) => string;
+    onMessage?: WsMessageHook<TResponse>;
+    onError?: WsErrorHook;
+    onConnectionError?: WsErrorHook;
+    onOpen?: () => any;
+    onClose?: () => any;
+    clientVersion?: string;
+}
+declare function arriWsRequest<TParams extends Record<any, any> | undefined = undefined, TResponse = any>(opts: ArriWsRequestOptions<TParams, TResponse>, retryCount?: number): WsController<TParams, TResponse>;
+type WsErrorHook = (err: ArriErrorInstance) => void;
+type WsMessageHook<TResponse> = (msg: TResponse) => any;
+declare class WsController<TParams, TResponse> {
+    url: string;
+    private _ws?;
+    private readonly _serializer;
+    private readonly _parser;
+    onMessage?: WsMessageHook<TResponse>;
+    onErrorMessage?: WsErrorHook;
+    onConnectionError?: WsErrorHook;
+    onOpen?: () => any;
+    onClose?: () => any;
+    constructor(opts: WsControllerOptions<TParams, TResponse>);
+    connect(): void;
+    readyState(): number;
+    send(message: TParams): void;
+    close(): void;
+    private _handleMessage;
+}
+declare function parsedWsResponse(input: string): {
+    event: "message" | "error" | "unknown";
+    data: string;
+};
+
+export { type ArriError, ArriErrorInstance, type ArriRequestOpts, type SafeResponse, type SseEvent, type SseOptions, type WsOptions, arriRequest, arriSafeRequest, arriSseRequest, arriWsRequest, isArriError, parseSseEvent, parseSseEvents, parsedWsResponse };

package/dist/index.d.ts

@@ -0,0 +1,129 @@
+import { HttpMethod, OnRequestContext, OnRequestErrorContext, OnResponseContext, OnResponseErrorContext, EventSourceController } from 'event-source-plus';
+
+interface ArriError {
+    code: number;
+    message: string;
+    data?: any;
+    stack?: string;
+    serverStack?: string;
+}
+declare function isArriError(input: unknown): input is ArriError;
+declare class ArriErrorInstance extends Error implements ArriError {
+    code: number;
+    data?: any;
+    serverStack?: string;
+    private readonly _internalMessage;
+    constructor(input: {
+        code: number;
+        message: string;
+        stack?: string;
+        data?: any;
+    });
+    toJSON(): {
+        code: number;
+        message: string;
+        stack: string[] | undefined;
+        data: any;
+    };
+    static fromJson(json: unknown): ArriErrorInstance;
+}
+
+interface ArriRequestOpts<TType, TParams extends Record<any, any> | undefined = undefined> {
+    url: string;
+    method: HttpMethod;
+    headers?: Record<string, string> | (() => Record<string, string>);
+    params?: TParams;
+    parser: (input: unknown) => TType;
+    serializer: (input: TParams) => TParams extends undefined ? undefined : string;
+    clientVersion?: string;
+}
+declare function arriRequest<TType, TParams extends Record<any, any> | undefined = undefined>(opts: ArriRequestOpts<TType, TParams>): Promise<TType>;
+declare function arriSafeRequest<TType, TParams extends Record<any, any> | undefined = undefined>(opts: ArriRequestOpts<TType, TParams>): Promise<SafeResponse<TType>>;
+type SafeResponse<T> = {
+    success: true;
+    value: T;
+} | {
+    success: false;
+    error: ArriErrorInstance;
+};
+
+interface SseEvent<TData = string> {
+    id?: string;
+    event?: string;
+    data: TData;
+}
+interface SseOptions<TData> {
+    onMessage?: (data: TData) => any;
+    onErrorMessage?: (error: ArriErrorInstance) => any;
+    onRequest?: (context: OnRequestContext) => any;
+    onRequestError?: (context: Omit<OnRequestErrorContext, "error"> & {
+        error: ArriErrorInstance;
+    }) => any;
+    onResponse?: (context: OnResponseContext) => any;
+    onResponseError?: (context: Omit<OnResponseErrorContext, "error"> & {
+        error: ArriErrorInstance;
+    }) => any;
+    onClose?: () => any;
+    maxRetryCount?: number;
+    maxRetryInterval?: number;
+}
+declare function arriSseRequest<TType, TParams extends Record<any, any> | undefined = undefined>(opts: ArriRequestOpts<TType, TParams>, options: SseOptions<TType>): EventSourceController;
+declare function parseSseEvent<TData = string>(input: string, dataParser: (input: string) => TData): SseEvent<TData> | undefined;
+declare function parseSseEvents<TData = string>(input: string, dataParser: (input: string) => TData): SseEvent<TData>[];
+
+interface WsControllerOptions<TParams, TResponse> {
+    url: string;
+    serializer: (input: TParams) => string;
+    parser: (input: unknown) => TResponse;
+    onMessage?: WsMessageHook<TResponse>;
+    onErrorMessage?: WsErrorHook;
+    onConnectionError?: WsErrorHook;
+    onOpen?: () => any;
+    onClose?: () => any;
+}
+interface WsOptions<TResponse> {
+    onMessage?: WsMessageHook<TResponse>;
+    onError?: WsErrorHook;
+    onConnectionError?: WsErrorHook;
+    onOpen?: () => any;
+    onClose?: () => any;
+}
+interface ArriWsRequestOptions<TParams = any, TResponse = any> {
+    url: string;
+    headers?: Record<string, string> | (() => Record<string, string>);
+    params?: TParams;
+    parser: (input: unknown) => TResponse;
+    serializer: (input: TParams) => string;
+    onMessage?: WsMessageHook<TResponse>;
+    onError?: WsErrorHook;
+    onConnectionError?: WsErrorHook;
+    onOpen?: () => any;
+    onClose?: () => any;
+    clientVersion?: string;
+}
+declare function arriWsRequest<TParams extends Record<any, any> | undefined = undefined, TResponse = any>(opts: ArriWsRequestOptions<TParams, TResponse>, retryCount?: number): WsController<TParams, TResponse>;
+type WsErrorHook = (err: ArriErrorInstance) => void;
+type WsMessageHook<TResponse> = (msg: TResponse) => any;
+declare class WsController<TParams, TResponse> {
+    url: string;
+    private _ws?;
+    private readonly _serializer;
+    private readonly _parser;
+    onMessage?: WsMessageHook<TResponse>;
+    onErrorMessage?: WsErrorHook;
+    onConnectionError?: WsErrorHook;
+    onOpen?: () => any;
+    onClose?: () => any;
+    constructor(opts: WsControllerOptions<TParams, TResponse>);
+    connect(): void;
+    readyState(): number;
+    send(message: TParams): void;
+    close(): void;
+    private _handleMessage;
+}
+declare function parsedWsResponse(input: string): {
+    event: "message" | "error" | "unknown";
+    data: string;
+};
+
+export { type ArriError, ArriErrorInstance, type ArriRequestOpts, type SafeResponse, type SseEvent, type SseOptions, type WsOptions, arriRequest, arriSafeRequest, arriSseRequest, arriWsRequest, isArriError, parseSseEvent, parseSseEvents, parsedWsResponse };

package/dist/index.mjs

@@ -0,0 +1,451 @@
+import { ofetch, FetchError } from 'ofetch';
+import { EventSourcePlus } from 'event-source-plus';
+import NodeWebsocket from 'ws';
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+function isArriError(input) {
+  if (typeof input !== "object" || input === null) {
+    return false;
+  }
+  if ("stack" in input && typeof input !== "string") {
+    return false;
+  }
+  if ("serverStack" in input && typeof input !== "string") {
+    return false;
+  }
+  return "code" in input && typeof input.code === "number" && "message" in input && typeof input.message === "string";
+}
+class ArriErrorInstance extends Error {
+  constructor(input) {
+    super(input.message);
+    __publicField$1(this, "code");
+    __publicField$1(this, "data");
+    __publicField$1(this, "serverStack");
+    __publicField$1(this, "_internalMessage");
+    this.code = input.code;
+    this.serverStack = input.stack;
+    this._internalMessage = input.message;
+    this.data = input.data;
+  }
+  toJSON() {
+    const stack = this.serverStack ?? this.stack;
+    return {
+      code: this.code,
+      message: this._internalMessage,
+      stack: stack?.split("\n").map((l) => l.trim()),
+      data: this.data
+    };
+  }
+  static fromJson(json) {
+    let parsedJson = json;
+    if (typeof parsedJson === "string") {
+      try {
+        parsedJson = JSON.parse(parsedJson);
+      } catch (_) {
+      }
+    }
+    if (typeof parsedJson !== "object" || parsedJson === null) {
+      return new ArriErrorInstance({
+        code: 500,
+        message: "Unknown error",
+        data: parsedJson
+      });
+    }
+    return new ArriErrorInstance({
+      code: "code" in parsedJson && typeof parsedJson.code === "number" ? parsedJson.code : 500,
+      message: "message" in parsedJson && typeof parsedJson.message === "string" ? parsedJson.message : "",
+      stack: "stack" in parsedJson && Array.isArray(parsedJson.stack) ? parsedJson.stack.join("\n") : void 0,
+      data: "data" in parsedJson ? parsedJson.data : void 0
+    });
+  }
+}
+
+async function arriRequest(opts) {
+  let url = opts.url;
+  let body;
+  let contentType;
+  switch (opts.method) {
+    case "get":
+    case "head":
+      if (opts.params && typeof opts.params === "object") {
+        const urlParts = [];
+        Object.keys(opts.params).forEach((key) => {
+          urlParts.push(`${key}=${opts.params[key]}`);
+        });
+        url = `${opts.url}?${urlParts.join("&")}`;
+      }
+      break;
+    default:
+      if (opts.params && typeof opts.params === "object") {
+        body = opts.serializer(opts.params);
+        contentType = "application/json";
+      }
+      break;
+  }
+  try {
+    let headers = {};
+    if (typeof opts.headers === "function") {
+      headers = opts.headers();
+    } else {
+      headers = opts.headers ?? {};
+    }
+    if (contentType)
+      headers["Content-Type"] = contentType;
+    if (opts.clientVersion)
+      headers["client-version"] = opts.clientVersion;
+    const result = await ofetch(url, {
+      method: opts.method,
+      body,
+      headers
+    });
+    return opts.parser(result);
+  } catch (err) {
+    const error = err;
+    if (isArriError(error.data)) {
+      throw new ArriErrorInstance(error.data);
+    } else {
+      throw new ArriErrorInstance({
+        code: error.statusCode ?? 500,
+        message: error.statusMessage ?? error.message ?? `Error connecting to ${url}`,
+        data: error.data,
+        stack: error.stack
+      });
+    }
+  }
+}
+async function arriSafeRequest(opts) {
+  try {
+    const result = await arriRequest(opts);
+    return {
+      success: true,
+      value: result
+    };
+  } catch (err) {
+    if (err instanceof ArriErrorInstance) {
+      return {
+        success: false,
+        error: err
+      };
+    }
+    if (err instanceof FetchError) {
+      return {
+        success: false,
+        error: new ArriErrorInstance({
+          code: err.statusCode ?? 0,
+          message: err.statusMessage ?? "",
+          stack: err.stack,
+          data: err.data
+        })
+      };
+    }
+    return {
+      success: false,
+      error: new ArriErrorInstance({
+        code: 500,
+        message: `Unknown error connecting to ${opts.url}`,
+        data: err
+      })
+    };
+  }
+}
+
+function arriSseRequest(opts, options) {
+  let url = opts.url;
+  let body;
+  switch (opts.method) {
+    case "get":
+    case "head":
+      if (opts.params && typeof opts.params === "object" && opts.params !== null) {
+        const urlParts = [];
+        Object.keys(opts.params).forEach((key) => {
+          urlParts.push(`${key}=${opts.params[key]}`);
+        });
+        url = `${opts.url}?${urlParts.join("&")}`;
+      }
+      break;
+    default:
+      if (opts.params && typeof opts.params === "object") {
+        body = opts.serializer(opts.params);
+      }
+      break;
+  }
+  const eventSource = new EventSourcePlus(url, {
+    method: opts.method ?? "get",
+    headers: () => {
+      let headers;
+      if (typeof opts.headers === "function") {
+        headers = opts.headers();
+      } else {
+        headers = opts.headers ?? {};
+      }
+      if (opts.clientVersion) {
+        headers["client-version"] = opts.clientVersion;
+      }
+      return headers;
+    },
+    body,
+    maxRetryCount: options.maxRetryCount,
+    maxRetryInterval: options.maxRetryInterval
+  });
+  const controller = eventSource.listen({
+    onMessage(message) {
+      if (message.event === "message" || message.event === void 0 || message.event === "") {
+        options.onMessage?.(opts.parser(message.data));
+        return;
+      }
+      if (message.event === "error") {
+        options.onErrorMessage?.(
+          ArriErrorInstance.fromJson(message.data)
+        );
+        return;
+      }
+      if (message.event === "done") {
+        controller.abort();
+      }
+    },
+    onRequest(context) {
+      options.onRequest?.(context);
+    },
+    onRequestError(context) {
+      options.onRequestError?.({
+        ...context,
+        error: new ArriErrorInstance({
+          code: 0,
+          message: context.error.message,
+          data: context.error
+        })
+      });
+    },
+    onResponse(context) {
+      options.onResponse?.(context);
+    },
+    async onResponseError(context) {
+      if (!options.onResponseError) {
+        return;
+      }
+      try {
+        const arriError = ArriErrorInstance.fromJson(
+          await context.response.json()
+        );
+        options.onResponseError({
+          ...context,
+          error: arriError
+        });
+      } catch (_) {
+        const arriError = new ArriErrorInstance({
+          code: context.response.status ?? 0,
+          message: context.response.statusText
+        });
+        options.onResponseError({ ...context, error: arriError });
+      }
+    }
+  });
+  return controller;
+}
+function parseSseEvent(input, dataParser) {
+  let id;
+  let event;
+  let data;
+  const lines = input.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("id:")) {
+      id = line.substring(3).trim();
+      continue;
+    }
+    if (line.startsWith("event:")) {
+      event = line.substring(6).trim();
+      continue;
+    }
+    if (line.startsWith("data:")) {
+      data = dataParser(line.substring(5).trim());
+    }
+  }
+  if (!data) {
+    return void 0;
+  }
+  return {
+    id,
+    event,
+    data
+  };
+}
+function parseSseEvents(input, dataParser) {
+  const eventStrings = input.split("\n\n");
+  const events = [];
+  for (const str of eventStrings) {
+    const event = parseSseEvent(str, dataParser);
+    if (event) {
+      events.push(event);
+    }
+  }
+  return events;
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+function connectWebsocket(url, protocol) {
+  if (isBrowser()) {
+    return new WebSocket(url, protocol);
+  }
+  return new NodeWebsocket(url, {
+    protocol
+  });
+}
+function arriWsRequest(opts, retryCount = 0) {
+  let url = opts.url.replace("http://", "ws://").replace("https://", "wss://");
+  let headers;
+  if (typeof opts.headers === "function") {
+    headers = opts.headers();
+  } else {
+    headers = opts.headers;
+  }
+  if (headers) {
+    if (opts.clientVersion)
+      headers["client-version"] = opts.clientVersion;
+    const queryParts = [];
+    for (const key of Object.keys(headers)) {
+      queryParts.push(`${key}=${headers[key]}`);
+    }
+    url += `?${queryParts.join("&")}`;
+  }
+  try {
+    const controller = new WsController({
+      url,
+      parser: opts.parser,
+      serializer: opts.serializer ?? ((_) => ""),
+      onOpen: opts.onOpen,
+      onClose: opts.onClose,
+      onMessage: opts.onMessage,
+      onErrorMessage: opts.onError,
+      onConnectionError: opts.onConnectionError
+    });
+    return controller;
+  } catch (err) {
+    console.error(err);
+    if (opts.onConnectionError) {
+      opts.onConnectionError(err);
+    }
+    return arriWsRequest(opts, retryCount + 1);
+  }
+}
+class WsController {
+  constructor(opts) {
+    __publicField(this, "url");
+    __publicField(this, "_ws");
+    __publicField(this, "_serializer");
+    __publicField(this, "_parser");
+    __publicField(this, "onMessage");
+    __publicField(this, "onErrorMessage");
+    __publicField(this, "onConnectionError");
+    __publicField(this, "onOpen");
+    __publicField(this, "onClose");
+    this.url = opts.url;
+    this._serializer = opts.serializer;
+    this._parser = opts.parser;
+    this.onOpen = opts.onOpen;
+    this.onClose = opts.onClose;
+    this.onErrorMessage = opts.onErrorMessage;
+    this.onConnectionError = opts.onConnectionError;
+    this.onMessage = opts.onMessage;
+  }
+  connect() {
+    this._ws = connectWebsocket(this.url);
+    this._ws.onopen = () => {
+      this.onOpen?.();
+    };
+    this._ws.onclose = () => {
+      this.onClose?.();
+    };
+    this._ws.onmessage = (event) => {
+      this._handleMessage(event);
+    };
+    this._ws.onerror = (event) => {
+      this.onConnectionError?.(
+        new ArriErrorInstance({
+          code: "errno" in event.error && typeof event.error.errno === "number" ? event.error.errno : 0,
+          message: event.error instanceof Error ? event.error.message : `Error connecting to ${this.url}`,
+          data: event.error,
+          stack: event.error instanceof Error ? event.error.stack : void 0
+        })
+      );
+    };
+  }
+  readyState() {
+    return this._ws?.readyState ?? -1;
+  }
+  send(message) {
+    const payload = this._serializer(message);
+    this._ws?.send(payload);
+  }
+  close() {
+    this._ws?.close();
+  }
+  _handleMessage(msg) {
+    if (typeof msg.data !== "string") {
+      return;
+    }
+    const response = parsedWsResponse(msg.data);
+    switch (response.event) {
+      case "error": {
+        if (!this.onErrorMessage) {
+          return;
+        }
+        const err = ArriErrorInstance.fromJson(response.data);
+        this.onErrorMessage(err);
+        break;
+      }
+      case "message": {
+        if (!this.onMessage) {
+          return;
+        }
+        const msg2 = this._parser(response.data);
+        this.onMessage(msg2);
+        break;
+      }
+      default:
+        console.warn("Invalid response from server", msg);
+        break;
+    }
+  }
+}
+function parsedWsResponse(input) {
+  const lines = input.split("\n");
+  let event = "unknown";
+  let data = "";
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (trimmedLine.startsWith("event: ")) {
+      switch (trimmedLine.substring(6).trim()) {
+        case "error":
+          event = "error";
+          break;
+        case "message":
+          event = "message";
+          break;
+      }
+      continue;
+    }
+    if (trimmedLine.startsWith("data: ")) {
+      data = trimmedLine.substring(5).trim();
+      continue;
+    }
+  }
+  return {
+    event,
+    data
+  };
+}
+
+export { ArriErrorInstance, arriRequest, arriSafeRequest, arriSseRequest, arriWsRequest, isArriError, parseSseEvent, parseSseEvents, parsedWsResponse };

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@arrirpc/client",
+  "version": "0.45.0",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "joshmossas",
+    "url": "https://github.com/joshmossas"
+  },
+  "bugs": {
+    "url": "https://github.com/modiimedia/arri/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/modiimedia/arri.git",
+    "directory": "languages/ts/ts-client"
+  },
+  "dependencies": {
+    "event-source-plus": "^0.0.6",
+    "ofetch": "^1.3.4",
+    "ws": "^8.17.0",
+    "@arrirpc/schema": "0.45.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.10"
+  }
+}