@orpc/client 0.0.0-next.5d3da98 → 0.0.0-next.5d5051b

package/dist/shared/client.DUjXqpDq.d.ts

@@ -0,0 +1,47 @@
+import { Interceptor, ThrowableError } from '@orpc/shared';
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { a as ClientContext, b as ClientOptions, C as ClientLink } from './client.CipPQkhk.js';
+
+interface StandardLinkCodec<T extends ClientContext> {
+    encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<unknown>;
+}
+interface StandardLinkClient<T extends ClientContext> {
+    call(request: StandardRequest, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
+}
+
+interface StandardLinkPlugin<T extends ClientContext> {
+    order?: number;
+    init?(options: StandardLinkOptions<T>): void;
+}
+declare class CompositeStandardLinkPlugin<T extends ClientContext, TPlugin extends StandardLinkPlugin<T>> implements StandardLinkPlugin<T> {
+    protected readonly plugins: TPlugin[];
+    constructor(plugins?: readonly TPlugin[]);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+declare class InvalidEventIteratorRetryResponse extends Error {
+}
+interface StandardLinkInterceptorOptions<T extends ClientContext> extends ClientOptions<T> {
+    path: readonly string[];
+    input: unknown;
+}
+interface StandardLinkClientInterceptorOptions<T extends ClientContext> extends StandardLinkInterceptorOptions<T> {
+    request: StandardRequest;
+}
+interface StandardLinkOptions<T extends ClientContext> {
+    interceptors?: Interceptor<StandardLinkInterceptorOptions<T>, unknown, ThrowableError>[];
+    clientInterceptors?: Interceptor<StandardLinkClientInterceptorOptions<T>, StandardLazyResponse, ThrowableError>[];
+    plugins?: StandardLinkPlugin<T>[];
+}
+declare class StandardLink<T extends ClientContext> implements ClientLink<T> {
+    #private;
+    readonly codec: StandardLinkCodec<T>;
+    readonly sender: StandardLinkClient<T>;
+    private readonly interceptors;
+    private readonly clientInterceptors;
+    constructor(codec: StandardLinkCodec<T>, sender: StandardLinkClient<T>, options?: StandardLinkOptions<T>);
+    call(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<unknown>;
+}
+
+export { CompositeStandardLinkPlugin as C, InvalidEventIteratorRetryResponse as I, type StandardLinkClientInterceptorOptions as S, type StandardLinkPlugin as a, type StandardLinkOptions as b, type StandardLinkInterceptorOptions as c, StandardLink as d, type StandardLinkCodec as e, type StandardLinkClient as f };

package/dist/shared/client.DraH2Kdf.d.ts

@@ -0,0 +1,90 @@
+import { a as ClientContext, b as ClientOptions, d as HTTPMethod } from './client.CipPQkhk.js';
+import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.DUjXqpDq.js';
+import { Segment, Value } from '@orpc/shared';
+import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+
+declare const STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES: {
+    readonly BIGINT: 0;
+    readonly DATE: 1;
+    readonly NAN: 2;
+    readonly UNDEFINED: 3;
+    readonly URL: 4;
+    readonly REGEXP: 5;
+    readonly SET: 6;
+    readonly MAP: 7;
+};
+type StandardRPCJsonSerializedMetaItem = readonly [type: number, ...path: Segment[]];
+type StandardRPCJsonSerialized = [json: unknown, meta: StandardRPCJsonSerializedMetaItem[], maps: Segment[][], blobs: Blob[]];
+interface StandardRPCCustomJsonSerializer {
+    type: number;
+    condition(data: unknown): boolean;
+    serialize(data: any): unknown;
+    deserialize(serialized: any): unknown;
+}
+interface StandardRPCJsonSerializerOptions {
+    customJsonSerializers?: readonly StandardRPCCustomJsonSerializer[];
+}
+declare class StandardRPCJsonSerializer {
+    private readonly customSerializers;
+    constructor(options?: StandardRPCJsonSerializerOptions);
+    serialize(data: unknown, segments?: Segment[], meta?: StandardRPCJsonSerializedMetaItem[], maps?: Segment[][], blobs?: Blob[]): StandardRPCJsonSerialized;
+    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[]): unknown;
+    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[], maps: readonly Segment[][], getBlob: (index: number) => Blob): unknown;
+}
+
+declare class StandardRPCSerializer {
+    #private;
+    private readonly jsonSerializer;
+    constructor(jsonSerializer: StandardRPCJsonSerializer);
+    serialize(data: unknown): object;
+    deserialize(data: unknown): unknown;
+}
+
+interface StandardRPCLinkCodecOptions<T extends ClientContext> {
+    /**
+     * Base url for all requests.
+     */
+    url: Value<string | URL, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
+    /**
+     * The maximum length of the URL.
+     *
+     * @default 2083
+     */
+    maxUrlLength?: Value<number, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
+    /**
+     * The method used to make the request.
+     *
+     * @default 'POST'
+     */
+    method?: Value<HTTPMethod, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
+    /**
+     * The method to use when the payload cannot safely pass to the server with method return from method function.
+     * GET is not allowed, it's very dangerous.
+     *
+     * @default 'POST'
+     */
+    fallbackMethod?: Exclude<HTTPMethod, 'GET'>;
+    /**
+     * Inject headers to the request.
+     */
+    headers?: Value<StandardHeaders, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
+}
+declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
+    private readonly serializer;
+    private readonly baseUrl;
+    private readonly maxUrlLength;
+    private readonly fallbackMethod;
+    private readonly expectedMethod;
+    private readonly headers;
+    constructor(serializer: StandardRPCSerializer, options: StandardRPCLinkCodecOptions<T>);
+    encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse): Promise<unknown>;
+}
+
+interface StandardRPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, StandardRPCJsonSerializerOptions {
+}
+declare class StandardRPCLink<T extends ClientContext> extends StandardLink<T> {
+    constructor(linkClient: StandardLinkClient<T>, options: StandardRPCLinkOptions<T>);
+}
+
+export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as S, type StandardRPCJsonSerializedMetaItem as a, type StandardRPCJsonSerialized as b, type StandardRPCCustomJsonSerializer as c, type StandardRPCJsonSerializerOptions as d, StandardRPCJsonSerializer as e, type StandardRPCLinkOptions as f, StandardRPCLink as g, type StandardRPCLinkCodecOptions as h, StandardRPCLinkCodec as i, StandardRPCSerializer as j };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.0.0-next.5d3da98",
+  "version": "0.0.0-next.5d5051b",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -15,37 +15,39 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     },
-    "./fetch": {
-      "types": "./dist/src/adapters/fetch/index.d.ts",
-      "import": "./dist/fetch.js",
-      "default": "./dist/fetch.js"
+    "./plugins": {
+      "types": "./dist/plugins/index.d.mts",
+      "import": "./dist/plugins/index.mjs",
+      "default": "./dist/plugins/index.mjs"
+    },
+    "./standard": {
+      "types": "./dist/adapters/standard/index.d.mts",
+      "import": "./dist/adapters/standard/index.mjs",
+      "default": "./dist/adapters/standard/index.mjs"
     },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+    "./fetch": {
+      "types": "./dist/adapters/fetch/index.d.mts",
+      "import": "./dist/adapters/fetch/index.mjs",
+      "default": "./dist/adapters/fetch/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
-  "peerDependencies": {
-    "@orpc/contract": "0.0.0-next.5d3da98"
-  },
   "dependencies": {
-    "@orpc/shared": "0.0.0-next.5d3da98",
-    "@orpc/server": "0.0.0-next.5d3da98"
+    "@orpc/shared": "0.0.0-next.5d5051b",
+    "@orpc/standard-server-fetch": "0.0.0-next.5d5051b",
+    "@orpc/standard-server": "0.0.0-next.5d5051b"
   },
   "devDependencies": {
-    "zod": "^3.24.1",
-    "@orpc/openapi": "0.0.0-next.5d3da98"
+    "zod": "^3.24.2"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/adapters/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/fetch.js

@@ -1,46 +0,0 @@
-// 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 {
-  constructor(options) {
-    this.options = options;
-    this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
-    this.payloadCodec = options.payloadCodec ?? new ORPCPayloadCodec();
-  }
-  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,
-      body: encoded.body,
-      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;
-    }
-    return decoded;
-  }
-};
-export {
-  ORPCLink
-};
-//# sourceMappingURL=fetch.js.map

