@orpc/client 0.0.0-next.911bdd9 → 0.0.0-next.9125edb

package/dist/fetch.js

@@ -1,10 +1,11 @@
 // src/adapters/fetch/orpc-link.ts
-import { ORPCPayloadCodec } from "@orpc/server/fetch";
-import { ORPC_HANDLER_HEADER, ORPC_HANDLER_VALUE, trim } from "@orpc/shared";
-import { ORPCError } from "@orpc/shared/error";
-var ORPCLink = class {
+import { ORPCError } from "@orpc/contract";
+import { toFetchBody, toStandardBody } from "@orpc/server-standard-fetch";
+import { RPCSerializer } from "@orpc/server/standard";
+import { isObject, trim } from "@orpc/shared";
+var RPCLink = class {
   fetch;
-  payloadCodec;
+  rpcSerializer;
   maxURLLength;
   fallbackMethod;
   getMethod;
@@ -12,7 +13,7 @@ var ORPCLink = class {
   url;
   constructor(options) {
     this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
-    this.payloadCodec = options.payloadCodec ?? new ORPCPayloadCodec();
+    this.rpcSerializer = options.rpcSerializer ?? new RPCSerializer();
     this.maxURLLength = options.maxURLLength ?? 2083;
     this.fallbackMethod = options.fallbackMethod ?? "POST";
     this.url = options.url;
@@ -24,64 +25,73 @@ var ORPCLink = class {
     };
   }
   async call(path, input, options) {
-    const clientContext = options.context;
+    const clientContext = options.context ?? {};
     const encoded = await this.encode(path, input, options);
+    const fetchBody = toFetchBody(encoded.body, encoded.headers);
     const response = await this.fetch(encoded.url, {
       method: encoded.method,
       headers: encoded.headers,
-      body: encoded.body,
+      body: fetchBody,
       signal: options.signal
     }, clientContext);
-    const decoded = await this.payloadCodec.decode(response);
-    if (!response.ok) {
-      const error = ORPCError.fromJSON(decoded) ?? new ORPCError({
-        status: response.status,
-        code: "INTERNAL_SERVER_ERROR",
-        message: "Internal server error",
-        cause: decoded
-      });
-      throw error;
+    const body = await toStandardBody(response);
+    const deserialized = (() => {
+      try {
+        return this.rpcSerializer.deserialize(body);
+      } catch (error) {
+        if (response.ok) {
+          throw new ORPCError("INTERNAL_SERVER_ERROR", {
+            message: "Invalid RPC response",
+            cause: error
+          });
+        }
+        throw new ORPCError(response.status.toString(), {
+          message: response.statusText
+        });
+      }
+    })();
+    if (response.ok) {
+      return deserialized;
     }
-    return decoded;
+    throw ORPCError.fromJSON(deserialized);
   }
   async encode(path, input, options) {
     const clientContext = options.context;
     const expectMethod = await this.getMethod(path, input, clientContext);
-    const methods = /* @__PURE__ */ new Set([expectMethod, this.fallbackMethod]);
-    const baseHeaders = await this.getHeaders(path, input, clientContext);
-    const baseUrl = new URL(`${trim(this.url, "/")}/${path.map(encodeURIComponent).join("/")}`);
-    baseHeaders.append(ORPC_HANDLER_HEADER, ORPC_HANDLER_VALUE);
-    for (const method of methods) {
-      const url = new URL(baseUrl);
-      const headers = new Headers(baseHeaders);
-      const encoded = this.payloadCodec.encode(input, method, this.fallbackMethod);
-      if (encoded.query) {
-        for (const [key, value] of encoded.query.entries()) {
-          url.searchParams.append(key, value);
-        }
-      }
-      if (url.toString().length > this.maxURLLength) {
-        continue;
-      }
-      if (encoded.headers) {
-        for (const [key, value] of encoded.headers.entries()) {
-          headers.append(key, value);
-        }
+    const headers = await this.getHeaders(path, input, clientContext);
+    const url = new URL(`${trim(this.url, "/")}/${path.map(encodeURIComponent).join("/")}`);
+    headers.append("x-orpc-handler", "rpc");
+    const serialized = this.rpcSerializer.serialize(input);
+    if (expectMethod === "GET" && isObject(serialized)) {
+      const tryURL = new URL(url);
+      tryURL.searchParams.append("data", JSON.stringify(serialized));
+      if (tryURL.toString().length <= this.maxURLLength) {
+        return {
+          body: void 0,
+          method: expectMethod,
+          headers,
+          url: tryURL
+        };
       }
+    }
+    const method = expectMethod === "GET" ? this.fallbackMethod : expectMethod;
+    if (input === void 0) {
       return {
-        url,
+        body: void 0,
+        method,
         headers,
-        method: encoded.method,
-        body: encoded.body
+        url
       };
     }
-    throw new ORPCError({
-      code: "BAD_REQUEST",
-      message: "Cannot encode the request, please check the url length or payload."
-    });
+    return {
+      body: serialized,
+      method,
+      headers,
+      url
+    };
   }
 };
 export {
-  ORPCLink
+  RPCLink
 };
 //# sourceMappingURL=fetch.js.map

package/dist/index.js

@@ -24,16 +24,20 @@ var DynamicLink = class {
     this.linkResolver = linkResolver;
   }
   async call(path, input, options) {
-    const resolvedLink = await this.linkResolver(path, input, options.context);
-    const output = await resolvedLink.call(path, input, options);
+    const clientContext = options.context ?? {};
+    const resolvedLink = await this.linkResolver(path, input, clientContext);
+    const output = await resolvedLink.call(path, input, { ...options, context: clientContext });
     return output;
   }
 };
 
 // src/index.ts
-export * from "@orpc/shared/error";
+import { isDefinedError, ORPCError, safe } from "@orpc/contract";
 export {
   DynamicLink,
-  createORPCClient
+  ORPCError,
+  createORPCClient,
+  isDefinedError,
+  safe
 };
 //# sourceMappingURL=index.js.map

package/dist/src/adapters/fetch/orpc-link.d.ts

@@ -1,10 +1,9 @@
-import type { HTTPMethod } from '@orpc/contract';
-import type { ProcedureClientOptions } from '@orpc/server';
+import type { ClientContext, ClientOptions, HTTPMethod } from '@orpc/contract';
 import type { Promisable } from '@orpc/shared';
 import type { ClientLink } from '../../types';
 import type { FetchWithContext } from './types';
-import { type PublicORPCPayloadCodec } from '@orpc/server/fetch';
-export interface ORPCLinkOptions<TClientContext> {
+import { RPCSerializer } from '@orpc/server/standard';
+export interface RPCLinkOptions<TClientContext extends ClientContext> {
     /**
      * Base url for all requests.
      */
@@ -20,28 +19,28 @@ export interface ORPCLinkOptions<TClientContext> {
      *
      * @default 'POST'
      */
-    method?: (path: readonly string[], input: unknown, context: TClientContext) => Promisable<HTTPMethod | undefined>;
+    method?(path: readonly string[], input: unknown, context: TClientContext): Promisable<HTTPMethod | undefined>;
     /**
      * The method to use when the payload cannot safely pass to the server with method return from method function.
-     * Do not use GET as fallback method, it's very dangerous.
+     * GET is not allowed, it's very dangerous.
      *
      * @default 'POST'
      */
-    fallbackMethod?: HTTPMethod;
-    headers?: (path: readonly string[], input: unknown, context: TClientContext) => Promisable<Headers | Record<string, string>>;
+    fallbackMethod?: Exclude<HTTPMethod, 'GET'>;
+    headers?(path: readonly string[], input: unknown, context: TClientContext): Promisable<Headers | Record<string, string>>;
     fetch?: FetchWithContext<TClientContext>;
-    payloadCodec?: PublicORPCPayloadCodec;
+    rpcSerializer?: RPCSerializer;
 }
-export declare class ORPCLink<TClientContext> implements ClientLink<TClientContext> {
+export declare class RPCLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
     private readonly fetch;
-    private readonly payloadCodec;
+    private readonly rpcSerializer;
     private readonly maxURLLength;
     private readonly fallbackMethod;
     private readonly getMethod;
     private readonly getHeaders;
     private readonly url;
-    constructor(options: ORPCLinkOptions<TClientContext>);
-    call(path: readonly string[], input: unknown, options: ProcedureClientOptions<TClientContext>): Promise<unknown>;
+    constructor(options: RPCLinkOptions<TClientContext>);
+    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
     private encode;
 }
 //# sourceMappingURL=orpc-link.d.ts.map

package/dist/src/adapters/fetch/types.d.ts

@@ -1,4 +1,5 @@
-export interface FetchWithContext<TClientContext> {
-    (input: RequestInfo | URL, init: RequestInit | undefined, context: TClientContext): Promise<Response>;
+import type { ClientContext } from '@orpc/contract';
+export interface FetchWithContext<TClientContext extends ClientContext> {
+    (url: Request | string | URL, init: RequestInit | undefined, context: TClientContext): Promise<Response>;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/src/client.d.ts

@@ -1,5 +1,5 @@
-import type { ContractRouter } from '@orpc/contract';
-import type { ANY_ROUTER, RouterClient } from '@orpc/server';
+import type { AnyContractRouter, ClientContext, ContractRouterClient } from '@orpc/contract';
+import type { AnyRouter, RouterClient } from '@orpc/server';
 import type { ClientLink } from './types';
 export interface createORPCClientOptions {
     /**
@@ -7,5 +7,5 @@ export interface createORPCClientOptions {
      */
     path?: string[];
 }
-export declare function createORPCClient<TRouter extends ANY_ROUTER | ContractRouter, TClientContext = unknown>(link: ClientLink<TClientContext>, options?: createORPCClientOptions): RouterClient<TRouter, TClientContext>;
+export declare function createORPCClient<TRouter extends AnyRouter | AnyContractRouter, TClientContext extends ClientContext = Record<never, never>>(link: ClientLink<TClientContext>, options?: createORPCClientOptions): TRouter extends AnyRouter ? RouterClient<TRouter, TClientContext> : TRouter extends AnyContractRouter ? ContractRouterClient<TRouter, TClientContext> : never;
 //# sourceMappingURL=client.d.ts.map

package/dist/src/dynamic-link.d.ts

@@ -1,13 +1,13 @@
-import type { ProcedureClientOptions } from '@orpc/server';
+import type { ClientContext, ClientOptions } from '@orpc/contract';
 import type { Promisable } from '@orpc/shared';
 import type { ClientLink } from './types';
 /**
  * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
  * based on the request path, input, and context.
  */
-export declare class DynamicLink<TClientContext> implements ClientLink<TClientContext> {
+export declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
     private readonly linkResolver;
     constructor(linkResolver: (path: readonly string[], input: unknown, context: TClientContext) => Promisable<ClientLink<TClientContext>>);
-    call(path: readonly string[], input: unknown, options: ProcedureClientOptions<TClientContext>): Promise<unknown>;
+    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
 }
 //# sourceMappingURL=dynamic-link.d.ts.map

package/dist/src/index.d.ts

@@ -2,5 +2,5 @@
 export * from './client';
 export * from './dynamic-link';
 export * from './types';
-export * from '@orpc/shared/error';
+export { isDefinedError, ORPCError, safe } from '@orpc/contract';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/types.d.ts

@@ -1,5 +1,5 @@
-import type { ProcedureClientOptions } from '@orpc/server';
-export interface ClientLink<TClientContext> {
-    call: (path: readonly string[], input: unknown, options: ProcedureClientOptions<TClientContext>) => Promise<unknown>;
+import type { ClientContext, ClientOptions } from '@orpc/contract';
+export interface ClientLink<TClientContext extends ClientContext> {
+    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
 }
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.0.0-next.911bdd9",
+  "version": "0.0.0-next.9125edb",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -33,16 +33,16 @@
     "!**/*.tsbuildinfo",
     "dist"
   ],
-  "peerDependencies": {
-    "@orpc/contract": "0.0.0-next.911bdd9"
-  },
   "dependencies": {
-    "@orpc/shared": "0.0.0-next.911bdd9",
-    "@orpc/server": "0.0.0-next.911bdd9"
+    "@orpc/server-standard": "^0.0.0",
+    "@orpc/server-standard-fetch": "^0.0.0",
+    "@orpc/contract": "0.0.0-next.9125edb",
+    "@orpc/server": "0.0.0-next.9125edb",
+    "@orpc/shared": "0.0.0-next.9125edb"
   },
   "devDependencies": {
     "zod": "^3.24.1",
-    "@orpc/openapi": "0.0.0-next.911bdd9"
+    "@orpc/openapi": "0.0.0-next.9125edb"
   },
   "scripts": {
     "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/adapters/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",