@orpc/shared 0.0.0-next.c6c659d → 0.0.0-next.caefe3a

package/dist/index.js

@@ -22,63 +22,72 @@ function toError(error) {
   return new Error("Unknown error", { cause: error });
 }
 
-// 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
-      });
+// src/function.ts
+function once(fn) {
+  let cached;
+  return () => {
+    if (cached) {
+      return cached.result;
     }
-    let state = { status: "pending", input: options.input, output: void 0, error: void 0 };
+    const result = fn();
+    cached = { result };
+    return result;
+  };
+}
+
+// src/interceptor.ts
+function onStart(callback) {
+  return async (options, ...rest) => {
+    await callback(options, ...rest);
+    return await options.next();
+  };
+}
+function onSuccess(callback) {
+  return async (options, ...rest) => {
+    const result = await options.next();
+    await callback(result, options, ...rest);
+    return result;
+  };
+}
+function onError(callback) {
+  return async (options, ...rest) => {
     try {
-      for (const onStart of onStarts) {
-        await onStart(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 };
-        }
-      }
+      return await options.next();
+    } catch (error) {
+      await callback(error, options, ...rest);
+      throw error;
     }
-    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 };
-      }
+  };
+}
+function onFinish(callback) {
+  let state;
+  return async (options, ...rest) => {
+    try {
+      const result = await options.next();
+      state = [result, void 0, "success"];
+      return result;
+    } catch (error) {
+      state = [void 0, error, "error"];
+      throw error;
+    } finally {
+      await callback(state, options, ...rest);
     }
-    if (state.status === "error") {
-      throw state.error;
+  };
+}
+async function intercept(interceptors, options, main) {
+  let index = 0;
+  const next = async (nextOptions = options) => {
+    const interceptor = interceptors[index++];
+    if (!interceptor) {
+      return await main(nextOptions);
     }
-    return state.output;
+    return await interceptor({
+      ...nextOptions,
+      next
+    });
   };
   return await next();
 }
-function convertToArray(value2) {
-  if (value2 === void 0) {
-    return [];
-  }
-  return Array.isArray(value2) ? value2 : [value2];
-}
 
 // src/json.ts
 function parseJSONSafely(text) {
@@ -178,17 +187,21 @@ import { group, guard, mapEntries, mapValues, omit, trim } from "radash";
 export {
   ORPC_HANDLER_HEADER,
   ORPC_HANDLER_VALUE,
-  convertToArray,
   createCallableObject,
-  executeWithHooks,
   findDeepMatches,
   get,
   group,
   guard,
+  intercept,
   isPlainObject3 as isPlainObject,
   mapEntries,
   mapValues,
   omit,
+  onError,
+  onFinish,
+  onStart,
+  onSuccess,
+  once,
   parseJSONSafely,
   set,
   toError,

package/dist/src/chain.d.ts

@@ -0,0 +1,5 @@
+import type { AnyFunction } from './function';
+export 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];
+};
+//# sourceMappingURL=chain.d.ts.map

package/dist/src/function.d.ts

@@ -1,2 +1,3 @@
 export type AnyFunction = (...args: any[]) => any;
+export declare function once<T extends () => any>(fn: T): () => ReturnType<T>;
 //# sourceMappingURL=function.d.ts.map

package/dist/src/index.d.ts

@@ -1,7 +1,8 @@
+export * from './chain';
 export * from './constants';
 export * from './error';
 export * from './function';
-export * from './hook';
+export * from './interceptor';
 export * from './json';
 export * from './object';
 export * from './proxy';

package/dist/src/interceptor.d.ts

@@ -0,0 +1,47 @@
+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>;
+};
+export type Interceptor<TOptions extends InterceptableOptions, TResult, TError> = (options: InterceptorOptions<TOptions, TResult>) => Promise<TResult> & {
+    __error?: {
+        type: TError;
+    };
+};
+/**
+ * Can used for interceptors or middlewares
+ */
+export declare function onStart<TOptions extends {
+    next(): any;
+}, TRest extends any[]>(callback: NoInfer<(options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => Promise<Awaited<ReturnType<TOptions['next']>>>;
+/**
+ * Can used for interceptors or middlewares
+ */
+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
+ */
+export declare function onError<TError, TOptions extends {
+    next(): any;
+}, TRest extends any[]>(callback: NoInfer<(error: TError, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => Promise<Awaited<ReturnType<TOptions['next']>>> & {
+    __error?: {
+        type: TError;
+    };
+};
+export type OnFinishState<TResult, TError> = [TResult, undefined, 'success'] | [undefined, TError, 'error'];
+/**
+ * Can used for interceptors or middlewares
+ */
+export declare function onFinish<TError, TOptions extends {
+    next(): any;
+}, TRest extends any[]>(callback: NoInfer<(state: OnFinishState<Awaited<ReturnType<TOptions['next']>>, TError>, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => Promise<Awaited<ReturnType<TOptions['next']>>> & {
+    __error?: {
+        type: TError;
+    };
+};
+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/object.d.ts

@@ -1,5 +1,5 @@
 export type Segment = string | number;
-export declare function set(root: Readonly<Record<string, unknown> | unknown[]>, segments: Readonly<Segment[]>, value: unknown): unknown;
+export declare function set(root: unknown, segments: Readonly<Segment[]>, value: unknown): unknown;
 export declare function get(root: Readonly<Record<string, unknown> | unknown[]>, segments: Readonly<Segment[]>): unknown;
 export declare function findDeepMatches(check: (value: unknown) => boolean, payload: unknown, segments?: Segment[], maps?: Segment[][], values?: unknown[]): {
     maps: Segment[][];

package/package.json

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

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