@orpc/client 0.0.0-next.c29cb6d → 0.0.0-next.c6c659d

package/dist/fetch.js

@@ -1,46 +1,89 @@
 // src/adapters/fetch/orpc-link.ts
+import { ORPCError } from "@orpc/contract";
 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 {
+var RPCLink = class {
+  fetch;
+  payloadCodec;
+  maxURLLength;
+  fallbackMethod;
+  getMethod;
+  getHeaders;
+  url;
   constructor(options) {
-    this.options = options;
     this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
     this.payloadCodec = options.payloadCodec ?? new ORPCPayloadCodec();
+    this.maxURLLength = options.maxURLLength ?? 2083;
+    this.fallbackMethod = options.fallbackMethod ?? "POST";
+    this.url = options.url;
+    this.getMethod = async (path, input, context) => {
+      return await options.method?.(path, input, context) ?? this.fallbackMethod;
+    };
+    this.getHeaders = async (path, input, context) => {
+      return new Headers(await options.headers?.(path, input, context));
+    };
   }
-  fetch;
-  payloadCodec;
   async call(path, input, options) {
-    const url = `${trim(this.options.url, "/")}/${path.map(encodeURIComponent).join("/")}`;
-    const encoded = this.payloadCodec.encode(input);
-    const headers = new Headers(encoded.headers);
-    headers.append(ORPC_HANDLER_HEADER, ORPC_HANDLER_VALUE);
     const clientContext = options.context;
-    let customHeaders = await this.options.headers?.(input, clientContext);
-    customHeaders = customHeaders instanceof Headers ? customHeaders : new Headers(customHeaders);
-    for (const [key, value] of customHeaders.entries()) {
-      headers.append(key, value);
-    }
-    const response = await this.fetch(url, {
-      method: "POST",
-      headers,
+    const encoded = await this.encode(path, input, options);
+    const response = await this.fetch(encoded.url, {
+      method: encoded.method,
+      headers: encoded.headers,
       body: encoded.body,
       signal: options.signal
     }, clientContext);
     const decoded = await this.payloadCodec.decode(response);
     if (!response.ok) {
-      const error = ORPCError.fromJSON(decoded) ?? new ORPCError({
+      if (ORPCError.isValidJSON(decoded)) {
+        throw new ORPCError(decoded);
+      }
+      throw new ORPCError({
         status: response.status,
         code: "INTERNAL_SERVER_ERROR",
         message: "Internal server error",
         cause: decoded
       });
-      throw error;
     }
     return decoded;
   }
+  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);
+        }
+      }
+      return {
+        url,
+        headers,
+        method: encoded.method,
+        body: encoded.body
+      };
+    }
+    throw new ORPCError({
+      code: "BAD_REQUEST",
+      message: "Cannot encode the request, please check the url length or payload."
+    });
+  }
 };
 export {
-  ORPCLink
+  RPCLink
 };
 //# sourceMappingURL=fetch.js.map

package/dist/index.js

@@ -24,16 +24,19 @@ var DynamicLink = class {
     this.linkResolver = linkResolver;
   }
   async call(path, input, options) {
-    const resolvedLink = await this.linkResolver(path, input, options);
+    const resolvedLink = await this.linkResolver(path, input, options.context);
     const output = await resolvedLink.call(path, input, options);
     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,19 +1,46 @@
-import type { ProcedureClientOptions } from '@orpc/server';
+import type { 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> {
+export interface RPCLinkOptions<TClientContext> {
+    /**
+     * Base url for all requests.
+     */
     url: string;
-    headers?: (input: unknown, context: TClientContext) => Promisable<Headers | Record<string, string>>;
+    /**
+     * The maximum length of the URL.
+     *
+     * @default 2083
+     */
+    maxURLLength?: number;
+    /**
+     * The method used to make the request.
+     *
+     * @default 'POST'
+     */
+    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.
+     *
+     * @default 'POST'
+     */
+    fallbackMethod?: HTTPMethod;
+    headers?: (path: readonly string[], input: unknown, context: TClientContext) => Promisable<Headers | Record<string, string>>;
     fetch?: FetchWithContext<TClientContext>;
     payloadCodec?: PublicORPCPayloadCodec;
 }
-export declare class ORPCLink<TClientContext> implements ClientLink<TClientContext> {
-    private readonly options;
+export declare class RPCLink<TClientContext> implements ClientLink<TClientContext> {
     private readonly fetch;
     private readonly payloadCodec;
-    constructor(options: ORPCLinkOptions<TClientContext>);
-    call(path: readonly string[], input: unknown, options: ProcedureClientOptions<TClientContext>): Promise<unknown>;
+    private readonly maxURLLength;
+    private readonly fallbackMethod;
+    private readonly getMethod;
+    private readonly getHeaders;
+    private readonly url;
+    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/dynamic-link.d.ts

@@ -1,4 +1,4 @@
-import type { ProcedureClientOptions } from '@orpc/server';
+import type { ClientOptions } from '@orpc/contract';
 import type { Promisable } from '@orpc/shared';
 import type { ClientLink } from './types';
 /**
@@ -7,9 +7,7 @@ import type { ClientLink } from './types';
  */
 export declare class DynamicLink<TClientContext> implements ClientLink<TClientContext> {
     private readonly linkResolver;
-    constructor(linkResolver: (path: readonly string[], input: unknown, options: ProcedureClientOptions<TClientContext> & {
-        context: TClientContext;
-    }) => Promisable<ClientLink<TClientContext>>);
-    call(path: readonly string[], input: unknown, options: ProcedureClientOptions<TClientContext>): Promise<unknown>;
+    constructor(linkResolver: (path: readonly string[], input: unknown, context: TClientContext) => Promisable<ClientLink<TClientContext>>);
+    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';
+import type { ClientOptions } from '@orpc/contract';
 export interface 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=types.d.ts.map

package/package.json

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