@orpc/shared 0.0.0-next.ef3ba82 → 0.0.0-next.f56d2b3

package/dist/index.js

@@ -1,3 +1,85 @@
+// src/constants.ts
+var ORPC_HANDLER_HEADER = "x-orpc-handler";
+var ORPC_HANDLER_VALUE = "orpc";
+
+// 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 });
+    }
+    if ("name" in error && typeof error.name === "string") {
+      return new Error(error.name, { cause: 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
+      });
+    }
+    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: 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/json.ts
 function parseJSONSafely(text) {
   if (text === "")
@@ -10,7 +92,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;
@@ -46,7 +128,7 @@ 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);
     }
@@ -54,27 +136,63 @@ 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) {
+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_HANDLER_HEADER,
+  ORPC_HANDLER_VALUE,
+  convertToArray,
+  createCallableObject,
+  executeWithHooks,
   findDeepMatches,
   get,
+  group,
   guard,
-  isPlainObject2 as isPlainObject,
+  isPlainObject3 as isPlainObject,
   mapEntries,
   mapValues,
   omit,
   parseJSONSafely,
   set,
+  toError,
   trim,
   value
 };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,3 @@
+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,57 +1,2 @@
-import { type ZodIssue } from 'zod';
-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 declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
-    zz$oe: {
-        code: TCode;
-        status?: number;
-        message?: string;
-        cause?: unknown;
-    } & (undefined extends TData ? {
-        data?: TData;
-    } : {
-        data: TData;
-    });
-    constructor(zz$oe: {
-        code: TCode;
-        status?: number;
-        message?: string;
-        cause?: unknown;
-    } & (undefined extends TData ? {
-        data?: TData;
-    } : {
-        data: TData;
-    }));
-    get code(): TCode;
-    get status(): number;
-    get data(): TData;
-    get issues(): ZodIssue[] | undefined;
-    toJSON(): {
-        code: TCode;
-        status: number;
-        message: string;
-        data: TData;
-        issues?: ZodIssue[];
-    };
-    static fromJSON(json: unknown): ORPCError<ORPCErrorCode, any> | undefined;
-}
+export declare function toError(error: unknown): Error;
+//# sourceMappingURL=error.d.ts.map

package/dist/src/function.d.ts

@@ -0,0 +1,2 @@
+export type AnyFunction = (...args: any[]) => any;
+//# sourceMappingURL=function.d.ts.map

package/dist/src/hook.d.ts

@@ -0,0 +1,42 @@
+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/index.d.ts

@@ -1,6 +1,13 @@
+export * from './chain';
+export * from './constants';
+export * from './error';
+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';
+export { group, guard, mapEntries, mapValues, omit, trim } from 'radash';
 export type * from 'type-fest';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/json.d.ts

@@ -1 +1,2 @@
 export declare function parseJSONSafely(text: string): unknown;
+//# sourceMappingURL=json.d.ts.map

package/dist/src/object.d.ts

@@ -5,3 +5,4 @@ export declare function findDeepMatches(check: (value: unknown) => boolean, payl
     maps: Segment[][];
     values: 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/value.d.ts

@@ -1,3 +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.ef3ba82",
+  "version": "0.0.0-next.f56d2b3",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -19,27 +19,23 @@
       "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"
     }
   },
   "files": [
-    "!dist/*.tsbuildinfo",
+    "!**/*.map",
+    "!**/*.tsbuildinfo",
     "dist"
   ],
   "dependencies": {
+    "@standard-schema/spec": "1.0.0-beta.4",
     "is-what": "^5.0.2",
     "radash": "^12.1.0",
-    "type-fest": "^4.26.1",
-    "zod": "^3.23.8"
+    "type-fest": "^4.26.1"
   },
   "scripts": {
-    "build": "tsup --clean --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/error.js

@@ -1,72 +0,0 @@
-// src/error.ts
-import { ZodError } from "zod";
-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() {
-    if (this.code === "BAD_REQUEST" && this.zz$oe.cause instanceof ZodError) {
-      return this.zz$oe.cause.issues;
-    }
-    return void 0;
-  }
-  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: Reflect.get(json, "message"),
-      data: Reflect.get(json, "data"),
-      cause: "issues" in json ? new ZodError(json.issues) : void 0
-    });
-  }
-};
-export {
-  ORPCError,
-  ORPC_ERROR_CODE_STATUSES
-};