orpc-nuxt 0.5.0 → 0.6.0

package/README.md

@@ -557,19 +557,20 @@ test("renders the posts", async () => {
 })
 ```
 
-Use `createORPCError()` when a fake procedure must reproduce a declared rejection:
+The second handler argument provides typed error constructors derived from that procedure's `.errors()` map:
 
 ```ts
-import { createORPCError } from "orpc-nuxt/testing"
-
-procedures.blog.posts.update.handle(() => {
-  throw createORPCError("CONFLICT", "Already exists", { field: "title" })
+procedures.blog.posts.update.handle((input, { errors }) => {
+  if (input.title === "taken") {
+    throw errors.CONFLICT({
+      message: "Already exists",
+      data: { field: "title" },
+    })
+  }
+  return { id: 1, ...input }
 })
 ```
 
-Because this helper is standalone, it cannot infer which fake procedure will throw the error.
-Its code and data are therefore not checked against that procedure's `.errors()` map.
-
 ### Outside Vue components
 
 You can call `.useQuery()` and `.useMutation()` outside a component, for example in a script or in a test that never mounts one.

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": "^3.14.1592 || ^4.0.1"
   },
-  "version": "0.5.0",
+  "version": "0.6.0",
   "builder": {
     "@nuxt/module-builder": "1.0.3",
     "unbuild": "unknown"

package/dist/runtime/testing.d.ts

@@ -1,33 +1,35 @@
-import type { AnyNestedClient, Client, ORPCError, ORPCErrorCode } from "@orpc/client";
+import type { AnyORPCError, AnyNestedClient, Client } from "@orpc/client";
+import { ORPCError } from "@orpc/client";
 import { QueryClient } from "@tanstack/vue-query";
 import type { Mock } from "vitest";
 import type { ORPCNuxtClient, ORPCNuxtClientOptions } from "./types.js";
 type MaybePromise<T> = T | Promise<T>;
-/**
- * Create an oRPC error marked as declared for a fake client procedure.
- * The standalone helper cannot infer a specific procedure, so its code is not limited to that procedure's `.errors()` map.
- *
- * @param code - The error code exposed to the client.
- * @param message - The human-readable error message.
- * @returns An error that `isDefinedError()` and `catchORPCError()` recognize as declared.
- */
-export declare function createORPCError<Code extends ORPCErrorCode>(code: Code, message: string): ORPCError<Code, undefined>;
-/**
- * Create an oRPC error with typed data marked as declared for a fake client procedure.
- * The standalone helper cannot infer a specific procedure, so its code and data are not checked against that procedure's `.errors()` map.
- *
- * @param code - The error code exposed to the client.
- * @param message - The human-readable error message.
- * @param data - Error data exposed to the client.
- * @returns An error that `isDefinedError()` and `catchORPCError()` recognize as declared.
- */
-export declare function createORPCError<Code extends ORPCErrorCode, Data>(code: Code, message: string, data: Data): ORPCError<Code, Data>;
+type ProcedureError<TProcedure> = TProcedure extends Client<any, any, any, infer Error> ? Extract<Error, AnyORPCError> : never;
+type ErrorConstructorOptions<Data> = ErrorOptions & {
+    message?: string;
+} & (undefined extends Data ? {
+    data?: Data;
+} : {
+    data: Data;
+});
+type ErrorConstructor<ErrorType extends AnyORPCError> = ErrorType extends ORPCError<infer _Code, infer Data> ? (...args: undefined extends Data ? [options?: ErrorConstructorOptions<Data>] : [options: ErrorConstructorOptions<Data>]) => ErrorType : never;
+type TestORPCErrors<TProcedure> = {
+    [Code in ProcedureError<TProcedure>["code"] & string]: ErrorConstructor<Extract<ProcedureError<TProcedure>, {
+        code: Code;
+    }>>;
+};
+/** Error constructors derived from the procedure's declared error union. */
+export interface TestORPCHandlerOptions<TProcedure> {
+    /** Construct an error declared by this procedure, with its corresponding data type. */
+    errors: TestORPCErrors<TProcedure>;
+}
 /** A procedure implementation registered for a test client. */
-export type TestORPCHandler<TProcedure> = TProcedure extends Client<infer _Context, infer Input, infer Output, infer _Error> ? (input: Input) => MaybePromise<Awaited<Output>> : never;
+export type TestORPCHandler<TProcedure> = TProcedure extends Client<infer _Context, infer Input, infer Output, infer _Error> ? (input: Input, options: TestORPCHandlerOptions<TProcedure>) => MaybePromise<Awaited<Output>> : never;
+type TestORPCMockHandler<TProcedure> = TProcedure extends Client<infer _Context, infer Input, infer Output, infer _Error> ? (input: Input) => MaybePromise<Awaited<Output>> : never;
 /** Registration methods for one procedure in a test client. */
 export interface TestORPCProcedure<TProcedure> {
     /** Register the implementation used by subsequent calls and return its Vitest mock. */
-    handle(handler: TestORPCHandler<TProcedure>): Mock<TestORPCHandler<TProcedure>>;
+    handle(handler: TestORPCHandler<TProcedure>): Mock<TestORPCMockHandler<TProcedure>>;
 }
 /** A router-shaped tree whose procedure leaves register test implementations. */
 export type TestORPCProcedures<T extends AnyNestedClient> = T extends Client<infer Context, infer Input, infer Output, infer Error> ? TestORPCProcedure<Client<Context, Input, Output, Error>> : {

package/dist/runtime/testing.js

@@ -1,10 +1,7 @@
-import { createORPCClient, createORPCErrorFromJson } from "@orpc/client";
+import { createORPCClient, createORPCErrorFromJson, ORPCError } from "@orpc/client";
 import { QueryClient } from "@tanstack/vue-query";
 import { vi } from "vitest";
 import { createORPCNuxtClient } from "./client/create.js";
-export function createORPCError(code, message, data) {
-  return createORPCErrorFromJson({ defined: true, code, message, data });
-}
 export function createTestORPCClient(options = {}) {
   const registrations = /* @__PURE__ */ new Map();
   const queryClient = options.queryClient ?? new QueryClient({
@@ -14,7 +11,8 @@ export function createTestORPCClient(options = {}) {
     }
   });
   function registerHandler(path, handler) {
-    const mock = vi.fn(handler);
+    const options2 = { errors: createErrorConstructors() };
+    const mock = vi.fn((input) => handler(input, options2));
     registrations.set(path, mock);
     return mock;
   }
@@ -53,6 +51,22 @@ export function createTestORPCClient(options = {}) {
     }
   };
 }
+function createErrorConstructors() {
+  const constructors = /* @__PURE__ */ new Map();
+  return new Proxy(/* @__PURE__ */ Object.create(null), {
+    get(target, property, receiver) {
+      if (typeof property !== "string") return Reflect.get(target, property, receiver);
+      const cached = constructors.get(property);
+      if (cached) return cached;
+      const constructor = (options) => {
+        const error = new ORPCError(property, options);
+        return createORPCErrorFromJson({ ...error.toJSON(), defined: true }, { cause: error.cause });
+      };
+      constructors.set(property, constructor);
+      return constructor;
+    }
+  });
+}
 function createRecursiveProxy(path, call) {
   const target = () => {
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orpc-nuxt",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "oRPC integration for Nuxt with TanStack Vue Query composables.",
   "homepage": "https://github.com/IlyaSemenov/orpc-nuxt#readme",
   "bugs": "https://github.com/IlyaSemenov/orpc-nuxt/issues",