@orpc/client 0.39.0 → 0.41.0

package/dist/src/index.d.ts

@@ -1,6 +1,9 @@
 /** unnoq */
 export * from './client';
 export * from './dynamic-link';
+export * from './error';
+export * from './event-iterator';
+export * from './event-iterator-state';
 export * from './types';
-export { isDefinedError, ORPCError, safe } from '@orpc/contract';
+export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/openapi/bracket-notation.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Serialize an object or array into a list of [key, value] pairs.
+ * The key will express by using bracket-notation.
+ *
+ * Notice: This way cannot express the empty object or array.
+ *
+ * @example
+ * ```ts
+ * const payload = {
+ *  name: 'John Doe',
+ *  pets: ['dog', 'cat'],
+ * }
+ *
+ * const entities = serialize(payload)
+ *
+ * expect(entities).toEqual([
+ *  ['name', 'John Doe'],
+ *  ['name[pets][0]', 'dog'],
+ *  ['name[pets][1]', 'cat'],
+ * ])
+ * ```
+ */
+export declare function serialize(payload: unknown, parentKey?: string): [string, unknown][];
+/**
+ * Deserialize a list of [key, value] pairs into an object or array.
+ * The key is expressed by using bracket-notation.
+ *
+ * @example
+ * ```ts
+ * const entities = [
+ *  ['name', 'John Doe'],
+ *  ['name[pets][0]', 'dog'],
+ *  ['name[pets][1]', 'cat'],
+ *  ['name[dogs][]', 'hello'],
+ *  ['name[dogs][]', 'kitty'],
+ * ]
+ *
+ * const payload = deserialize(entities)
+ *
+ * expect(payload).toEqual({
+ *  name: 'John Doe',
+ *  pets: { 0: 'dog', 1: 'cat' },
+ *  dogs: ['hello', 'kitty'],
+ * })
+ * ```
+ */
+export declare function deserialize(entities: readonly (readonly [string, unknown])[]): Record<string, unknown> | unknown[] | undefined;
+/**
+ * Escape the `[`, `]`, and `\` chars in a path segment.
+ *
+ * @example
+ * ```ts
+ * expect(escapeSegment('name[pets')).toEqual('name\\[pets')
+ * ```
+ */
+export declare function escapeSegment(segment: string): string;
+/**
+ * Convert an array of path segments into a path string using bracket-notation.
+ *
+ * For the special char `[`, `]`, and `\` will be escaped by adding `\` at start.
+ *
+ * @example
+ * ```ts
+ * expect(stringifyPath(['name', 'pets', '0'])).toEqual('name[pets][0]')
+ * ```
+ */
+export declare function stringifyPath(path: readonly [string, ...string[]]): string;
+/**
+ * Convert a path string using bracket-notation into an array of path segments.
+ *
+ * For the special char `[`, `]`, and `\` you should escape by adding `\` at start.
+ * It only treats a pair `[${string}]` as a path segment.
+ * If missing or escape it will bypass and treat as normal string.
+ *
+ * @example
+ * ```ts
+ * expect(parsePath('name[pets][0]')).toEqual(['name', 'pets', '0'])
+ * expect(parsePath('name[pets][0')).toEqual(['name', 'pets', '[0'])
+ * expect(parsePath('name[pets[0]')).toEqual(['name', 'pets[0')
+ * expect(parsePath('name\\[pets][0]')).toEqual(['name[pets]', '0'])
+ * ```
+ */
+export declare function parsePath(path: string): [string, ...string[]];
+//# sourceMappingURL=bracket-notation.d.ts.map

package/dist/src/openapi/index.d.ts

@@ -0,0 +1,4 @@
+export * as BracketNotation from './bracket-notation';
+export * from './json-serializer';
+export * from './serializer';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/openapi/json-serializer.d.ts

@@ -0,0 +1,5 @@
+export declare class OpenAPIJsonSerializer {
+    serialize(payload: unknown): unknown;
+}
+export type PublicOpenAPIJsonSerializer = Pick<OpenAPIJsonSerializer, keyof OpenAPIJsonSerializer>;
+//# sourceMappingURL=json-serializer.d.ts.map

package/dist/src/openapi/serializer.d.ts

@@ -0,0 +1,11 @@
+import type { PublicOpenAPIJsonSerializer } from './json-serializer';
+export interface OpenAPISerializerOptions {
+    jsonSerializer?: PublicOpenAPIJsonSerializer;
+}
+export declare class OpenAPISerializer {
+    private readonly jsonSerializer;
+    constructor(options?: OpenAPISerializerOptions);
+    serialize(data: unknown): unknown;
+    deserialize(serialized: unknown): unknown;
+}
+//# sourceMappingURL=serializer.d.ts.map

package/dist/src/rpc/index.d.ts

@@ -0,0 +1,2 @@
+export * from './serializer';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/rpc/serializer.d.ts

