@orpc/shared 0.0.0-next.10945d3 → 0.0.0-next.172fe95

package/dist/index.js

@@ -1,67 +1,92 @@
-import {
-  convertToStandardError
-} from "./chunk-CCTAECMC.js";
-
 // src/constants.ts
-var ORPC_PROTOCOL_HEADER = "x-orpc-protocol";
-var ORPC_PROTOCOL_VALUE = "orpc";
+var ORPC_HANDLER_HEADER = "x-orpc-handler";
+var ORPC_HANDLER_VALUE = "orpc";
 
-// src/hook.ts
-async function executeWithHooks(options) {
-  const executes = convertToArray(options.hooks?.execute);
-  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 = executes[currentExecuteIndex];
-    if (execute) {
-      currentExecuteIndex++;
-      return await execute(options.input, options.context, {
-        ...options.meta,
-        next
-      });
+// src/error.ts
+import { isPlainObject } from "is-what";
+function toError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "string") {
+    return new Error(error, { cause: error });
+  }
+  if (isPlainObject(error)) {
+    if ("message" in error && typeof error.message === "string") {
+      return new Error(error.message, { cause: error });
     }
-    let state = { status: "pending", input: options.input, output: void 0, error: void 0 };
-    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: convertToStandardError(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: convertToStandardError(e2), output: void 0 };
-        }
-      }
+    if ("name" in error && typeof error.name === "string") {
+      return new Error(error.name, { cause: 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: convertToStandardError(e), output: void 0 };
-      }
+  }
+  return new Error("Unknown error", { cause: error });
+}
+
+// src/function.ts
+function once(fn) {
+  let cached;
+  return () => {
+    if (cached) {
+      return cached.result;
     }
-    if (state.status === "error") {
-      throw state.error;
+    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 {
+      return await options.next();
+    } catch (error) {
+      await callback(error, options, ...rest);
+      throw error;
     }
-    return state.output;
   };
-  return await next();
 }
-function convertToArray(value2) {
-  if (value2 === void 0) {
-    return [];
-  }
-  return Array.isArray(value2) ? value2 : [value2];
+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);
+    }
+  };
+}
+async function intercept(interceptors, options, main) {
+  let index = 0;
+  const next = async (options2) => {
+    const interceptor = interceptors[index++];
+    if (!interceptor) {
+      return await main(options2);
+    }
+    return await interceptor({
+      ...options2,
+      next: (newOptions = options2) => next(newOptions)
+    });
+  };
+  return await next(options);
 }
 
 // src/json.ts
@@ -76,7 +101,7 @@ function parseJSONSafely(text) {
 }
 
 // src/object.ts
-import { isPlainObject } from "is-what";
+import { isPlainObject as isPlainObject2 } from "is-what";
 function set(root, segments, value2) {
   const ref = { root };
   let currentRef = ref;
@@ -112,39 +137,82 @@ function findDeepMatches(check, payload, segments = [], maps = [], values = [])
     payload.forEach((v, i) => {
       findDeepMatches(check, v, [...segments, i], maps, values);
     });
-  } else if (isPlainObject(payload)) {
+  } else if (isPlainObject2(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 === null;
+}
+
+// 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;
+}
 
 // src/value.ts
-function value(value2) {
+function value(value2, ...args) {
   if (typeof value2 === "function") {
-    return value2();
+    return value2(...args);
   }
   return value2;
 }
 
 // src/index.ts
-import { isPlainObject as isPlainObject2 } from "is-what";
-import { guard, mapEntries, mapValues, omit, trim } from "radash";
+import { isPlainObject as isPlainObject3 } from "is-what";
+import { group, guard, mapEntries, mapValues, omit, trim } from "radash";
 export {
-  ORPC_PROTOCOL_HEADER,
-  ORPC_PROTOCOL_VALUE,
-  convertToArray,
-  executeWithHooks,
+  ORPC_HANDLER_HEADER,
+  ORPC_HANDLER_VALUE,
+  createCallableObject,
   findDeepMatches,
   get,
+  group,
   guard,
-  isPlainObject2 as isPlainObject,
+  intercept,
+  isObject,
+  isPlainObject3 as isPlainObject,
   mapEntries,
   mapValues,
   omit,
+  onError,
+  onFinish,
+  onStart,
+  onSuccess,
+  once,
   parseJSONSafely,
   set,
+  toError,
   trim,
   value
 };

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/constants.d.ts

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

package/dist/src/error.d.ts

@@ -1,65 +1,2 @@
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-export declare const ORPC_ERROR_CODE_STATUSES: {
-    readonly BAD_REQUEST: 400;
-    readonly UNAUTHORIZED: 401;
-    readonly FORBIDDEN: 403;
-    readonly NOT_FOUND: 404;
-    readonly METHOD_NOT_SUPPORTED: 405;
-    readonly NOT_ACCEPTABLE: 406;
-    readonly TIMEOUT: 408;
-    readonly CONFLICT: 409;
-    readonly PRECONDITION_FAILED: 412;
-    readonly PAYLOAD_TOO_LARGE: 413;
-    readonly UNSUPPORTED_MEDIA_TYPE: 415;
-    readonly UNPROCESSABLE_CONTENT: 422;
-    readonly TOO_MANY_REQUESTS: 429;
-    readonly CLIENT_CLOSED_REQUEST: 499;
-    readonly INTERNAL_SERVER_ERROR: 500;
-    readonly NOT_IMPLEMENTED: 501;
-    readonly BAD_GATEWAY: 502;
-    readonly SERVICE_UNAVAILABLE: 503;
-    readonly GATEWAY_TIMEOUT: 504;
-};
-export type ORPCErrorCode = keyof typeof ORPC_ERROR_CODE_STATUSES;
-export interface ORPCErrorJSON<TCode extends ORPCErrorCode, TData> {
-    code: TCode;
-    status: number;
-    message: string;
-    data: TData;
-    issues?: readonly StandardSchemaV1.Issue[];
-}
-export type ANY_ORPC_ERROR_JSON = ORPCErrorJSON<any, any>;
-export type WELL_ORPC_ERROR_JSON = ORPCErrorJSON<ORPCErrorCode, unknown>;
-export declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
-    zz$oe: {
-        code: TCode;
-        status?: number;
-        message?: string;
-        cause?: unknown;
-        issues?: readonly StandardSchemaV1.Issue[];
-    } & (undefined extends TData ? {
-        data?: TData;
-    } : {
-        data: TData;
-    });
-    constructor(zz$oe: {
-        code: TCode;
-        status?: number;
-        message?: string;
-        cause?: unknown;
-        issues?: readonly StandardSchemaV1.Issue[];
-    } & (undefined extends TData ? {
-        data?: TData;
-    } : {
-        data: TData;
-    }));
-    get code(): TCode;
-    get status(): number;
-    get data(): TData;
-    get issues(): readonly StandardSchemaV1.Issue[] | undefined;
-    toJSON(): ORPCErrorJSON<TCode, TData>;
-    static fromJSON(json: unknown): ORPCError<ORPCErrorCode, any> | undefined;
-}
-export type WELL_ORPC_ERROR = ORPCError<ORPCErrorCode, unknown>;
-export declare function convertToStandardError(error: unknown): Error;
+export declare function toError(error: unknown): Error;
 //# sourceMappingURL=error.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,10 +1,14 @@
+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';
+export * from './types';
 export * from './value';
 export { isPlainObject } from 'is-what';
-export { guard, mapEntries, mapValues, omit, trim } from 'radash';
-export type * from 'type-fest';
+export { group, guard, mapEntries, mapValues, omit, trim } from 'radash';
+export type { IsEqual, IsNever, JsonValue, PartialDeep, Promisable } from 'type-fest';
 //# sourceMappingURL=index.d.ts.map

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,8 +1,13 @@
 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[][];
     values: unknown[];
 };
+/**
+ * Check if the value is an object.
+ * Even object created by Object.create(null) is considered an object.
+ */
+export declare function isObject(value: unknown): value is Record<string, unknown>;
 //# sourceMappingURL=object.d.ts.map

package/dist/src/proxy.d.ts

@@ -0,0 +1,3 @@
+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

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> = T | (() => Promisable<T>);
-export declare function value<T extends Value<any>>(value: T): Promise<T extends Value<infer U> ? U : never>;
+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>;
 //# sourceMappingURL=value.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/shared",
   "type": "module",
-  "version": "0.0.0-next.10945d3",
+  "version": "0.0.0-next.172fe95",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -19,11 +19,6 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
-    "./error": {
-      "types": "./dist/src/error.d.ts",
-      "import": "./dist/error.js",
-      "default": "./dist/error.js"
-    },
     "./🔒/*": {
       "types": "./dist/src/*.d.ts"
     }
@@ -34,13 +29,12 @@
     "dist"
   ],
   "dependencies": {
-    "@standard-schema/spec": "1.0.0-beta.4",
     "is-what": "^5.0.2",
     "radash": "^12.1.0",
     "type-fest": "^4.26.1"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.error=src/error.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/chunk-CCTAECMC.js

@@ -1,88 +0,0 @@
-// src/error.ts
-var ORPC_ERROR_CODE_STATUSES = {
-  BAD_REQUEST: 400,
-  UNAUTHORIZED: 401,
-  FORBIDDEN: 403,
-  NOT_FOUND: 404,
-  METHOD_NOT_SUPPORTED: 405,
-  NOT_ACCEPTABLE: 406,
-  TIMEOUT: 408,
-  CONFLICT: 409,
-  PRECONDITION_FAILED: 412,
-  PAYLOAD_TOO_LARGE: 413,
-  UNSUPPORTED_MEDIA_TYPE: 415,
-  UNPROCESSABLE_CONTENT: 422,
-  TOO_MANY_REQUESTS: 429,
-  CLIENT_CLOSED_REQUEST: 499,
-  INTERNAL_SERVER_ERROR: 500,
-  NOT_IMPLEMENTED: 501,
-  BAD_GATEWAY: 502,
-  SERVICE_UNAVAILABLE: 503,
-  GATEWAY_TIMEOUT: 504
-};
-var ORPCError = class _ORPCError extends Error {
-  constructor(zz$oe) {
-    if (zz$oe.status && (zz$oe.status < 400 || zz$oe.status >= 600)) {
-      throw new Error("The ORPCError status code must be in the 400-599 range.");
-    }
-    super(zz$oe.message, { cause: zz$oe.cause });
-    this.zz$oe = zz$oe;
-  }
-  get code() {
-    return this.zz$oe.code;
-  }
-  get status() {
-    return this.zz$oe.status ?? ORPC_ERROR_CODE_STATUSES[this.code];
-  }
-  get data() {
-    return this.zz$oe.data;
-  }
-  get issues() {
-    return this.zz$oe.issues;
-  }
-  toJSON() {
-    return {
-      code: this.code,
-      status: this.status,
-      message: this.message,
-      data: this.data,
-      issues: this.issues
-    };
-  }
-  static fromJSON(json) {
-    if (typeof json !== "object" || json === null || !("code" in json) || !Object.keys(ORPC_ERROR_CODE_STATUSES).find((key) => json.code === key) || !("status" in json) || typeof json.status !== "number" || "message" in json && json.message !== void 0 && typeof json.message !== "string" || "issues" in json && json.issues !== void 0 && !Array.isArray(json.issues)) {
-      return void 0;
-    }
-    return new _ORPCError({
-      code: json.code,
-      status: json.status,
-      message: json.message,
-      data: json.data,
-      issues: json.issues
-    });
-  }
-};
-function convertToStandardError(error) {
-  if (error instanceof Error) {
-    return error;
-  }
-  if (typeof error === "string") {
-    return new Error(error, { cause: error });
-  }
-  if (typeof error === "object" && error !== null) {
-    if ("message" in error && typeof error.message === "string") {
-      return new Error(error.message, { cause: error });
-    }
-    if ("name" in error && typeof error.name === "string") {
-      return new Error(error.name, { cause: error });
-    }
-  }
-  return new Error("Unknown error", { cause: error });
-}
-
-export {
-  ORPC_ERROR_CODE_STATUSES,
-  ORPCError,
-  convertToStandardError
-};
-//# sourceMappingURL=chunk-CCTAECMC.js.map

package/dist/error.js

@@ -1,11 +0,0 @@
-import {
-  ORPCError,
-  ORPC_ERROR_CODE_STATUSES,
-  convertToStandardError
-} from "./chunk-CCTAECMC.js";
-export {
-  ORPCError,
-  ORPC_ERROR_CODE_STATUSES,
-  convertToStandardError
-};
-//# sourceMappingURL=error.js.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> {
-    execute?: 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, unknown> & {
-    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