@orpc/client 0.0.0-next.d137cdf → 0.0.0-next.d5f0415

package/dist/src/error.d.ts

@@ -0,0 +1,106 @@
+import { type MaybeOptionalOptions } from '@orpc/shared';
+export declare const COMMON_ORPC_ERROR_DEFS: {
+    readonly BAD_REQUEST: {
+        readonly status: 400;
+        readonly message: "Bad Request";
+    };
+    readonly UNAUTHORIZED: {
+        readonly status: 401;
+        readonly message: "Unauthorized";
+    };
+    readonly FORBIDDEN: {
+        readonly status: 403;
+        readonly message: "Forbidden";
+    };
+    readonly NOT_FOUND: {
+        readonly status: 404;
+        readonly message: "Not Found";
+    };
+    readonly METHOD_NOT_SUPPORTED: {
+        readonly status: 405;
+        readonly message: "Method Not Supported";
+    };
+    readonly NOT_ACCEPTABLE: {
+        readonly status: 406;
+        readonly message: "Not Acceptable";
+    };
+    readonly TIMEOUT: {
+        readonly status: 408;
+        readonly message: "Request Timeout";
+    };
+    readonly CONFLICT: {
+        readonly status: 409;
+        readonly message: "Conflict";
+    };
+    readonly PRECONDITION_FAILED: {
+        readonly status: 412;
+        readonly message: "Precondition Failed";
+    };
+    readonly PAYLOAD_TOO_LARGE: {
+        readonly status: 413;
+        readonly message: "Payload Too Large";
+    };
+    readonly UNSUPPORTED_MEDIA_TYPE: {
+        readonly status: 415;
+        readonly message: "Unsupported Media Type";
+    };
+    readonly UNPROCESSABLE_CONTENT: {
+        readonly status: 422;
+        readonly message: "Unprocessable Content";
+    };
+    readonly TOO_MANY_REQUESTS: {
+        readonly status: 429;
+        readonly message: "Too Many Requests";
+    };
+    readonly CLIENT_CLOSED_REQUEST: {
+        readonly status: 499;
+        readonly message: "Client Closed Request";
+    };
+    readonly INTERNAL_SERVER_ERROR: {
+        readonly status: 500;
+        readonly message: "Internal Server Error";
+    };
+    readonly NOT_IMPLEMENTED: {
+        readonly status: 501;
+        readonly message: "Not Implemented";
+    };
+    readonly BAD_GATEWAY: {
+        readonly status: 502;
+        readonly message: "Bad Gateway";
+    };
+    readonly SERVICE_UNAVAILABLE: {
+        readonly status: 503;
+        readonly message: "Service Unavailable";
+    };
+    readonly GATEWAY_TIMEOUT: {
+        readonly status: 504;
+        readonly message: "Gateway Timeout";
+    };
+};
+export type CommonORPCErrorCode = keyof typeof COMMON_ORPC_ERROR_DEFS;
+export type ORPCErrorCode = CommonORPCErrorCode | (string & {});
+export declare function fallbackORPCErrorStatus(code: ORPCErrorCode, status: number | undefined): number;
+export declare function fallbackORPCErrorMessage(code: ORPCErrorCode, message: string | undefined): string;
+export type ORPCErrorOptions<TData> = ErrorOptions & {
+    defined?: boolean;
+    status?: number;
+    message?: string;
+} & (undefined extends TData ? {
+    data?: TData;
+} : {
+    data: TData;
+});
+export declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
+    readonly defined: boolean;
+    readonly code: TCode;
+    readonly status: number;
+    readonly data: TData;
+    constructor(code: TCode, ...[options]: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
+    toJSON(): ORPCErrorJSON<TCode, TData>;
+    static fromJSON<TCode extends ORPCErrorCode, TData>(json: ORPCErrorJSON<TCode, TData>, options?: ErrorOptions): ORPCError<TCode, TData>;
+    static isValidJSON(json: unknown): json is ORPCErrorJSON<ORPCErrorCode, unknown>;
+}
+export type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
+export declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
+export declare function toORPCError(error: unknown): ORPCError<any, any>;
+//# sourceMappingURL=error.d.ts.map

package/dist/src/event-iterator-state.d.ts

@@ -0,0 +1,9 @@
+export type ConnectionStatus = 'reconnecting' | 'connected' | 'closed';
+export interface EventIteratorState {
+    status: ConnectionStatus;
+    listeners: Array<(newStatus: ConnectionStatus) => void>;
+}
+export declare function registerEventIteratorState(iterator: AsyncIteratorObject<unknown, unknown, void>, state: EventIteratorState): void;
+export declare function updateEventIteratorStatus(state: EventIteratorState, status: ConnectionStatus): void;
+export declare function onEventIteratorStatusChange(iterator: AsyncIteratorObject<unknown, unknown, void>, callback: (status: ConnectionStatus) => void, notifyImmediately?: boolean): () => void;
+//# sourceMappingURL=event-iterator-state.d.ts.map

package/dist/src/event-iterator.d.ts

@@ -0,0 +1,12 @@
+export declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
+    value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
+    error: (error: unknown) => Promise<unknown>;
+}): AsyncGenerator<TMap, TMap, TNext>;
+export interface EventIteratorReconnectOptions {
+    lastRetry: number | undefined;
+    lastEventId: string | undefined;
+    retryTimes: number;
+    error: unknown;
+}
+export declare function createAutoRetryEventIterator<TYield, TReturn>(initial: AsyncIterator<TYield, TReturn, void>, reconnect: (options: EventIteratorReconnectOptions) => Promise<AsyncIterator<TYield, TReturn, void> | null>, initialLastEventId: string | undefined): AsyncGenerator<TYield, TReturn, void>;
+//# sourceMappingURL=event-iterator.d.ts.map

package/dist/src/index.d.ts

@@ -1,7 +1,9 @@
 /** 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 './error';
+export * from './event-iterator';
+export * from './event-iterator-state';
+export * from './types';
+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

@@ -0,0 +1,29 @@
+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> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options: ClientOptions<TClientContext>];
+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: 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.0.0-next.d137cdf",
+  "version": "0.0.0-next.d5f0415",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -19,6 +19,21 @@
       "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",
+      "default": "./dist/fetch.js"
+    },
     "./🔒/*": {
       "types": "./dist/src/*.d.ts"
     }
@@ -28,20 +43,16 @@
     "!**/*.tsbuildinfo",
     "dist"
   ],
-  "peerDependencies": {
-    "@orpc/server": "0.0.0-next.d137cdf",
-    "@orpc/contract": "0.0.0-next.d137cdf"
-  },
   "dependencies": {
-    "@orpc/shared": "0.0.0-next.d137cdf",
-    "@orpc/transformer": "0.0.0-next.d137cdf"
+    "@orpc/server-standard": "^0.4.0",
+    "@orpc/server-standard-fetch": "^0.4.0",
+    "@orpc/shared": "0.0.0-next.d5f0415"
   },
   "devDependencies": {
-    "zod": "^3.23.8",
-    "@orpc/openapi": "0.0.0-next.d137cdf"
+    "zod": "^3.24.1"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/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/procedure.d.ts

@@ -1,27 +0,0 @@
-import type { Promisable } from '@orpc/shared';
-import { type Schema, type SchemaInput, type SchemaOutput } from '@orpc/contract';
-export interface ProcedureClient<TInputSchema extends Schema, TOutputSchema extends Schema, TFuncOutput extends SchemaOutput<TOutputSchema>> {
-    (input: SchemaInput<TInputSchema>): Promise<SchemaOutput<TOutputSchema, TFuncOutput>>;
-}
-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<TInputSchema extends Schema, TOutputSchema extends Schema, TFuncOutput extends SchemaOutput<TOutputSchema>>(options: CreateProcedureClientOptions): ProcedureClient<TInputSchema, TOutputSchema, TFuncOutput>;
-//# sourceMappingURL=procedure.d.ts.map

package/dist/src/router.d.ts

@@ -1,34 +0,0 @@
-import type { ContractProcedure, ContractRouter, SchemaOutput } from '@orpc/contract';
-import type { Lazy, Procedure, Router } from '@orpc/server';
-import type { Promisable } from '@orpc/shared';
-import { type ProcedureClient } from './procedure';
-export type RouterClientWithContractRouter<TRouter extends ContractRouter> = {
-    [K in keyof TRouter]: TRouter[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? ProcedureClient<UInputSchema, UOutputSchema, SchemaOutput<UOutputSchema>> : TRouter[K] extends ContractRouter ? RouterClientWithContractRouter<TRouter[K]> : never;
-};
-export type RouterClientWithRouter<TRouter extends Router<any>> = {
-    [K in keyof TRouter]: TRouter[K] extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> | Lazy<Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput>> ? ProcedureClient<UInputSchema, UOutputSchema, UFuncOutput> : TRouter[K] extends Router<any> ? RouterClientWithRouter<TRouter[K]> : never;
-};
-export interface CreateRouterClientOptions {
-    /**
-     * 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>>;
-    /**
-     * This used for internal purpose only.
-     *
-     * @internal
-     */
-    path?: string[];
-}
-export declare function createRouterClient<TRouter extends Router<any> | ContractRouter>(options: CreateRouterClientOptions): TRouter extends Router<any> ? RouterClientWithRouter<TRouter> : TRouter extends ContractRouter ? RouterClientWithContractRouter<TRouter> : never;
-//# sourceMappingURL=router.d.ts.map