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

package/dist/chunk-CCTAECMC.js

@@ -0,0 +1,88 @@
+// 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,72 +1,11 @@
-// 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
-    });
-  }
-};
+import {
+  ORPCError,
+  ORPC_ERROR_CODE_STATUSES,
+  convertToStandardError
+} from "./chunk-CCTAECMC.js";
 export {
   ORPCError,
-  ORPC_ERROR_CODE_STATUSES
+  ORPC_ERROR_CODE_STATUSES,
+  convertToStandardError
 };
+//# sourceMappingURL=error.js.map

package/dist/index.js

@@ -1,3 +1,69 @@
+import {
+  convertToStandardError
+} from "./chunk-CCTAECMC.js";
+
+// src/constants.ts
+var ORPC_HANDLER_HEADER = "x-orpc-handler";
+var ORPC_HANDLER_VALUE = "orpc";
+
+// 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: 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 };
+        }
+      }
+    }
+    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 };
+      }
+    }
+    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 === "")
@@ -54,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") {
@@ -66,6 +160,11 @@ function value(value2) {
 import { isPlainObject as isPlainObject2 } from "is-what";
 import { guard, mapEntries, mapValues, omit, trim } from "radash";
 export {
+  ORPC_HANDLER_HEADER,
+  ORPC_HANDLER_VALUE,
+  convertToArray,
+  createCallableObject,
+  executeWithHooks,
   findDeepMatches,
   get,
   guard,
@@ -78,3 +177,4 @@ export {
   trim,
   value
 };
+//# sourceMappingURL=index.js.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,4 +1,4 @@
-import { type ZodIssue } from 'zod';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
 export declare const ORPC_ERROR_CODE_STATUSES: {
     readonly BAD_REQUEST: 400;
     readonly UNAUTHORIZED: 401;
@@ -21,12 +21,22 @@ export declare const ORPC_ERROR_CODE_STATUSES: {
     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;
     } : {
@@ -37,6 +47,7 @@ export declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error
         status?: number;
         message?: string;
         cause?: unknown;
+        issues?: readonly StandardSchemaV1.Issue[];
     } & (undefined extends TData ? {
         data?: TData;
     } : {
@@ -45,13 +56,10 @@ export declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error
     get code(): TCode;
     get status(): number;
     get data(): TData;
-    get issues(): ZodIssue[] | undefined;
-    toJSON(): {
-        code: TCode;
-        status: number;
-        message: string;
-        data: TData;
-        issues?: ZodIssue[];
-    };
+    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;
+//# 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,11 @@
+export * from './constants';
+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 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>;
+//# 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.fd1db03",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -29,17 +29,18 @@
     }
   },
   "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 --entry.error=src/error.ts --format=esm --onSuccess='tsc -b --noCheck'",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }