@seam-rpc/client 5.4.0 → 5.6.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { ApiError, type Result } from "@seam-rpc/core";
+import { ApiError, type Result, Ok, Err } from "@seam-rpc/core";
 export { ApiError };
-export type { Result };
+export type { Result, Ok, Err };
 export type SeamRequestMiddleware = (context: SeamRequestMiddlewareContext) => void | Promise<void>;
 export type SeamResponseMiddleware = (context: SeamResponseMiddlewareContext) => void | Promise<void>;
 export type SeamOnErrorHandler = (error: SeamClientError) => void | Promise<void>;
@@ -14,29 +14,36 @@ export type SeamResponseMiddlewareContext = SeamRequestMiddlewareContext & {
     response: Response;
     parsedResponse: any;
 };
-export interface SeamClientOptions {
+export interface SeamClientOptionsConstructor {
     middleware?: {
         request?: SeamRequestMiddleware[];
         response?: SeamResponseMiddleware[];
     };
     onError?: SeamOnErrorHandler[];
 }
+export interface SeamClientOptions {
+    middleware: {
+        request: SeamRequestMiddleware[];
+        response: SeamResponseMiddleware[];
+    };
+    onError: SeamOnErrorHandler[];
+}
 export declare class SeamClient<ApiType> {
     readonly baseUrl: string;
     options: SeamClientOptions;
     readonly api: ApiType;
-    constructor(baseUrl: string, options?: SeamClientOptions);
+    constructor(baseUrl: string, options?: SeamClientOptionsConstructor);
     preRequest(middleware: SeamRequestMiddleware): void;
     postRequest(middleware: SeamResponseMiddleware): void;
     onError(handler: SeamOnErrorHandler): void;
 }
-type SeamClientErrorType = "REQUEST_FAILED" | "INVALID_CONTENT_TYPE";
+type SeamClientErrorType = "REQUEST_FAILED" | "INVALID_CONTENT_TYPE" | "UNEXPECTED";
 export declare class SeamClientError extends Error {
     readonly type: SeamClientErrorType;
     readonly url: string;
-    readonly request: RequestInit;
+    readonly request: RequestInit | null;
     readonly cause: unknown;
-    constructor(type: SeamClientErrorType, message: string, url: string, request: RequestInit, cause: unknown);
+    constructor(type: SeamClientErrorType, message: string, url: string, request: RequestInit | null, cause: unknown);
 }
 export declare function createSeamClient<ApiType>(baseUrl: string, options?: SeamClientOptions): SeamClient<ApiType>;
-export declare function callApi(seamClient: SeamClient<any>, routerName: string, funcName: string, input?: Record<string, any>): Promise<any>;
+export declare function callApi(seamClient: SeamClient<any>, url: string, routerName: string, funcName: string, input?: Record<string, any>): Promise<any>;

package/dist/index.js

@@ -16,14 +16,18 @@ export class SeamClient {
                 return new Proxy({}, {
                     get(_subTarget, procName) {
                         return async (input) => {
+                            const url = `${client.baseUrl}/${String(routerName)}/${String(procName)}`;
                             try {
-                                return await callApi(client, String(routerName), String(procName), input);
+                                return await callApi(client, url, String(routerName), String(procName), input);
                             }
                             catch (err) {
-                                if (!client.options.onError || !(err instanceof SeamClientError))
-                                    throw err;
+                                const error = err instanceof SeamClientError
+                                    ? err
+                                    : new SeamClientError("UNEXPECTED", "Unexpected error when calling API procedure.", url, null, err);
+                                if (client.options.onError.length == 0)
+                                    throw error;
                                 for (const handler of client.options?.onError) {
-                                    handler(err);
+                                    handler(error);
                                 }
                                 return { ok: false, error: new ApiError("") };
                             }
@@ -56,9 +60,8 @@ export class SeamClientError extends Error {
 export function createSeamClient(baseUrl, options) {
     return new SeamClient(baseUrl, options);
 }
-export async function callApi(seamClient, routerName, funcName, input) {
+export async function callApi(seamClient, url, routerName, funcName, input) {
     const req = buildRequest(input);
-    const url = `${seamClient.baseUrl}/${routerName}/${funcName}`;
     if (seamClient.options?.middleware?.request) {
         for (const mw of seamClient.options.middleware.request) {
             await mw({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seam-rpc/client",
-  "version": "5.4.0",
+  "version": "5.6.0",
   "main": "./dist/index.js",
   "type": "module",
   "files": [