@orpc/client 1.14.9 → 1.14.11

package/dist/shared/client.BRJnOJ0R.mjs

@@ -0,0 +1,174 @@
+import { sortPlugins, runWithSpan, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, intercept, getOpenTelemetryConfig, value, pathToHttpPath, stringifyJSON } from '@orpc/shared';
+import { mergeStandardHeaders, parseStandardUrl } from '@standardserver/core';
+import { toStandardHeaders } from '@standardserver/fetch';
+import { O as ORPCError } from './client.Dnfj8jnT.mjs';
+import { R as RPCSerializer, i as isORPCErrorJson, c as createORPCErrorFromJson } from './client.DqYwRDUO.mjs';
+
+class CompositeStandardLinkPlugin {
+  name = "~composite";
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = sortPlugins(plugins);
+  }
+  init(options) {
+    for (const plugin of this.plugins) {
+      if (plugin.init) {
+        options = plugin.init(options);
+      }
+    }
+    return options;
+  }
+}
+
+class StandardLink {
+  constructor(codec, transport, options = {}) {
+    this.codec = codec;
+    this.transport = transport;
+    options = new CompositeStandardLinkPlugin(options.plugins).init(options);
+    this.interceptors = options.interceptors;
+    this.transportInterceptors = options.transportInterceptors;
+  }
+  interceptors;
+  transportInterceptors;
+  /**
+   * @throws ORPCError, transport-level errors (network failures, timeouts, etc.)
+   */
+  call(path, input, options) {
+    return runWithSpan(`${ORPC_NAME}.${path.join("/")}`, (span) => {
+      span?.setAttribute("rpc.system", ORPC_NAME);
+      span?.setAttribute("rpc.method", path.join("."));
+      if (isAsyncIteratorObject(input)) {
+        input = override(input, traceAsyncIterator("consume_async_iterator_object_input", input));
+      }
+      return intercept(this.interceptors, { ...options, path, input }, async ({ path: path2, input: input2, ...options2 }) => {
+        const otel = getOpenTelemetryConfig();
+        let activeContext;
+        const activeSpan = otel?.trace.getActiveSpan() ?? span;
+        if (activeSpan && otel) {
+          activeContext = otel.trace.setSpan(otel.context.active(), activeSpan);
+        }
+        let request = await runWithSpan(
+          { name: "encode_input", context: activeContext },
+          () => this.codec.encodeInput(input2, path2, options2)
+        );
+        if (activeContext && otel?.propagation) {
+          const headers = { ...request.headers };
+          otel.propagation.inject(activeContext, headers);
+          request = { ...request, headers };
+        }
+        const response = await intercept(
+          this.transportInterceptors,
+          { ...options2, path: path2, request },
+          ({ path: path3, request: request2, ...options3 }) => {
+            let activeTransportContext;
+            const activeTransportSpan = otel?.trace.getActiveSpan() ?? activeSpan;
+            if (activeTransportSpan && otel) {
+              activeTransportContext = otel.trace.setSpan(otel.context.active(), activeTransportSpan);
+            }
+            return runWithSpan(
+              { name: "send_request", context: activeTransportContext },
+              () => this.transport.send(request2, path3, options3)
+            );
+          }
+        );
+        const decodedResult = await runWithSpan(
+          { name: "decode_response", context: activeContext },
+          () => this.codec.decodeResponse(response, path2, options2)
+        );
+        if (decodedResult.kind === "error") {
+          throw decodedResult.error;
+        }
+        const output = decodedResult.output;
+        if (isAsyncIteratorObject(output)) {
+          return override(output, traceAsyncIterator("consume_async_iterator_object_output", output));
+        }
+        return output;
+      });
+    });
+  }
+}
+
+const END_SLASH_REGEX = /\/$/;
+class RPCLinkCodec {
+  baseUrl;
+  maxUrlLength;
+  fallbackMethod;
+  expectedMethod;
+  headers;
+  serializer;
+  constructor(options) {
+    this.baseUrl = options.url ?? "/";
+    this.maxUrlLength = options.maxUrlLength ?? 2083;
+    this.fallbackMethod = options.fallbackMethod ?? "POST";
+    this.expectedMethod = options.method ?? this.fallbackMethod;
+    this.headers = options.headers ?? {};
+    this.serializer = options.serializer ?? new RPCSerializer();
+  }
+  async encodeInput(input, path, options) {
+    let headers = toResolvedStandardHeaders(await value(this.headers, options, path, input));
+    if (options.lastEventId !== void 0) {
+      headers = mergeStandardHeaders(headers, { "last-event-id": options.lastEventId });
+    }
+    const expectedMethod = await value(this.expectedMethod, options, path, input);
+    const baseUrl = await value(this.baseUrl, options, path, input);
+    const [pathname, search, hash] = parseStandardUrl(baseUrl);
+    const newPathname = `${pathname.replace(END_SLASH_REGEX, "")}${pathToHttpPath(path)}`;
+    const serialized = this.serializer.serialize(input);
+    if (expectedMethod === "GET" && !(serialized instanceof Blob) && !(serialized instanceof ReadableStream) && !(serialized instanceof FormData) && !isAsyncIteratorObject(serialized)) {
+      const maxUrlLength = await value(this.maxUrlLength, options, path, input);
+      const mergedSearch = new URLSearchParams(search);
+      mergedSearch.append("data", stringifyJSON(serialized) ?? "");
+      const url2 = `${newPathname}?${mergedSearch}${hash ?? ""}`;
+      if (url2.length <= maxUrlLength) {
+        return {
+          body: void 0,
+          method: expectedMethod,
+          headers,
+          url: url2,
+          signal: options.signal
+        };
+      }
+    }
+    const url = `${newPathname}${search ?? ""}${hash ?? ""}`;
+    return {
+      url,
+      method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
+      headers,
+      body: serialized,
+      signal: options.signal
+    };
+  }
+  async decodeResponse(response) {
+    const isOk = response.status < 400;
+    const body = await response.resolveBody();
+    const deserialized = await (async () => {
+      try {
+        return this.serializer.deserialize(body);
+      } catch (cause) {
+        throw new Error("Invalid RPC response format.", {
+          cause
+        });
+      }
+    })();
+    if (!isOk) {
+      if (isORPCErrorJson(deserialized)) {
+        return { kind: "error", error: createORPCErrorFromJson(deserialized) };
+      }
+      return {
+        kind: "error",
+        error: new ORPCError("MALFORMED_ORPC_ERROR_RESPONSE", {
+          data: { headers: response.headers, status: response.status, body: deserialized }
+        })
+      };
+    }
+    return { kind: "output", output: deserialized };
+  }
+}
+function toResolvedStandardHeaders(headers) {
+  if (typeof headers.forEach === "function") {
+    return toStandardHeaders(headers);
+  }
+  return headers;
+}
+
+export { CompositeStandardLinkPlugin as C, RPCLinkCodec as R, StandardLink as S };

package/dist/shared/client.BdItY5DT.d.mts

@@ -0,0 +1,111 @@
+import { StandardBody } from '@standardserver/core';
+import { Segment } from '@orpc/shared';
+
+type RPCJsonSerializationMeta = [type: string, ...path: Segment[]];
+type RPCJsonSerialization = {
+    json: unknown;
+    meta?: RPCJsonSerializationMeta[] | undefined;
+    maps?: undefined;
+    blobs?: undefined;
+} | {
+    json: unknown;
+    meta?: RPCJsonSerializationMeta[] | undefined;
+    maps: Segment[][];
+    blobs: Blob[];
+};
+interface RPCJsonSerializerHandler {
+    condition(value: unknown): boolean;
+    serialize(value: any): unknown;
+    deserialize(serialized: any): unknown;
+    /**
+     * If false, the result of this serializer will not be further processed by other serializers,
+     * even if it matches their conditions and treat it as final serialized value.
+     * This can be useful for serializers that return primitive values, which should not be further processed.
+     * to improve performance and avoid potential issues with other serializers.
+     *
+     * @default false
+     */
+    isTerminal?: boolean;
+}
+interface RPCJsonSerializerOptions {
+    /**
+     * Extend or override the built-in type handlers used during serialization and deserialization.
+     *
+     * Each key is a unique type identifier (e.g. `"date"`, `"bigint"`) and maps to a handler
+     * that defines how to detect, serialize, and deserialize values of that type.
+     *
+     * **Extending:** Add new keys to support custom types:
+     * ```ts
+     * handlers: {
+     *   buffer: {
+     *     condition: (v) => v instanceof Buffer,
+     *     serialize: (v: Buffer) => v.toString('base64'),
+     *     deserialize: (s: string) => Buffer.from(s, 'base64'),
+     *     isTerminal: true,
+     *   }
+     * }
+     * ```
+     *
+     * **Overriding:** Use an existing key to replace a built-in handler:
+     * ```ts
+     * handlers: {
+     *   date: {
+     *     condition: (v) => v instanceof Date,
+     *     serialize: (v: Date) => v.getTime(),
+     *     deserialize: (n: number) => new Date(n),
+     *     isTerminal: true,
+     *   }
+     * }
+     * ```
+     *
+     * **Disabling:** Set a key to `undefined` to remove a built-in handler:
+     * ```ts
+     * handlers: { regexp: undefined }
+     * ```
+     *
+     * Built-in type keys: `undefined`, `bigint`, `date`, `nan`, `url`, `regexp`, `set`, `map`.
+     */
+    handlers?: Record<string, undefined | RPCJsonSerializerHandler> | undefined;
+    /**
+     * If true, properties with undefined values will be omitted during serialization.
+     *
+     * @default true
+     */
+    omitUndefinedProperties?: boolean | undefined;
+}
+declare class RPCJsonSerializer {
+    private readonly handlers;
+    private readonly omitUndefinedProperties;
+    constructor(options?: RPCJsonSerializerOptions);
+    serialize(data: unknown): RPCJsonSerialization;
+    private serializeValue;
+    deserialize(serialized: RPCJsonSerialization): unknown;
+}
+
+interface RPCSerializerSerializeOptions {
+    /**
+     * Use FormData for serialization when nested blobs are present.
+     * Does not apply to root-level Blob values.
+     *
+     * @default true
+     */
+    useFormDataForBlobFields?: boolean;
+}
+interface RPCSerializerOptions extends RPCJsonSerializerOptions {
+    /**
+     * Default options for serialize method
+     */
+    serialize?: RPCSerializerSerializeOptions | undefined;
+}
+declare class RPCSerializer {
+    private readonly jsonSerializer;
+    private readonly defaultSerializeOptions;
+    constructor(options?: RPCSerializerOptions);
+    serialize(data: unknown, options?: RPCSerializerSerializeOptions): StandardBody;
+    private serializeValue;
+    deserialize(data: StandardBody): unknown;
+    private deserializeValue;
+}
+
+export { RPCJsonSerializer as b, RPCSerializer as e };
+export type { RPCJsonSerialization as R, RPCJsonSerializationMeta as a, RPCJsonSerializerHandler as c, RPCJsonSerializerOptions as d, RPCSerializerOptions as f, RPCSerializerSerializeOptions as g };

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

