@orpc/client 0.0.0-next.ee0aeaf → 0.0.0-next.f22c7ec

package/dist/fetch.js

@@ -0,0 +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";
+var RPCLink = class {
+  fetch;
+  payloadCodec;
+  maxURLLength;
+  fallbackMethod;
+  getMethod;
+  getHeaders;
+  url;
+  constructor(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));
+    };
+  }
+  async call(path, input, options) {
+    const clientContext = options.context;
+    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) {
+      if (ORPCError.isValidJSON(decoded)) {
+        throw new ORPCError(decoded);
+      }
+      throw new ORPCError({
+        status: response.status,
+        code: "INTERNAL_SERVER_ERROR",
+        message: "Internal server error",
+        cause: decoded
+      });
+    }
+    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 {
+  RPCLink
+};
+//# sourceMappingURL=fetch.js.map

package/dist/index.js

@@ -1,86 +1,42 @@
-// src/procedure.ts
-import { ORPC_PROTOCOL_HEADER, ORPC_PROTOCOL_VALUE, trim } from "@orpc/shared";
-import { ORPCError } from "@orpc/shared/error";
-import { ORPCDeserializer, ORPCSerializer } from "@orpc/transformer";
-var serializer = new ORPCSerializer();
-var deserializer = new ORPCDeserializer();
-function createProcedureClient(options) {
-  const client = async (...args) => {
-    const [input, callerOptions] = args;
-    const fetch_ = options.fetch ?? fetch;
-    const url = `${trim(options.baseURL, "/")}/${options.path.map(encodeURIComponent).join("/")}`;
-    const headers = new Headers({
-      [ORPC_PROTOCOL_HEADER]: ORPC_PROTOCOL_VALUE
-    });
-    let customHeaders = await options.headers?.(input);
-    customHeaders = customHeaders instanceof Headers ? customHeaders : new Headers(customHeaders);
-    for (const [key, value] of customHeaders.entries()) {
-      headers.append(key, value);
-    }
-    const serialized = serializer.serialize(input);
-    for (const [key, value] of serialized.headers.entries()) {
-      headers.append(key, value);
-    }
-    const response = await fetch_(url, {
-      method: "POST",
-      headers,
-      body: serialized.body,
-      signal: callerOptions?.signal
-    });
-    const json = await (async () => {
-      try {
-        return await deserializer.deserialize(response);
-      } catch (e) {
-        throw new ORPCError({
-          code: "INTERNAL_SERVER_ERROR",
-          message: "Cannot parse response.",
-          cause: e
-        });
+// src/client.ts
+function createORPCClient(link, options) {
+  const path = options?.path ?? [];
+  const procedureClient = async (...[input, options2]) => {
+    return await link.call(path, input, options2 ?? {});
+  };
+  const recursive = new Proxy(procedureClient, {
+    get(target, key) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
       }
-    })();
-    if (!response.ok) {
-      throw ORPCError.fromJSON(json) ?? new ORPCError({
-        status: response.status,
-        code: "INTERNAL_SERVER_ERROR",
-        message: "Internal server error"
+      return createORPCClient(link, {
+        ...options,
+        path: [...path, key]
       });
     }
-    return json;
-  };
-  return client;
+  });
+  return recursive;
 }
 
-// src/router.ts
-function createRouterClient(options) {
-  const path = options?.path ?? [];
-  const client = new Proxy(
-    createProcedureClient({
-      baseURL: options.baseURL,
-      fetch: options.fetch,
-      headers: options.headers,
-      path
-    }),
-    {
-      get(target, key) {
-        if (typeof key !== "string") {
-          return Reflect.get(target, key);
-        }
-        return createRouterClient({
-          ...options,
-          path: [...path, key]
-        });
-      }
-    }
-  );
-  return client;
-}
+// src/dynamic-link.ts
+var DynamicLink = class {
+  constructor(linkResolver) {
+    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);
+    return output;
+  }
+};
 
 // src/index.ts
-export * from "@orpc/shared/error";
-var createORPCClient = createRouterClient;
+import { isDefinedError, ORPCError, safe } from "@orpc/contract";
 export {
+  DynamicLink,
+  ORPCError,
   createORPCClient,
-  createProcedureClient,
-  createRouterClient
+  isDefinedError,
+  safe
 };
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,3 @@
+export * from './orpc-link';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,46 @@
+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 RPCLinkOptions<TClientContext> {
+    /**
+     * Base url for all requests.
+     */
+    url: 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 RPCLink<TClientContext> implements ClientLink<TClientContext> {
+    private readonly fetch;
+    private readonly payloadCodec;
+    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/adapters/fetch/types.d.ts

@@ -0,0 +1,4 @@
+export interface FetchWithContext<TClientContext> {
+    (input: RequestInfo | URL, init: RequestInit | undefined, context: TClientContext): Promise<Response>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/client.d.ts

@@ -0,0 +1,11 @@
+import type { ContractRouter, ContractRouterClient } from '@orpc/contract';
+import type { ANY_ROUTER, RouterClient } from '@orpc/server';
+import type { ClientLink } from './types';
+export interface createORPCClientOptions {
+    /**
+     * Use as base path for all procedure, useful when you only want to call a subset of the procedure.
+     */
+    path?: string[];
+}
+export declare function createORPCClient<TRouter extends ANY_ROUTER | ContractRouter<any>, TClientContext = unknown>(link: ClientLink<TClientContext>, options?: createORPCClientOptions): TRouter extends ContractRouter<any> ? ContractRouterClient<TRouter, TClientContext> : TRouter extends ANY_ROUTER ? RouterClient<TRouter, TClientContext> : never;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,13 @@
+import type { 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> {
+    private readonly linkResolver;
+    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

@@ -1,7 +1,6 @@
 /** unnoq */
-import { createRouterClient } from './router';
-export * from './procedure';
-export * from './router';
-export * from '@orpc/shared/error';
-export declare const createORPCClient: typeof createRouterClient;
+export * from './client';
+export * from './dynamic-link';
+export * from './types';
+export { isDefinedError, ORPCError, safe } from '@orpc/contract';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/types.d.ts

@@ -0,0 +1,5 @@
+import type { ClientOptions } from '@orpc/contract';
+export interface ClientLink<TClientContext> {
+    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.ee0aeaf",
+  "version": "0.0.0-next.f22c7ec",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -19,6 +19,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./fetch": {
+      "types": "./dist/src/adapters/fetch/index.d.ts",
+      "import": "./dist/fetch.js",
+      "default": "./dist/fetch.js"
+    },
     "./🔒/*": {
       "types": "./dist/src/*.d.ts"
     }
@@ -28,20 +33,17 @@
     "!**/*.tsbuildinfo",
     "dist"
   ],
-  "peerDependencies": {
-    "@orpc/contract": "0.0.0-next.ee0aeaf",
-    "@orpc/server": "0.0.0-next.ee0aeaf"
-  },
   "dependencies": {
-    "@orpc/shared": "0.0.0-next.ee0aeaf",
-    "@orpc/transformer": "0.0.0-next.ee0aeaf"
+    "@orpc/contract": "0.0.0-next.f22c7ec",
+    "@orpc/server": "0.0.0-next.f22c7ec",
+    "@orpc/shared": "0.0.0-next.f22c7ec"
   },
   "devDependencies": {
     "zod": "^3.24.1",
-    "@orpc/openapi": "0.0.0-next.ee0aeaf"
+    "@orpc/openapi": "0.0.0-next.f22c7ec"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/adapters/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/src/procedure.d.ts

@@ -1,24 +0,0 @@
-import type { Caller } from '@orpc/server';
-import type { Promisable } from '@orpc/shared';
-export interface CreateProcedureClientOptions {
-    /**
-     * The base url of the server.
-     */
-    baseURL: string;
-    /**
-     * The fetch function used to make the request.
-     * @default global fetch
-     */
-    fetch?: typeof fetch;
-    /**
-     * The headers used to make the request.
-     * Invoked before the request is made.
-     */
-    headers?: (input: unknown) => Promisable<Headers | Record<string, string>>;
-    /**
-     * The path of the procedure on server.
-     */
-    path: string[];
-}
-export declare function createProcedureClient<TInput, TOutput>(options: CreateProcedureClientOptions): Caller<TInput, TOutput>;
-//# sourceMappingURL=procedure.d.ts.map

package/dist/src/router.d.ts

@@ -1,9 +0,0 @@
-import type { ContractProcedure, ContractRouter, SchemaInput, SchemaOutput } from '@orpc/contract';
-import type { Caller, Lazy, Procedure, Router } from '@orpc/server';
-import type { SetOptional } from '@orpc/shared';
-import type { CreateProcedureClientOptions } from './procedure';
-export type RouterClient<T extends Router<any> | ContractRouter> = {
-    [K in keyof T]: T[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> | Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> | Lazy<Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput>> ? Caller<SchemaInput<UInputSchema>, SchemaOutput<UOutputSchema, UFuncOutput>> : T[K] extends Router<any> | ContractRouter ? RouterClient<T[K]> : never;
-};
-export declare function createRouterClient<T extends Router<any> | ContractRouter>(options: SetOptional<CreateProcedureClientOptions, 'path'>): RouterClient<T>;
-//# sourceMappingURL=router.d.ts.map