@orpc/shared 0.0.0-next.f81b4a2 → 0.0.0-next.fcb9d5a

package/README.md

@@ -26,28 +26,24 @@
 
 <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.
+**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
 
 ---
 
 ## 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, Solid, Svelte), 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.
+- **🔗 End-to-End Type Safety**: Ensure type-safe inputs, outputs, and errors from client to server.
+- **📘 First-Class OpenAPI**: Built-in support that fully adheres to the OpenAPI standard.
+- **📝 Contract-First Development**: Optionally define your API contract before implementation.
+- **⚙️ Framework Integrations**: Seamlessly integrate with TanStack Query (React, Vue, Solid, Svelte), Pinia Colada, and more.
+- **🚀 Server Actions**: Fully compatible with React Server Actions on Next.js, TanStack Start, and other platforms.
+- **🔠 Standard Schema Support**: Works out of the box with Zod, Valibot, ArkType, and other schema validators.
+- **🗃️ Native Types**: Supports native types like Date, File, Blob, BigInt, URL, and more.
+- **⏱️ Lazy Router**: Enhance cold start times with our lazy routing feature.
+- **📡 SSE & Streaming**: Enjoy full type-safe support for SSE and streaming.
+- **🌍 Multi-Runtime Support**: Fast and lightweight on Cloudflare, Deno, Bun, Node.js, and beyond.
+- **🔌 Extendability**: Easily extend functionality with plugins, middleware, and interceptors.
+- **🛡️ Reliability**: Well-tested, TypeScript-based, production-ready, and MIT licensed.
 
 ## Documentation
 