package/dist/index.js

@@ -1,39 +0,0 @@
-// 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);
-      }
-      return createORPCClient(link, {
-        ...options,
-        path: [...path, key]
-      });
-    }
-  });
-  return recursive;
-}
-
-// 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);
-    const output = await resolvedLink.call(path, input, options);
-    return output;
-  }
-};
-
-// src/index.ts
-export * from "@orpc/shared/error";
-export {
-  DynamicLink,
-  createORPCClient
-};
-//# sourceMappingURL=index.js.map

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

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

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

@@ -1,19 +0,0 @@
-import type { ProcedureClientOptions } from '@orpc/server';
-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> {
-    url: string;
-    headers?: (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;
-    private readonly fetch;
-    private readonly payloadCodec;
-    constructor(options: ORPCLinkOptions<TClientContext>);
-    call(path: readonly string[], input: unknown, options: ProcedureClientOptions<TClientContext>): Promise<unknown>;
-}
-//# sourceMappingURL=orpc-link.d.ts.map

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

@@ -1,4 +0,0 @@
-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

@@ -1,11 +0,0 @@
-import type { ContractRouter } 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, TClientContext = unknown>(link: ClientLink<TClientContext>, options?: createORPCClientOptions): RouterClient<TRouter, TClientContext>;
-//# sourceMappingURL=client.d.ts.map

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

@@ -1,15 +0,0 @@
-import type { ProcedureClientOptions } from '@orpc/server';
-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, options: ProcedureClientOptions<TClientContext> & {
-        context: TClientContext;
-    }) => Promisable<ClientLink<TClientContext>>);
-    call(path: readonly string[], input: unknown, options: ProcedureClientOptions<TClientContext>): Promise<unknown>;
-}
-//# sourceMappingURL=dynamic-link.d.ts.map

package/dist/src/index.d.ts

@@ -1,6 +0,0 @@
-/** unnoq */
-export * from './client';
-export * from './dynamic-link';
-export * from './types';
-export * from '@orpc/shared/error';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/types.d.ts

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