@@ -0,0 +1,111 @@
+import { StandardBody } from '@standardserver/core';
+import { Segment } from '@orpc/shared';
+
+type RPCJsonSerializationMeta = [type: string, ...path: Segment[]];
+type RPCJsonSerialization = {
+    json: unknown;
+    meta?: RPCJsonSerializationMeta[] | undefined;
+    maps?: undefined;
+    blobs?: undefined;
+} | {
+    json: unknown;
+    meta?: RPCJsonSerializationMeta[] | undefined;
+    maps: Segment[][];
+    blobs: Blob[];
+};
+interface RPCJsonSerializerHandler {
+    condition(value: unknown): boolean;
+    serialize(value: any): unknown;
+    deserialize(serialized: any): unknown;
+    /**
+     * If false, the result of this serializer will not be further processed by other serializers,
+     * even if it matches their conditions and treat it as final serialized value.
+     * This can be useful for serializers that return primitive values, which should not be further processed.
+     * to improve performance and avoid potential issues with other serializers.
+     *
+     * @default false
+     */
+    isTerminal?: boolean;
+}
+interface RPCJsonSerializerOptions {
+    /**
+     * Extend or override the built-in type handlers used during serialization and deserialization.
+     *
+     * Each key is a unique type identifier (e.g. `"date"`, `"bigint"`) and maps to a handler
+     * that defines how to detect, serialize, and deserialize values of that type.
+     *
+     * **Extending:** Add new keys to support custom types:
+     * ```ts
+     * handlers: {
+     *   buffer: {
+     *     condition: (v) => v instanceof Buffer,
+     *     serialize: (v: Buffer) => v.toString('base64'),
+     *     deserialize: (s: string) => Buffer.from(s, 'base64'),
+     *     isTerminal: true,
+     *   }
+     * }
+     * ```
+     *
+     * **Overriding:** Use an existing key to replace a built-in handler:
+     * ```ts
+     * handlers: {
+     *   date: {
+     *     condition: (v) => v instanceof Date,
+     *     serialize: (v: Date) => v.getTime(),
+     *     deserialize: (n: number) => new Date(n),
+     *     isTerminal: true,
+     *   }
+     * }
+     * ```
+     *
+     * **Disabling:** Set a key to `undefined` to remove a built-in handler:
+     * ```ts
+     * handlers: { regexp: undefined }
+     * ```
+     *
+     * Built-in type keys: `undefined`, `bigint`, `date`, `nan`, `url`, `regexp`, `set`, `map`.
+     */
+    handlers?: Record<string, undefined | RPCJsonSerializerHandler> | undefined;
+    /**
+     * If true, properties with undefined values will be omitted during serialization.
+     *
+     * @default true
+     */
+    omitUndefinedProperties?: boolean | undefined;
+}
+declare class RPCJsonSerializer {
+    private readonly handlers;
+    private readonly omitUndefinedProperties;
+    constructor(options?: RPCJsonSerializerOptions);
+    serialize(data: unknown): RPCJsonSerialization;
+    private serializeValue;
+    deserialize(serialized: RPCJsonSerialization): unknown;
+}
+
+interface RPCSerializerSerializeOptions {
+    /**
+     * Use FormData for serialization when nested blobs are present.
+     * Does not apply to root-level Blob values.
+     *
+     * @default true
+     */
+    useFormDataForBlobFields?: boolean;
+}
+interface RPCSerializerOptions extends RPCJsonSerializerOptions {
+    /**
+     * Default options for serialize method
+     */
+    serialize?: RPCSerializerSerializeOptions | undefined;
+}
+declare class RPCSerializer {
+    private readonly jsonSerializer;
+    private readonly defaultSerializeOptions;
+    constructor(options?: RPCSerializerOptions);
+    serialize(data: unknown, options?: RPCSerializerSerializeOptions): StandardBody;
+    private serializeValue;
+    deserialize(data: StandardBody): unknown;
+    private deserializeValue;
+}
+
+export { RPCJsonSerializer as b, RPCSerializer as e };
+export type { RPCJsonSerialization as R, RPCJsonSerializationMeta as a, RPCJsonSerializerHandler as c, RPCJsonSerializerOptions as d, RPCSerializerOptions as f, RPCSerializerSerializeOptions as g };

