@orpc/shared 0.0.0-next.ee0aeaf → 0.0.0-next.fd1db03

package/dist/index.js

@@ -3,19 +3,19 @@ import {
 } 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 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 = executes[currentExecuteIndex];
+    const execute = interceptors[currentExecuteIndex];
     if (execute) {
       currentExecuteIndex++;
       return await execute(options.input, options.context, {
@@ -120,6 +120,34 @@ function findDeepMatches(check, payload, segments = [], maps = [], values = [])
   return { maps, values };
 }
 
+// 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) {
   if (typeof value2 === "function") {
@@ -132,9 +160,10 @@ function value(value2) {
 import { isPlainObject as isPlainObject2 } from "is-what";
 import { guard, mapEntries, mapValues, omit, trim } from "radash";
 export {
-  ORPC_PROTOCOL_HEADER,
-  ORPC_PROTOCOL_VALUE,
+  ORPC_HANDLER_HEADER,
+  ORPC_HANDLER_VALUE,
   convertToArray,
+  createCallableObject,
   executeWithHooks,
   findDeepMatches,
   get,

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

@@ -23,13 +23,13 @@ export interface BaseHookMeta<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>>;
+    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, unknown> & {
+export declare function executeWithHooks<TInput, TOutput, TContext, TMeta extends (Record<string, any> & {
     next?: never;
 }) | undefined>(options: {
     hooks?: Hooks<TInput, TOutput, TContext, TMeta>;

package/dist/src/index.d.ts

@@ -3,6 +3,7 @@ export * from './function';
 export * from './hook';
 export * from './json';
 export * from './object';
+export * from './proxy';
 export * from './value';
 export { isPlainObject } from 'is-what';
 export { guard, mapEntries, mapValues, omit, trim } from 'radash';

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/package.json

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