@@ -0,0 +1,22 @@
+import type { Segment } from '@orpc/shared';
+export type RPCSerializedJsonMeta = ['bigint' | 'date' | 'nan' | 'undefined' | 'set' | 'map' | 'regexp' | 'url', Segment[]][];
+export type RPCSerialized = {
+    json: unknown;
+    meta: RPCSerializedJsonMeta;
+} | FormData | AsyncIteratorObject<{
+    json: unknown;
+    meta: RPCSerializedJsonMeta;
+}, {
+    json: unknown;
+    meta: RPCSerializedJsonMeta;
+}, void>;
+export type RPCSerializedFormDataMaps = Segment[][];
+export declare class RPCSerializer {
+    serialize(data: unknown): RPCSerialized;
+    deserialize(serialized: RPCSerialized): unknown;
+}
+export declare function serializeRPCJson(value: unknown, segments?: Segment[], meta?: RPCSerializedJsonMeta): {
+    json: unknown;
+    meta: RPCSerializedJsonMeta;
+};
+//# sourceMappingURL=serializer.d.ts.map

package/dist/src/types.d.ts

@@ -1,5 +1,29 @@
-import type { ClientContext, ClientOptions } from '@orpc/contract';
+export type ClientContext = Record<string, any>;
+export type ClientOptions<TClientContext extends ClientContext> = {
+    signal?: AbortSignal;
+    lastEventId?: string | undefined;
+} & (Record<never, never> extends TClientContext ? {
+    context?: TClientContext;
+} : {
+    context: TClientContext;
+});
+export type ClientRest<TClientContext extends ClientContext, TInput> = [input: TInput, options: ClientOptions<TClientContext>] | (Record<never, never> extends TClientContext ? (undefined extends TInput ? [input?: TInput] : [input: TInput]) : never);
+export type ClientPromiseResult<TOutput, TError extends Error> = Promise<TOutput> & {
+    __error?: {
+        type: TError;
+    };
+};
+export interface Client<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
+    (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
+}
+export type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
+    [k: string]: NestedClient<TClientContext>;
+};
+export type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
+export type ClientOptionsOut<TClientContext extends ClientContext> = ClientOptions<TClientContext> & {
+    context: TClientContext;
+};
 export interface ClientLink<TClientContext extends ClientContext> {
-    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
+    call: (path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>) => Promise<unknown>;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/src/utils.d.ts

@@ -0,0 +1,5 @@
+import type { ORPCError } from './error';
+import type { ClientPromiseResult } from './types';
+export type SafeResult<TOutput, TError extends Error> = [output: TOutput, error: undefined, isDefinedError: false] | [output: undefined, error: TError, isDefinedError: false] | [output: undefined, error: Extract<TError, ORPCError<any, any>>, isDefinedError: true];
+export declare function safe<TOutput, TError extends Error>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
+//# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.39.0",
+  "version": "0.41.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -19,6 +19,16 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./openapi": {
+      "types": "./dist/src/openapi/index.d.ts",
+      "import": "./dist/openapi.js",
+      "default": "./dist/openapi.js"
+    },
+    "./rpc": {
+      "types": "./dist/src/rpc/index.d.ts",
+      "import": "./dist/rpc.js",
+      "default": "./dist/rpc.js"
+    },
     "./fetch": {
       "types": "./dist/src/adapters/fetch/index.d.ts",
       "import": "./dist/fetch.js",
@@ -34,18 +44,15 @@
     "dist"
   ],
   "dependencies": {
-    "@orpc/server-standard-fetch": "^0.0.0",
-    "@tinyhttp/content-disposition": "^2.2.2",
-    "@orpc/contract": "0.39.0",
-    "@orpc/server": "0.39.0",
-    "@orpc/shared": "0.39.0"
+    "@orpc/server-standard": "^0.4.0",
+    "@orpc/server-standard-fetch": "^0.4.0",
+    "@orpc/shared": "0.41.0"
   },
   "devDependencies": {
-    "zod": "^3.24.1",
-    "@orpc/openapi": "0.39.0"
+    "zod": "^3.24.1"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/adapters/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "tsup --onSuccess='tsc -b --noCheck'",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

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

@@ -1,46 +0,0 @@
-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 { RPCSerializer } from '@orpc/server/standard';
-export interface RPCLinkOptions<TClientContext extends ClientContext> {
-    /**
-     * 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.
-     * GET is not allowed, it's very dangerous.
-     *
-     * @default 'POST'
-     */
-    fallbackMethod?: Exclude<HTTPMethod, 'GET'>;
-    headers?(path: readonly string[], input: unknown, context: TClientContext): Promisable<Headers | Record<string, string>>;
-    fetch?: FetchWithContext<TClientContext>;
-    rpcSerializer?: RPCSerializer;
-}
-export declare class RPCLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
-    private readonly fetch;
-    private readonly rpcSerializer;
-    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