@seam-rpc/client 4.3.21 → 5.0.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { RpcError, type Result } from "@seam-rpc/core";
-export { RpcError };
+import { ApiError, type Result } from "@seam-rpc/core";
+export { ApiError as RpcError };
 export type { Result };
 export type SeamRequestMiddleware = (context: SeamRequestMiddlewareContext) => void | Promise<void>;
 export type SeamResponseMiddleware = (context: SeamResponseMiddlewareContext) => void | Promise<void>;
@@ -19,23 +19,24 @@ export interface SeamClientOptions {
         response?: SeamResponseMiddleware[];
     };
 }
-export declare class SeamClient {
+export declare class SeamClient<ApiType> {
     readonly baseUrl: string;
-    static _instance: SeamClient;
     options: SeamClientOptions;
+    readonly api: ApiType;
     constructor(baseUrl: string, options?: SeamClientOptions);
     preRequest(middleware: SeamRequestMiddleware): void;
     postRequest(middleware: SeamResponseMiddleware): void;
 }
-export declare class SeamError extends RpcError {
+export declare class SeamError extends ApiError {
     constructor(code: string);
 }
-type SeamClientErrorType = "REQUEST_FAILED" | "TIMEOUT" | "PARSE_ERROR" | "INVALID_RESPONSE";
+type SeamClientErrorType = "REQUEST_FAILED" | "INVALID_CONTENT_TYPE";
 export declare class SeamClientError extends Error {
     readonly type: SeamClientErrorType;
+    readonly url: string;
     readonly request: RequestInit;
     readonly cause: unknown;
-    constructor(type: SeamClientErrorType, message: string, request: RequestInit, cause: unknown);
+    constructor(type: SeamClientErrorType, message: string, url: string, request: RequestInit, cause: unknown);
 }
-export declare function createSeamClient(baseUrl: string, options?: SeamClientOptions): SeamClient;
-export declare function callApi(routerName: string, funcName: string, input?: Record<string, any>): Promise<any>;
+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>;

package/dist/index.js

@@ -1,15 +1,26 @@
-import { extractFiles, injectFiles, RpcError } from "@seam-rpc/core";
-export { RpcError };
+import { extractFiles, injectFiles, ApiError } from "@seam-rpc/core";
+export { ApiError as RpcError };
 export class SeamClient {
     constructor(baseUrl, options) {
         this.baseUrl = baseUrl;
-        SeamClient._instance = this;
         this.options = {
             middleware: {
                 request: options?.middleware?.request || [],
                 response: options?.middleware?.response || [],
             }
         };
+        const client = this;
+        this.api = new Proxy({}, {
+            get(_target, routerName) {
+                return new Proxy({}, {
+                    get(_subTarget, procName) {
+                        return async (input) => {
+                            return callApi(client, String(routerName), String(procName), input);
+                        };
+                    },
+                });
+            },
+        });
     }
     preRequest(middleware) {
         this.options?.middleware?.request?.push(middleware);
@@ -18,15 +29,16 @@ export class SeamClient {
         this.options?.middleware?.response?.push(middleware);
     }
 }
-export class SeamError extends RpcError {
+export class SeamError extends ApiError {
     constructor(code) {
         super(code, undefined);
     }
 }
 export class SeamClientError extends Error {
-    constructor(type, message, request, cause) {
+    constructor(type, message, url, request, cause) {
         super(message);
         this.type = type;
+        this.url = url;
         this.request = request;
         this.cause = cause;
         this.name = "SeamClientError";
@@ -35,10 +47,7 @@ export class SeamClientError extends Error {
 export function createSeamClient(baseUrl, options) {
     return new SeamClient(baseUrl, options);
 }
-export async function callApi(routerName, funcName, input) {
-    if (!SeamClient._instance)
-        throw new Error("Seam Client not instantiated.");
-    const seamClient = SeamClient._instance;
+export async function callApi(seamClient, routerName, funcName, input) {
     const req = buildRequest(input);
     const url = `${seamClient.baseUrl}/${routerName}/${funcName}`;
     if (seamClient.options?.middleware?.request) {
@@ -56,30 +65,27 @@ export async function callApi(routerName, funcName, input) {
         res = await fetch(url, req);
     }
     catch (err) {
-        throw new SeamClientError("REQUEST_FAILED", "Failed to send request.", req, err);
+        throw new SeamClientError("REQUEST_FAILED", "Failed to send request.", url, req, err);
     }
     if (!res.ok) {
         if (res.status == 400) {
             const resError = await res.json();
-            if (resError.rpcError) {
+            if (resError.isApiError) {
                 return {
                     ok: false,
-                    error: RpcError.fromJSON(resError.error),
+                    error: ApiError.fromJSON(resError.error),
                 };
             }
-            else {
-                return { ok: false, error: null };
-            }
+            throw new SeamClientError("REQUEST_FAILED", `Request failed with status ${res.status} ${res.statusText} and non-api error.`, url, req, null);
         }
-        // throw new Error(`Request failed at router ${routerName} at function ${funcName}, with status ${res.status} ${res.statusText}.`);
-        return { ok: false, error: null };
+        throw new SeamClientError("REQUEST_FAILED", `Request failed with status ${res.status} ${res.statusText}.`, url, req, null);
     }
     const contentType = res.headers.get("content-type") || "";
     if (contentType.startsWith("application/json")) {
         const data = await res.json();
         return data.result;
     }
-    else if (contentType.startsWith("multipart/form-data")) {
+    if (contentType.startsWith("multipart/form-data")) {
         const formData = await res.formData();
         const jsonPart = JSON.parse(formData.get("json")?.toString() || "[]");
         const pathsPart = JSON.parse(formData.get("paths")?.toString() || "[]");
@@ -109,9 +115,7 @@ export async function callApi(routerName, funcName, input) {
         }
         return jsonPart.result;
     }
-    else {
-        return { ok: false, error: null };
-    }
+    throw new SeamClientError("INVALID_CONTENT_TYPE", `Response has invalid content type ${contentType}.`, url, req, null);
 }
 function buildRequest(input = {}) {
     let req;

package/package.json

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