package/dist/shared/client.Dnfj8jnT.mjs

@@ -0,0 +1,92 @@
+import { resolveMaybeOptionalOptions, getConstructor } from '@orpc/shared';
+
+const COMMON_ERROR_STATUS_MAP = {
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_SUPPORTED: 405,
+  NOT_ACCEPTABLE: 406,
+  TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  UNPROCESSABLE_CONTENT: 422,
+  PRECONDITION_REQUIRED: 428,
+  TOO_MANY_REQUESTS: 429,
+  CLIENT_CLOSED_REQUEST: 499,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504
+};
+let ORPCErrorConstructors;
+class ORPCError extends Error {
+  static {
+    const ORPC_ERROR_CONSTRUCTORS_SYMBOL = Symbol.for("ORPC_ERROR_CONSTRUCTORS");
+    void (globalThis[ORPC_ERROR_CONSTRUCTORS_SYMBOL] ??= /* @__PURE__ */ new WeakSet());
+    ORPCErrorConstructors = globalThis[ORPC_ERROR_CONSTRUCTORS_SYMBOL];
+    ORPCErrorConstructors.add(ORPCError);
+  }
+  /**
+   * @info
+   * The `__branch` property is used for type branding, helping TypeScript distinguish
+   * an `ORPCError` instance from plain objects with a similar structure.
+   */
+  name = "ORPCError";
+  /**
+   * Indicates whether the error matches a definition in the procedure's `.errors` map.
+   */
+  defined = false;
+  /**
+   * Indicates whether the error's type is inferable at the TypeScript level.
+   * This is typically true when the error is explicitly defined or returned within a handler.
+   */
+  inferable = false;
+  code;
+  data;
+  constructor(code, ...rest) {
+    const options = resolveMaybeOptionalOptions(rest);
+    const message = options.message ?? code.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+    super(message, options);
+    this.code = code;
+    this.data = options.data;
+  }
+  toJSON() {
+    return {
+      defined: this.defined,
+      inferable: this.inferable,
+      code: this.code,
+      message: this.message,
+      data: this.data
+    };
+  }
+  /**
+   * Workaround for Next.js where different contexts use separate
+   * dependency graphs, causing multiple ORPCError constructors existing and breaking
+   * `instanceof` checks across contexts.
+   *
+   * This is particularly problematic with "Optimized SSR", where orpc-client
+   * executes in one context but is invoked from another. When an error is thrown
+   * in the execution context, `instanceof ORPCError` checks fail in the
+   * invocation context due to separate class constructors.
+   *
+   * @todo Remove this and related code if Next.js resolves the multiple dependency graph issue.
+   */
+  static [Symbol.hasInstance](instance) {
+    if (!ORPCErrorConstructors.has(this)) {
+      return super[Symbol.hasInstance](instance);
+    }
+    const constructor = getConstructor(instance);
+    if (constructor && ORPCErrorConstructors.has(constructor)) {
+      return true;
+    }
+    return super[Symbol.hasInstance](instance);
+  }
+}
+
+export { COMMON_ERROR_STATUS_MAP as C, ORPCError as O };