@@ -58,6 +54,7 @@ You can find the full documentation [here](https://orpc.unnoq.com).
 - [@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/nest](https://www.npmjs.com/package/@orpc/nest): Deeply integrate oRPC with NestJS.
 - [@orpc/react](https://www.npmjs.com/package/@orpc/react): Utilities for integrating oRPC with React and React Server Actions.
 - [@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).

package/dist/index.d.mts

@@ -10,11 +10,17 @@ declare function splitInHalf<T>(arr: readonly T[]): [T[], T[]];
 
 type AnyFunction = (...args: any[]) => any;
 declare function once<T extends () => any>(fn: T): () => ReturnType<T>;
+declare function sequential<A extends any[], R>(fn: (...args: A) => Promise<R>): (...args: A) => Promise<R>;
 
 type OmitChainMethodDeep<T extends object, K extends keyof any> = {
     [P in keyof Omit<T, K>]: T[P] extends AnyFunction ? ((...args: Parameters<T[P]>) => OmitChainMethodDeep<ReturnType<T[P]>, K>) : T[P];
 };
 
+declare class SequentialIdGenerator {
+    private nextId;
+    generate(): number;
+}
+
 type SetOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 type IntersectPick<T, U> = Pick<T, keyof T & keyof U>;
 type PromiseWithError<T, TError> = Promise<T> & {
@@ -66,6 +72,10 @@ declare function onFinish<T, TOptions extends {
 declare function intercept<TOptions extends InterceptableOptions, TResult, TError>(interceptors: Interceptor<TOptions, TResult, TError>[], options: NoInfer<TOptions>, main: NoInfer<(options: TOptions) => Promisable<TResult>>): Promise<TResult>;
 
 declare function isAsyncIteratorObject(maybe: unknown): maybe is AsyncIteratorObject<any, any, any>;
+interface CreateAsyncIteratorObjectCleanupFn {
+    (reason: 'return' | 'throw' | 'next' | 'dispose'): Promise<void>;
+}
+declare function createAsyncIteratorObject<T, TReturn, TNext>(next: () => Promise<IteratorResult<T, TReturn>>, cleanup: CreateAsyncIteratorObjectCleanupFn): AsyncIteratorObject<T, TReturn, TNext> & AsyncGenerator<T, TReturn, TNext>;
 
 declare function parseEmptyableJSON(text: string | null | undefined): unknown;
 declare function stringifyJSON<T>(value: T): undefined extends T ? undefined | string : string;
@@ -86,8 +96,25 @@ declare function isTypescriptObject(value: unknown): value is object & Record<Pr
 declare function clone<T>(value: T): T;
 declare function get(object: object, path: readonly string[]): unknown;
 
+interface AsyncIdQueueCloseOptions {
+    id?: number;
+    reason?: Error;
+}
+declare class AsyncIdQueue<T> {
+    private readonly openIds;
+    private readonly items;
+    private readonly pendingPulls;
+    get length(): number;
+    open(id: number): void;
+    isOpen(id: number): boolean;
+    push(id: number, item: T): void;
+    pull(id: number): Promise<T>;
+    close({ id, reason }?: AsyncIdQueueCloseOptions): void;
+    assertOpen(id: number): void;
+}
+
 type Value<T, TArgs extends any[] = []> = T | ((...args: TArgs) => Promisable<T>);
 declare function value<T, TArgs extends any[]>(value: Value<T, TArgs>, ...args: NoInfer<TArgs>): Promise<T extends Value<infer U, any> ? U : never>;
 
-export { clone, findDeepMatches, get, intercept, isAsyncIteratorObject, isObject, isTypescriptObject, onError, onFinish, onStart, onSuccess, once, parseEmptyableJSON, resolveMaybeOptionalOptions, splitInHalf, stringifyJSON, toArray, value };
-export type { AnyFunction, InterceptableOptions, Interceptor, InterceptorOptions, IntersectPick, MaybeOptionalOptions, OmitChainMethodDeep, OnFinishState, PromiseWithError, Registry, Segment, SetOptional, ThrowableError, Value };
+export { AsyncIdQueue, SequentialIdGenerator, clone, createAsyncIteratorObject, findDeepMatches, get, intercept, isAsyncIteratorObject, isObject, isTypescriptObject, onError, onFinish, onStart, onSuccess, once, parseEmptyableJSON, resolveMaybeOptionalOptions, sequential, splitInHalf, stringifyJSON, toArray, value };
+export type { AnyFunction, AsyncIdQueueCloseOptions, CreateAsyncIteratorObjectCleanupFn, InterceptableOptions, Interceptor, InterceptorOptions, IntersectPick, MaybeOptionalOptions, OmitChainMethodDeep, OnFinishState, PromiseWithError, Registry, Segment, SetOptional, ThrowableError, Value };

package/dist/index.d.ts

@@ -10,11 +10,17 @@ declare function splitInHalf<T>(arr: readonly T[]): [T[], T[]];
 
 type AnyFunction = (...args: any[]) => any;
 declare function once<T extends () => any>(fn: T): () => ReturnType<T>;
+declare function sequential<A extends any[], R>(fn: (...args: A) => Promise<R>): (...args: A) => Promise<R>;
 
 type OmitChainMethodDeep<T extends object, K extends keyof any> = {
     [P in keyof Omit<T, K>]: T[P] extends AnyFunction ? ((...args: Parameters<T[P]>) => OmitChainMethodDeep<ReturnType<T[P]>, K>) : T[P];
 };
 
+declare class SequentialIdGenerator {
+    private nextId;
+    generate(): number;
+}
+
 type SetOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 type IntersectPick<T, U> = Pick<T, keyof T & keyof U>;
 type PromiseWithError<T, TError> = Promise<T> & {
@@ -66,6 +72,10 @@ declare function onFinish<T, TOptions extends {
 declare function intercept<TOptions extends InterceptableOptions, TResult, TError>(interceptors: Interceptor<TOptions, TResult, TError>[], options: NoInfer<TOptions>, main: NoInfer<(options: TOptions) => Promisable<TResult>>): Promise<TResult>;
 
 declare function isAsyncIteratorObject(maybe: unknown): maybe is AsyncIteratorObject<any, any, any>;
+interface CreateAsyncIteratorObjectCleanupFn {
+    (reason: 'return' | 'throw' | 'next' | 'dispose'): Promise<void>;
+}
+declare function createAsyncIteratorObject<T, TReturn, TNext>(next: () => Promise<IteratorResult<T, TReturn>>, cleanup: CreateAsyncIteratorObjectCleanupFn): AsyncIteratorObject<T, TReturn, TNext> & AsyncGenerator<T, TReturn, TNext>;
 
 declare function parseEmptyableJSON(text: string | null | undefined): unknown;
 declare function stringifyJSON<T>(value: T): undefined extends T ? undefined | string : string;
@@ -86,8 +96,25 @@ declare function isTypescriptObject(value: unknown): value is object & Record<Pr
 declare function clone<T>(value: T): T;
 declare function get(object: object, path: readonly string[]): unknown;
 
+interface AsyncIdQueueCloseOptions {
+    id?: number;
+    reason?: Error;
+}
+declare class AsyncIdQueue<T> {
+    private readonly openIds;
+    private readonly items;
+    private readonly pendingPulls;
+    get length(): number;
+    open(id: number): void;
+    isOpen(id: number): boolean;
+    push(id: number, item: T): void;
+    pull(id: number): Promise<T>;
+    close({ id, reason }?: AsyncIdQueueCloseOptions): void;
+    assertOpen(id: number): void;
+}
+
 type Value<T, TArgs extends any[] = []> = T | ((...args: TArgs) => Promisable<T>);
 declare function value<T, TArgs extends any[]>(value: Value<T, TArgs>, ...args: NoInfer<TArgs>): Promise<T extends Value<infer U, any> ? U : never>;
 
-export { clone, findDeepMatches, get, intercept, isAsyncIteratorObject, isObject, isTypescriptObject, onError, onFinish, onStart, onSuccess, once, parseEmptyableJSON, resolveMaybeOptionalOptions, splitInHalf, stringifyJSON, toArray, value };
-export type { AnyFunction, InterceptableOptions, Interceptor, InterceptorOptions, IntersectPick, MaybeOptionalOptions, OmitChainMethodDeep, OnFinishState, PromiseWithError, Registry, Segment, SetOptional, ThrowableError, Value };
+export { AsyncIdQueue, SequentialIdGenerator, clone, createAsyncIteratorObject, findDeepMatches, get, intercept, isAsyncIteratorObject, isObject, isTypescriptObject, onError, onFinish, onStart, onSuccess, once, parseEmptyableJSON, resolveMaybeOptionalOptions, sequential, splitInHalf, stringifyJSON, toArray, value };
+export type { AnyFunction, AsyncIdQueueCloseOptions, CreateAsyncIteratorObjectCleanupFn, InterceptableOptions, Interceptor, InterceptorOptions, IntersectPick, MaybeOptionalOptions, OmitChainMethodDeep, OnFinishState, PromiseWithError, Registry, Segment, SetOptional, ThrowableError, Value };

package/dist/index.mjs

@@ -23,6 +23,26 @@ function once(fn) {
     return result;
   };
 }
+function sequential(fn) {
+  let lastOperationPromise = Promise.resolve();
+  return (...args) => {
+    return lastOperationPromise = lastOperationPromise.catch(() => {
+    }).then(() => {
+      return fn(...args);
+    });
+  };
+}
+
+class SequentialIdGenerator {
+  nextId = 0;
+  generate() {
+    if (this.nextId === Number.MAX_SAFE_INTEGER) {
+      this.nextId = 0;
+      return Number.MAX_SAFE_INTEGER;
+    }
+    return this.nextId++;
+  }
+}
 
 function onStart(callback) {
   return async (options, ...rest) => {
@@ -82,6 +102,62 @@ function isAsyncIteratorObject(maybe) {
   }
   return Symbol.asyncIterator in maybe && typeof maybe[Symbol.asyncIterator] === "function";
 }
+function createAsyncIteratorObject(next, cleanup) {
+  let isExecuteComplete = false;
+  let isDone = false;
+  const iterator = {
+    next: sequential(async () => {
+      if (isDone) {
+        return { done: true, value: void 0 };
+      }
+      try {
+        const result = await next();
+        if (result.done) {
+          isDone = true;
+        }
+        return result;
+      } catch (err) {
+        isDone = true;
+        throw err;
+      } finally {
+        if (isDone && !isExecuteComplete) {
+          isExecuteComplete = true;
+          await cleanup("next");
+        }
+      }
+    }),
+    async return(value) {
+      isDone = true;
+      if (!isExecuteComplete) {
+        isExecuteComplete = true;
+        await cleanup("return");
+      }
+      return { done: true, value };
+    },
+    async throw(err) {
+      isDone = true;
+      if (!isExecuteComplete) {
+        isExecuteComplete = true;
+        await cleanup("throw");
+      }
+      throw err;
+    },
+    /**
+     * asyncDispose symbol only available in esnext, we should fallback to Symbol.for('asyncDispose')
+     */
+    async [Symbol.asyncDispose ?? Symbol.for("asyncDispose")]() {
+      isDone = true;
+      if (!isExecuteComplete) {
+        isExecuteComplete = true;
+        await cleanup("dispose");
+      }
+    },
+    [Symbol.asyncIterator]() {
+      return iterator;
+    }
+  };
+  return iterator;
+}
 
 function parseEmptyableJSON(text) {
   if (!text) {
@@ -142,6 +218,82 @@ function get(object, path) {
   return current;
 }
 
+class AsyncIdQueue {
+  openIds = /* @__PURE__ */ new Set();
+  items = /* @__PURE__ */ new Map();
+  pendingPulls = /* @__PURE__ */ new Map();
+  get length() {
+    return this.openIds.size;
+  }
+  open(id) {
+    this.openIds.add(id);
+  }
+  isOpen(id) {
+    return this.openIds.has(id);
+  }
+  push(id, item) {
+    this.assertOpen(id);
+    const pending = this.pendingPulls.get(id);
+    if (pending?.length) {
+      pending.shift()[0](item);
+      if (pending.length === 0) {
+        this.pendingPulls.delete(id);
+      }
+    } else {
+      const items = this.items.get(id);
+      if (items) {
+        items.push(item);
+      } else {
+        this.items.set(id, [item]);
+      }
+    }
+  }
+  async pull(id) {
+    this.assertOpen(id);
+    const items = this.items.get(id);
+    if (items?.length) {
+      const item = items.shift();
+      if (items.length === 0) {
+        this.items.delete(id);
+      }
+      return item;
+    }
+    return new Promise((resolve, reject) => {
+      const waitingPulls = this.pendingPulls.get(id);
+      const pending = [resolve, reject];
+      if (waitingPulls) {
+        waitingPulls.push(pending);
+      } else {
+        this.pendingPulls.set(id, [pending]);
+      }
+    });
+  }
+  close({ id, reason } = {}) {
+    if (id === void 0) {
+      this.pendingPulls.forEach((pendingPulls, id2) => {
+        pendingPulls.forEach(([, reject]) => {
+          reject(reason ?? new Error(`[AsyncIdQueue] Queue[${id2}] was closed or aborted while waiting for pulling.`));
+        });
+      });
+      this.pendingPulls.clear();
+      this.openIds.clear();
+      this.items.clear();
+      return;
+    }
+    this.pendingPulls.get(id)?.forEach(([, reject]) => {
+      reject(reason ?? new Error(`[AsyncIdQueue] Queue[${id}] was closed or aborted while waiting for pulling.`));
+    });
+    this.pendingPulls.delete(id);
+    this.openIds.delete(id);
+    this.items.delete(id);
+  }
+  assertOpen(id) {
+    if (!this.isOpen(id)) {
+      throw new Error(`[AsyncIdQueue] Cannot access queue[${id}] because it is not open or aborted.`);
+    }
+  }
+}
+
 function value(value2, ...args) {
   if (typeof value2 === "function") {
     return value2(...args);
@@ -149,4 +301,4 @@ function value(value2, ...args) {
   return value2;
 }
 
-export { clone, findDeepMatches, get, intercept, isAsyncIteratorObject, isObject, isTypescriptObject, onError, onFinish, onStart, onSuccess, once, parseEmptyableJSON, resolveMaybeOptionalOptions, splitInHalf, stringifyJSON, toArray, value };
+export { AsyncIdQueue, SequentialIdGenerator, clone, createAsyncIteratorObject, findDeepMatches, get, intercept, isAsyncIteratorObject, isObject, isTypescriptObject, onError, onFinish, onStart, onSuccess, once, parseEmptyableJSON, resolveMaybeOptionalOptions, sequential, splitInHalf, stringifyJSON, toArray, value };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/shared",
   "type": "module",
-  "version": "0.0.0-next.f81b4a2",
+  "version": "0.0.0-next.fcb9d5a",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {