@orpc/shared 0.0.0-next.ccd4e42 → 0.0.0-next.d0e429d

package/README.md

@@ -0,0 +1,68 @@
+<div align="center">
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 />
+</div>
+
+<h1></h1>
+
+<div align="center">
+  <a href="https://codecov.io/gh/unnoq/orpc">
+    <img alt="codecov" src="https://codecov.io/gh/unnoq/orpc/branch/main/graph/badge.svg">
+  </a>
+  <a href="https://www.npmjs.com/package/@orpc/shared">
+    <img alt="weekly downloads" src="https://img.shields.io/npm/dw/%40orpc%2Fshared?logo=npm" />
+  </a>
+  <a href="https://github.com/unnoq/orpc/blob/main/LICENSE">
+    <img alt="MIT License" src="https://img.shields.io/github/license/unnoq/orpc?logo=open-source-initiative" />
+  </a>
+  <a href="https://discord.gg/TXEbwRBvQn">
+    <img alt="Discord" src="https://img.shields.io/discord/1308966753044398161?color=7389D8&label&logo=discord&logoColor=ffffff" />
+  </a>
+</div>
+
+<h3 align="center">Typesafe APIs Made Simple 🪄</h3>
+
+**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards, ensuring a smooth and enjoyable developer experience.
+
+---
+
+## Highlights
+
+- **End-to-End Type Safety 🔒**: Ensure complete type safety from inputs to outputs and errors, bridging server and client seamlessly.
+- **First-Class OpenAPI 📄**: Adheres to the OpenAPI standard out of the box, ensuring seamless integration and comprehensive API documentation.
+- **Contract-First Development 📜**: (Optional) Define your API contract upfront and implement it with confidence.
+- **Exceptional Developer Experience ✨**: Enjoy a streamlined workflow with robust typing and clear, in-code documentation.
+- **Multi-Runtime Support 🌍**: Run your code seamlessly on Cloudflare, Deno, Bun, Node.js, and more.
+- **Framework Integrations 🧩**: Supports Tanstack Query (React, Vue), Pinia Colada, and more.
+- **Server Actions ⚡️**: Fully compatible with React Server Actions on Next.js, TanStack Start, and more.
+- **Standard Schema Support 🗂️**: Effortlessly work with Zod, Valibot, ArkType, and others right out of the box.
+- **Fast & Lightweight 💨**: Built on native APIs across all runtimes – optimized for speed and efficiency.
+- **Native Types 📦**: Enjoy built-in support for Date, File, Blob, BigInt, URL and more with no extra setup.
+- **Lazy Router ⏱️**: Improve cold start times with our lazy routing feature.
+- **SSE & Streaming 📡**: Provides SSE and streaming features – perfect for real-time notifications and AI-powered streaming responses.
+- **Reusability 🔄**: Write once and reuse your code across multiple purposes effortlessly.
+- **Extendability 🔌**: Easily enhance oRPC with plugins, middleware, and interceptors.
+- **Reliability 🛡️**: Well-tested, fully TypeScript, production-ready, and MIT licensed for peace of mind.
+- **Simplicity 💡**: Enjoy straightforward, clean code with no hidden magic.
+
+## Documentation
+
+You can find the full documentation [here](https://orpc.unnoq.com).
+
+## Packages
+
+- [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
+- [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
+- [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
+- [@orpc/react-query](https://www.npmjs.com/package/@orpc/react-query): Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview).
+- [@orpc/vue-query](https://www.npmjs.com/package/@orpc/vue-query): Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview).
+- [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
+- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
+
+## `@orpc/shared`
+
+Provides shared utilities for oRPC packages.
+
+## License
+
+Distributed under the MIT License. See [LICENSE](https://github.com/unnoq/orpc/blob/main/LICENSE) for more information.

package/dist/index.js

@@ -1,9 +1,58 @@
-// src/constants.ts
-var ORPC_HANDLER_HEADER = "x-orpc-handler";
-var ORPC_HANDLER_VALUE = "orpc";
+// src/object.ts
+function set(root, segments, value2) {
+  const ref = { root };
+  let currentRef = ref;
+  let preSegment = "root";
+  for (const segment of segments) {
+    currentRef = currentRef[preSegment];
+    preSegment = segment;
+  }
+  currentRef[preSegment] = value2;
+  return ref.root;
+}
+function get(root, segments) {
+  const ref = { root };
+  let currentRef = ref;
+  let preSegment = "root";
+  for (const segment of segments) {
+    if (typeof currentRef !== "object" && typeof currentRef !== "function" || currentRef === null) {
+      return void 0;
+    }
+    currentRef = currentRef[preSegment];
+    preSegment = segment;
+  }
+  if (typeof currentRef !== "object" && typeof currentRef !== "function" || currentRef === null) {
+    return void 0;
+  }
+  return currentRef[preSegment];
+}
+function findDeepMatches(check, payload, segments = [], maps = [], values = []) {
+  if (check(payload)) {
+    maps.push(segments);
+    values.push(payload);
+  } else if (Array.isArray(payload)) {
+    payload.forEach((v, i) => {
+      findDeepMatches(check, v, [...segments, i], maps, values);
+    });
+  } else if (isObject(payload)) {
+    for (const key in payload) {
+      findDeepMatches(check, payload[key], [...segments, key], maps, values);
+    }
+  }
+  return { maps, values };
+}
+function isObject(value2) {
+  if (!value2 || typeof value2 !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value2);
+  return proto === Object.prototype || !proto || !proto.constructor;
+}
+function isTypescriptObject(value2) {
+  return !!value2 && (typeof value2 === "object" || typeof value2 === "function");
+}
 
 // src/error.ts
-import { isPlainObject } from "is-what";
 function toError(error) {
   if (error instanceof Error) {
     return error;
@@ -11,7 +60,7 @@ function toError(error) {
   if (typeof error === "string") {
     return new Error(error, { cause: error });
   }
-  if (isPlainObject(error)) {
+  if (isObject(error)) {
     if ("message" in error && typeof error.message === "string") {
       return new Error(error.message, { cause: error });
     }
@@ -35,64 +84,6 @@ function once(fn) {
   };
 }
 
-// src/hook.ts
-async function executeWithHooks(options) {
-  const interceptors = convertToArray(options.hooks?.interceptor);
-  const onStarts = convertToArray(options.hooks?.onStart);
-  const onSuccesses = convertToArray(options.hooks?.onSuccess);
-  const onErrors = convertToArray(options.hooks?.onError);
-  const onFinishes = convertToArray(options.hooks?.onFinish);
-  let currentExecuteIndex = 0;
-  const next = async () => {
-    const execute = interceptors[currentExecuteIndex];
-    if (execute) {
-      currentExecuteIndex++;
-      return await execute(options.input, options.context, {
-        ...options.meta,
-        next
-      });
-    }
-    let state = { status: "pending", input: options.input, output: void 0, error: void 0 };
-    try {
-      for (const onStart2 of onStarts) {
-        await onStart2(state, options.context, options.meta);
-      }
-      const output = await options.execute();
-      state = { status: "success", input: options.input, output, error: void 0 };
-      for (let i = onSuccesses.length - 1; i >= 0; i--) {
-        await onSuccesses[i](state, options.context, options.meta);
-      }
-    } catch (e) {
-      state = { status: "error", input: options.input, error: toError(e), output: void 0 };
-      for (let i = onErrors.length - 1; i >= 0; i--) {
-        try {
-          await onErrors[i](state, options.context, options.meta);
-        } catch (e2) {
-          state = { status: "error", input: options.input, error: toError(e2), output: void 0 };
-        }
-      }
-    }
-    for (let i = onFinishes.length - 1; i >= 0; i--) {
-      try {
-        await onFinishes[i](state, options.context, options.meta);
-      } catch (e) {
-        state = { status: "error", input: options.input, error: toError(e), output: void 0 };
-      }
-    }
-    if (state.status === "error") {
-      throw state.error;
-    }
-    return state.output;
-  };
-  return await next();
-}
-function convertToArray(value2) {
-  if (value2 === void 0) {
-    return [];
-  }
-  return Array.isArray(value2) ? value2 : [value2];
-}
-
 // src/interceptor.ts
 function onStart(callback) {
   return async (options, ...rest) => {
@@ -132,104 +123,38 @@ function onFinish(callback) {
     }
   };
 }
-async function intercept(interceptable, options, main) {
-  const interceptors = interceptable.interceptors ?? [];
+async function intercept(interceptors, options, main) {
   let index = 0;
-  const next = async (nextOptions = options) => {
+  const next = async (options2) => {
     const interceptor = interceptors[index++];
     if (!interceptor) {
-      return await main(nextOptions);
+      return await main(options2);
     }
     return await interceptor({
-      ...nextOptions,
-      next
+      ...options2,
+      next: (newOptions = options2) => next(newOptions)
     });
   };
-  return await next();
+  return await next(options);
 }
 
-// src/json.ts
-function parseJSONSafely(text) {
-  if (text === "")
-    return void 0;
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
+// src/iterator.ts
+function isAsyncIteratorObject(maybe) {
+  if (!maybe || typeof maybe !== "object") {
+    return false;
   }
+  return Symbol.asyncIterator in maybe && typeof maybe[Symbol.asyncIterator] === "function";
 }
 
-// src/object.ts
-import { isPlainObject as isPlainObject2 } from "is-what";
-function set(root, segments, value2) {
-  const ref = { root };
-  let currentRef = ref;
-  let preSegment = "root";
-  for (const segment of segments) {
-    currentRef = currentRef[preSegment];
-    preSegment = segment;
-  }
-  currentRef[preSegment] = value2;
-  return ref.root;
-}
-function get(root, segments) {
-  const ref = { root };
-  let currentRef = ref;
-  let preSegment = "root";
-  for (const segment of segments) {
-    if (typeof currentRef !== "object" && typeof currentRef !== "function" || currentRef === null) {
-      return void 0;
-    }
-    currentRef = currentRef[preSegment];
-    preSegment = segment;
-  }
-  if (typeof currentRef !== "object" && typeof currentRef !== "function" || currentRef === null) {
+// src/json.ts
+function parseEmptyableJSON(text) {
+  if (!text) {
     return void 0;
   }
-  return currentRef[preSegment];
-}
-function findDeepMatches(check, payload, segments = [], maps = [], values = []) {
-  if (check(payload)) {
-    maps.push(segments);
-    values.push(payload);
-  } else if (Array.isArray(payload)) {
-    payload.forEach((v, i) => {
-      findDeepMatches(check, v, [...segments, i], maps, values);
-    });
-  } else if (isPlainObject2(payload)) {
-    for (const key in payload) {
-      findDeepMatches(check, payload[key], [...segments, key], maps, values);
-    }
-  }
-  return { maps, values };
+  return JSON.parse(text);
 }
-
-// src/proxy.ts
-function createCallableObject(obj, handler) {
-  const proxy = new Proxy(handler, {
-    has(target, key) {
-      return Reflect.has(obj, key) || Reflect.has(target, key);
-    },
-    ownKeys(target) {
-      return Array.from(new Set(Reflect.ownKeys(obj).concat(...Reflect.ownKeys(target))));
-    },
-    get(target, key) {
-      if (!Reflect.has(target, key) || Reflect.has(obj, key)) {
-        return Reflect.get(obj, key);
-      }
-      return Reflect.get(target, key);
-    },
-    defineProperty(_, key, descriptor) {
-      return Reflect.defineProperty(obj, key, descriptor);
-    },
-    set(_, key, value2) {
-      return Reflect.set(obj, key, value2);
-    },
-    deleteProperty(target, key) {
-      return Reflect.deleteProperty(target, key) && Reflect.deleteProperty(obj, key);
-    }
-  });
-  return proxy;
+function stringifyJSON(value2) {
+  return JSON.stringify(value2);
 }
 
 // src/value.ts
@@ -241,20 +166,16 @@ function value(value2, ...args) {
 }
 
 // src/index.ts
-import { isPlainObject as isPlainObject3 } from "is-what";
-import { group, guard, mapEntries, mapValues, omit, trim } from "radash";
+import { group, guard, mapEntries, mapValues, omit, retry, trim } from "radash";
 export {
-  ORPC_HANDLER_HEADER,
-  ORPC_HANDLER_VALUE,
-  convertToArray,
-  createCallableObject,
-  executeWithHooks,
   findDeepMatches,
   get,
   group,
   guard,
   intercept,
-  isPlainObject3 as isPlainObject,
+  isAsyncIteratorObject,
+  isObject,
+  isTypescriptObject,
   mapEntries,
   mapValues,
   omit,
@@ -263,8 +184,10 @@ export {
   onStart,
   onSuccess,
   once,
-  parseJSONSafely,
+  parseEmptyableJSON,
+  retry,
   set,
+  stringifyJSON,
   toError,
   trim,
   value

package/dist/src/index.d.ts

@@ -1,14 +1,12 @@
 export * from './chain';
-export * from './constants';
 export * from './error';
 export * from './function';
-export * from './hook';
 export * from './interceptor';
+export * from './iterator';
 export * from './json';
 export * from './object';
-export * from './proxy';
+export * from './types';
 export * from './value';
-export { isPlainObject } from 'is-what';
-export { group, guard, mapEntries, mapValues, omit, trim } from 'radash';
-export type * from 'type-fest';
+export { group, guard, mapEntries, mapValues, omit, retry, trim } from 'radash';
+export type { IsEqual, IsNever, PartialDeep, Promisable } from 'type-fest';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/interceptor.d.ts

@@ -1,5 +1,4 @@
 import type { Promisable } from 'type-fest';
-import type { AnyFunction } from './function';
 export type InterceptableOptions = Record<string, any>;
 export type InterceptorOptions<TOptions extends InterceptableOptions, TResult> = Omit<TOptions, 'next'> & {
     next(options?: TOptions): Promise<TResult>;
@@ -9,9 +8,6 @@ export type Interceptor<TOptions extends InterceptableOptions, TResult, TError>
         type: TError;
     };
 };
-export interface Interceptable<TOptions extends InterceptableOptions, TResult, TError> {
-    interceptors?: Interceptor<TOptions, TResult, TError>[];
-}
 /**
  * Can used for interceptors or middlewares
  */
@@ -24,7 +20,6 @@ export declare function onStart<TOptions extends {
 export declare function onSuccess<TOptions extends {
     next(): any;
 }, TRest extends any[]>(callback: NoInfer<(result: Awaited<ReturnType<TOptions['next']>>, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => Promise<Awaited<ReturnType<TOptions['next']>>>;
-export type InferError<T extends AnyFunction> = T extends Interceptor<any, any, infer TError> ? TError : unknown;
 /**
  * Can used for interceptors or middlewares
  */
@@ -46,5 +41,5 @@ export declare function onFinish<TError, TOptions extends {
         type: TError;
     };
 };
-export declare function intercept<TOptions extends InterceptableOptions, TResult, TError>(interceptable: Interceptable<TOptions, TResult, TError>, options: NoInfer<TOptions>, main: NoInfer<(options: TOptions) => Promisable<TResult>>): Promise<TResult>;
+export declare function intercept<TOptions extends InterceptableOptions, TResult, TError>(interceptors: Interceptor<TOptions, TResult, TError>[], options: NoInfer<TOptions>, main: NoInfer<(options: TOptions) => Promisable<TResult>>): Promise<TResult>;
 //# sourceMappingURL=interceptor.d.ts.map

package/dist/src/iterator.d.ts

@@ -0,0 +1,2 @@
+export declare function isAsyncIteratorObject(maybe: unknown): maybe is AsyncIteratorObject<any, any, any>;
+//# sourceMappingURL=iterator.d.ts.map

package/dist/src/json.d.ts

@@ -1,2 +1,3 @@
-export declare function parseJSONSafely(text: string): unknown;
+export declare function parseEmptyableJSON(text: string | null | undefined): unknown;
+export declare function stringifyJSON<T>(value: T): undefined extends T ? undefined | string : string;
 //# sourceMappingURL=json.d.ts.map

package/dist/src/object.d.ts

@@ -5,4 +5,12 @@ export declare function findDeepMatches(check: (value: unknown) => boolean, payl
     maps: Segment[][];
     values: unknown[];
 };
+/**
+ * Check if the value is an object even it created by `Object.create(null)` or more tricky way.
+ */
+export declare function isObject(value: unknown): value is Record<PropertyKey, unknown>;
+/**
+ * Check if the value satisfy a `object` type in typescript
+ */
+export declare function isTypescriptObject(value: unknown): value is object & Record<PropertyKey, unknown>;
 //# sourceMappingURL=object.d.ts.map

package/dist/src/types.d.ts

@@ -0,0 +1,3 @@
+export type MaybeOptionalOptions<TOptions> = [options: TOptions] | (Record<never, never> extends TOptions ? [] : never);
+export type SetOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/value.d.ts

@@ -1,4 +1,4 @@
 import type { Promisable } from 'type-fest';
 export type Value<T, TArgs extends any[] = []> = T | ((...args: TArgs) => Promisable<T>);
-export declare function value<T extends Value<any, TArgs>, TArgs extends any[] = []>(value: T, ...args: TArgs): Promise<T extends Value<infer U, any> ? U : never>;
+export declare function value<T, TArgs extends any[]>(value: Value<T, TArgs>, ...args: NoInfer<TArgs>): Promise<T extends Value<infer U, any> ? U : never>;
 //# sourceMappingURL=value.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/shared",
   "type": "module",
-  "version": "0.0.0-next.ccd4e42",
+  "version": "0.0.0-next.d0e429d",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -29,8 +29,6 @@
     "dist"
   ],
   "dependencies": {
-    "@standard-schema/spec": "1.0.0-beta.4",
-    "is-what": "^5.0.2",
     "radash": "^12.1.0",
     "type-fest": "^4.26.1"
   },

package/dist/src/constants.d.ts

@@ -1,3 +0,0 @@
-export declare const ORPC_HANDLER_HEADER = "x-orpc-handler";
-export declare const ORPC_HANDLER_VALUE = "orpc";
-//# sourceMappingURL=constants.d.ts.map

package/dist/src/hook.d.ts

@@ -1,42 +0,0 @@
-import type { Arrayable, Promisable } from 'type-fest';
-export type OnStartState<TInput> = {
-    status: 'pending';
-    input: TInput;
-    output: undefined;
-    error: undefined;
-};
-export type OnSuccessState<TInput, TOutput> = {
-    status: 'success';
-    input: TInput;
-    output: TOutput;
-    error: undefined;
-};
-export type OnErrorState<TInput> = {
-    status: 'error';
-    input: TInput;
-    output: undefined;
-    error: Error;
-};
-export interface BaseHookMeta<TOutput> {
-    next(): Promise<TOutput>;
-}
-export interface Hooks<TInput, TOutput, TContext, TMeta extends (Record<string, any> & {
-    next?: never;
-}) | undefined> {
-    interceptor?: Arrayable<(input: TInput, context: TContext, meta: (TMeta extends undefined ? unknown : TMeta) & BaseHookMeta<TOutput>) => Promise<TOutput>>;
-    onStart?: Arrayable<(state: OnStartState<TInput>, context: TContext, meta: TMeta) => Promisable<void>>;
-    onSuccess?: Arrayable<(state: OnSuccessState<TInput, TOutput>, context: TContext, meta: TMeta) => Promisable<void>>;
-    onError?: Arrayable<(state: OnErrorState<TInput>, context: TContext, meta: TMeta) => Promisable<void>>;
-    onFinish?: Arrayable<(state: OnSuccessState<TInput, TOutput> | OnErrorState<TInput>, context: TContext, meta: TMeta) => Promisable<void>>;
-}
-export declare function executeWithHooks<TInput, TOutput, TContext, TMeta extends (Record<string, any> & {
-    next?: never;
-}) | undefined>(options: {
-    hooks?: Hooks<TInput, TOutput, TContext, TMeta>;
-    input: TInput;
-    context: TContext;
-    meta: TMeta;
-    execute: BaseHookMeta<TOutput>['next'];
-}): Promise<TOutput>;
-export declare function convertToArray<T>(value: undefined | T | readonly T[]): readonly T[];
-//# sourceMappingURL=hook.d.ts.map

package/dist/src/proxy.d.ts

@@ -1,3 +0,0 @@
-import type { AnyFunction } from './function';
-export declare function createCallableObject<TObject extends object, THandler extends AnyFunction>(obj: TObject, handler: THandler): TObject & THandler;
-//# sourceMappingURL=proxy.d.ts.map