@arrirpc/server 0.70.1 → 0.71.0

package/README.md

@@ -2,28 +2,36 @@
 
 Typescript implementation of [Arri RPC](/README.md). It's built on top of [H3](https://github.com/unjs/h3) and uses [esbuild](https://esbuild.github.io/) for bundling.
 
-Parameters and responses are defined using [@arrirpc/schema](/tooling/schema/README.md) for automatic validation and serialization of inputs and outputs and to generate Arri Type Definitions for client generators.
+Parameters and responses are defined using [@arrirpc/schema](/languages/ts/ts-schema/README.md) for automatic validation and serialization of inputs and outputs and to generate Arri Type Definitions for client generators.
+
+## Related Libraries
+
+| Name                                                            | Description                                                                                                                                              |
+| --------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [arri](/tooling/cli/README.md)                                  | The Arri CLI                                                                                                                                             |
+| [@arrirpc/schema](/languages/ts/ts-schema/README.md)            | High performance validation library used to define the inputs and outputs of procedures. Can also be used standalone as a generic TS validation library. |
+| [@arrirpc/eslint-plugin](/languages/ts/eslint-plugin/README.md) | Eslint rules for Arri RPC                                                                                                                                |
 
 ## Table of Contents
 
--   [Quickstart](#quickstart)
--   [Manual Setup](#manual-setup)
-    -   [Install Dependencies](#install-dependencies)
-    -   [Scaffold Your Project](#scaffold-your-project)
--   [Usage](#usage)
-    -   [Creating Procedures](#creating-procedures)
-        -   [File-Based Routing](#file-based-routing)
-        -   [Manual Routing](#manual-routing)
-        -   [Creating Event Stream Procedures](#creating-event-stream-procedures)
-        -   [Creating Websocket Procedures](#creating-websocket-procedures-experimental)
-            -   [Adding to the RPC Context](#adding-to-the-rpc-context)
-    -   [Adding Non-RPC Routes](#adding-non-rpc-routes)
-    -   [Adding Middleware](#adding-middleware)
--   [Key Concepts](#key-concepts)
-    -   [Arri Definition File](#arri-definition-file)
-    -   [How Procedures Map To Endpoints](#how-procedures-map-to-endpoints)
-    -   [H3 Support](#h3-support)
--   [Arri CLI](#arri-cli)
+- [Quickstart](#quickstart)
+- [Manual Setup](#manual-setup)
+    - [Install Dependencies](#install-dependencies)
+    - [Scaffold Your Project](#scaffold-your-project)
+- [Usage](#usage)
+    - [Creating Procedures](#creating-procedures)
+        - [File-Based Routing](#file-based-routing)
+        - [Manual Routing](#manual-routing)
+        - [Creating Event Stream Procedures](#creating-event-stream-procedures)
+        - [Creating Websocket Procedures](#creating-websocket-procedures-experimental)
+            - [Adding to the RPC Context](#adding-to-the-rpc-context)
+    - [Adding Non-RPC Routes](#adding-non-rpc-routes)
+    - [Adding Middleware](#adding-middleware)
+- [Key Concepts](#key-concepts)
+    - [Arri Definition File](#arri-definition-file)
+    - [How Procedures Map To Endpoints](#how-procedures-map-to-endpoints)
+    - [H3 Support](#h3-support)
+- [Arri CLI](#arri-cli)
 
 ## Quickstart
 
@@ -47,10 +55,12 @@ pnpm run dev
 
 ```bash
 # npm
-npm install arri @arrirpc/server @arrirpc/schema
+npm install -D arri
+npm install @arrirpc/server @arrirpc/schema
 
 # pnpm
-pnpm install arri @arrirpc/server @arrirpc/schema
+pnpm install -D arri
+pnpm install @arrirpc/server @arrirpc/schema
 ```
 
 ### Scaffold Your Project
@@ -84,7 +94,7 @@ Create an `arri.config.ts` in the project directory
 
 ```ts
 // arri.config.ts
-import { defineConfig, servers, generators } from "arri";
+import { defineConfig, servers, generators } from 'arri';
 
 export default defineConfig({
     server: servers.tsServer(),
@@ -105,7 +115,7 @@ Create an app entry file in your src directory. The name of the file must match
 
 ```ts
 // ./src/app.ts
-import { ArriApp } from "arri";
+import { ArriApp } from 'arri';
 
 const app = new ArriApp();
 
@@ -154,8 +164,8 @@ Example `.rpc.ts` file
 
 ```ts
 // ./src/users/getUser.rpc.ts
-import { defineRpc } from "@arrirpc/server";
-import { a } from "@arrirpc/schema";
+import { defineRpc } from '@arrirpc/server';
+import { a } from '@arrirpc/schema';
 
 export default defineRpc({
     params: a.object({
@@ -177,8 +187,8 @@ export default defineRpc({
 ```ts
 export default defineConfig({
     servers: servers.tsServer({
-        procedureDir: "procedures", // change which directory to look for procedures (This is relative to the srcDir)
-        procedureGlobPatterns: ["**/*.rpc.ts"], // change the file name glob pattern for finding rpcs
+        procedureDir: 'procedures', // change which directory to look for procedures (This is relative to the srcDir)
+        procedureGlobPatterns: ['**/*.rpc.ts'], // change the file name glob pattern for finding rpcs
     }),
     // rest of config
 });
@@ -221,23 +231,23 @@ Event stream procedures make use of [Server Sent Events](https://developer.mozil
 
 Arri Event streams sent the following event types:
 
--   `message` - A standard message with the response data serialized as JSON
--   `done` - A message to tell clients that there will be no more events
--   `ping` - A message periodically sent by the server to keep the connection alive.
+- `message` - A standard message with the response data serialized as JSON
+- `done` - A message to tell clients that there will be no more events
+- `ping` - A message periodically sent by the server to keep the connection alive.
 
 ```ts
 /// message event ///
 id: string | undefined;
-event: "message";
+event: 'message';
 data: Response; // whatever you have specified as the response serialized to json
 
 /// done event ///
-event: "done";
-data: "this stream has ended";
+event: 'done';
+data: 'this stream has ended';
 
 /// ping event ///
-event: "ping";
-data: "";
+event: 'ping';
+data: '';
 ```
 
 ##### Example Usage:
@@ -261,15 +271,15 @@ export default defineEventStreamRpc({
         // send a message every second
         const interval = setInterval(async () => {
             await stream.push({
-                id: "1",
-                name: "John Doe",
+                id: '1',
+                name: 'John Doe',
                 createdAt: new Date(),
                 updatedAt: new Date(),
             });
         }, 1000);
 
         // cleanup when the client disconnects
-        stream.on("close", () => {
+        stream.on('close', () => {
             clearInterval(interval);
         });
     },
@@ -412,12 +422,12 @@ const authMiddleware = defineMiddleware(async (event) => {
     // assume you did something to get the user from the request
     event.context.user = {
         id: 1,
-        name: "John Doe",
-        email: "johndoe@gmail.com",
+        name: 'John Doe',
+        email: 'johndoe@gmail.com',
     };
 });
 
-app.rpc("sayHello", {
+app.rpc('sayHello', {
     params: undefined,
     response: a.object({
         message: a.string(),
@@ -434,9 +444,9 @@ app.rpc("sayHello", {
 To get type safety for these new properties create a `.d.ts` file and augment the `ArriEventContext` provided by `@arrirpc/server`
 
 ```ts
-import "@arrirpc/server";
+import '@arrirpc/server';
 
-declare module "@arrirpc/server" {
+declare module '@arrirpc/server' {
     interface ArriEventContext {
         user?: {
             id: number;
@@ -538,18 +548,18 @@ By default all procedures will become post requests, but you can change this whe
 ```ts
 // procedures/users/getUser.rpc.ts
 export default defineRpc({
-    method: "get",
+    method: 'get',
     // rest of config
 });
 ```
 
 The supported HTTP methods are as follows:
 
--   post
--   get
--   delete
--   patch
--   put
+- post
+- get
+- delete
+- patch
+- put
 
 When using a get method the RPC params will be mapped as query parameters which will be coerced into their type using the `a.coerce` method from `arri-validate`. Get methods support all basic scalar types however arrays and nested objects are not supported.
 
@@ -562,7 +572,7 @@ Arri is built on top of [H3](https://h3.unjs.io/utils/request#getrequestipevent)
 Arri re-eports all of the H3 utilities.
 
 ```ts
-import { getRequestIP, setResponseHeader } from "@arrirpc/server";
+import { getRequestIP, setResponseHeader } from '@arrirpc/server';
 ```
 
 #### Accessing H3 Events
@@ -592,8 +602,8 @@ defineEventStreamRpc({
 Arri server is just an H3 app under the hood so you can start it the same way you would start an H3 app. Although you should note that currently the filed based router only works when using the Arri CLI.
 
 ```ts
-import { createServer } from "node:http";
-import { ArriApp, toNodeListener } from "@arrirpc/server";
+import { createServer } from 'node:http';
+import { ArriApp, toNodeListener } from '@arrirpc/server';
 
 const app = new ArriApp();
 

package/dist/index.cjs

@@ -273,7 +273,7 @@ function createHttpRpcDefinition(rpcName, httpPath, procedure) {
     params: getRpcParamName(rpcName, procedure),
     response: getRpcResponseDefinition(rpcName, procedure),
     isDeprecated: procedure.isDeprecated,
-    isEventStream: procedure.isEventStream === true ? true : void 0
+    isEventStream: procedure.isEventStream === true ? true : undefined
   };
 }
 function getRpcPath(rpcName, prefix = "") {
@@ -288,7 +288,7 @@ function getRpcPath(rpcName, prefix = "") {
 }
 function getRpcParamName(rpcName, procedure) {
   if (!isRpcParamSchema(procedure.params)) {
-    return void 0;
+    return undefined;
   }
   const nameParts = rpcName.split(".").map(
     (part) => codegenUtils.removeDisallowedChars(part, `!@#$%^&*()+=[]{}|\\;:'"<>,./?`)
@@ -298,7 +298,7 @@ function getRpcParamName(rpcName, procedure) {
 }
 function getRpcResponseName(rpcName, procedure) {
   if (!isRpcParamSchema(procedure.response)) {
-    return void 0;
+    return undefined;
   }
   const nameParts = rpcName.split(".").map(
     (part) => codegenUtils.removeDisallowedChars(part, `!@#$%^&*()+=[]{}|\\;:'"<>,./?`)
@@ -308,17 +308,17 @@ function getRpcResponseName(rpcName, procedure) {
 }
 function getRpcResponseDefinition(rpcName, procedure) {
   if (!isRpcParamSchema(procedure.response)) {
-    return void 0;
+    return undefined;
   }
   const name = getRpcResponseName(rpcName, procedure);
   if (!name) {
-    return void 0;
+    return undefined;
   }
   return name;
 }
 function registerRpc(router, path, procedure, opts) {
-  const paramValidator = procedure.params ? getSchemaValidator(procedure.name, "params", procedure.params) : void 0;
-  const responseValidator = procedure.response ? getSchemaValidator(procedure.name, "response", procedure.response) : void 0;
+  const paramValidator = procedure.params ? getSchemaValidator(procedure.name, "params", procedure.params) : undefined;
+  const responseValidator = procedure.response ? getSchemaValidator(procedure.name, "response", procedure.response) : undefined;
   const httpMethod = procedure.method ?? "post";
   const handler = h3.eventHandler(async (event) => {
     event.context.rpcName = procedure.name;
@@ -469,7 +469,7 @@ function getSchemaValidator(rpcName, type, schema$1) {
     return schema.a.compile(schema$1);
   } catch (_) {
     console.error(`Error compiling ${type} validator for ${rpcName}`);
-    return void 0;
+    return undefined;
   }
 }
 
@@ -490,7 +490,7 @@ class EventStreamConnection {
   validator;
   serializer;
   // for some reason Rollup cannot output DTS when this is set to NodeJS.Timeout
-  pingInterval = void 0;
+  pingInterval = undefined;
   pingIntervalMs;
   eventStream;
   constructor(event, opts) {
@@ -573,8 +573,8 @@ class EventStreamConnection {
   }
 }
 function registerEventStreamRpc(router, path, procedure, opts) {
-  const paramValidator = procedure.params ? getSchemaValidator(procedure.name, "params", procedure.params) : void 0;
-  const responseValidator = procedure.response ? getSchemaValidator(procedure.name, "response", procedure.response) : void 0;
+  const paramValidator = procedure.params ? getSchemaValidator(procedure.name, "params", procedure.params) : undefined;
+  const responseValidator = procedure.response ? getSchemaValidator(procedure.name, "response", procedure.response) : undefined;
   const httpMethod = procedure.method ?? "get";
   const handler = h3.eventHandler(async (event) => {
     event.context.rpcName = procedure.name;

package/dist/index.d.cts

@@ -55,9 +55,9 @@ declare const arriErrorResponse: AObjectSchema<{
     data?: any;
 }>;
 type arriErrorResponse = a.infer<typeof arriErrorResponse>;
-declare function defineError(statusCode: StatusCode, input?: Partial<Omit<arriErrorResponse, "code" | "stack">>): arriError;
-declare function errorResponseFromValidationErrors(errors: ValidationError["errors"], prefixText?: string): H3Error;
-declare function handleH3Error(err: unknown, event: H3Event, onError: ArriOptions["onError"], debug: boolean): Promise<void>;
+declare function defineError(statusCode: StatusCode, input?: Partial<Omit<arriErrorResponse, 'code' | 'stack'>>): arriError;
+declare function errorResponseFromValidationErrors(errors: ValidationError['errors'], prefixText?: string): H3Error;
+declare function handleH3Error(err: unknown, event: H3Event, onError: ArriOptions['onError'], debug: boolean): Promise<void>;
 
 interface RouteEvent<TPath extends string, TQuery extends Record<any, any> = any, TBody = any> extends H3Event {
     context: RouteEventContext<TPath, TQuery, TBody>;
@@ -74,7 +74,7 @@ interface ArriRoute<TPath extends string, TQuery extends AObjectSchema<any, any>
     postHandler?: (event: PostRouteEvent<TPath, InferType<TQuery>, InferType<TBody>, Awaited<TResponse>>) => any;
 }
 declare function defineRoute<TPath extends string, TQuery extends AObjectSchema<any, any> = any, TBody extends AObjectSchema<any, any> = any, TResponse = any>(route: ArriRoute<TPath, TQuery, TBody, TResponse>): ArriRoute<TPath, TQuery, TBody, TResponse>;
-type RouteOptions = Pick<ArriOptions, "onAfterResponse" | "onBeforeResponse" | "onError" | "onRequest" | "debug"> & {
+type RouteOptions = Pick<ArriOptions, 'onAfterResponse' | 'onBeforeResponse' | 'onError' | 'onRequest' | 'debug'> & {
     middleware: Middleware[];
 };
 declare function registerRoute(router: Router, route: ArriRoute<any>, opts: RouteOptions): void;
@@ -91,9 +91,9 @@ declare class ArriRouter {
     getDefinitions(): DefinitionMap;
 }
 
-declare function defineEventStreamRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined | never = undefined>(config: Omit<EventStreamRpc<TParams, TResponse>, "isEventStream" | "transport">): EventStreamRpc<TParams, TResponse>;
+declare function defineEventStreamRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined | never = undefined>(config: Omit<EventStreamRpc<TParams, TResponse>, 'isEventStream' | 'transport'>): EventStreamRpc<TParams, TResponse>;
 declare function isEventStreamRpc(input: unknown): input is EventStreamRpc<any, any>;
-interface EventStreamRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> extends Omit<HttpRpc<true, TParams, TResponse>, "handler" | "postHandler"> {
+interface EventStreamRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> extends Omit<HttpRpc<true, TParams, TResponse>, 'handler' | 'postHandler'> {
     isEventStream: true;
     handler: EventStreamRpcHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : undefined>;
 }
@@ -146,7 +146,7 @@ interface NamedWebsocketRpc<TParams extends RpcParamSchema | undefined = undefin
     name: string;
 }
 interface WebsocketRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> {
-    transport: "ws";
+    transport: 'ws';
     description?: string;
     path?: string;
     isDeprecated?: boolean;
@@ -189,7 +189,7 @@ interface WebSocketRpcHandler<TParams, TResponse> {
 /**
  * @experimental
  */
-declare function defineWebsocketRpc<TParams extends RpcParamSchema | undefined, TResponse extends RpcParamSchema | undefined>(def: Omit<WebsocketRpc<TParams, TResponse>, "transport">): WebsocketRpc<TParams, TResponse>;
+declare function defineWebsocketRpc<TParams extends RpcParamSchema | undefined, TResponse extends RpcParamSchema | undefined>(def: Omit<WebsocketRpc<TParams, TResponse>, 'transport'>): WebsocketRpc<TParams, TResponse>;
 /**
  * @experimental
  */
@@ -206,7 +206,7 @@ interface NamedHttpRpc<TIsEventStream extends boolean = false, TParams extends R
 }
 type Rpc<TIsEventStream extends boolean = false, TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> = HttpRpc<TIsEventStream, TParams, TResponse> | WebsocketRpc<TParams, TResponse>;
 interface HttpRpc<TIsEventStream extends boolean = false, TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> {
-    transport: "http";
+    transport: 'http';
     method?: RpcHttpMethod;
     path?: string;
     description?: string;
@@ -218,23 +218,23 @@ interface HttpRpc<TIsEventStream extends boolean = false, TParams extends RpcPar
     handler: TIsEventStream extends true ? EventStreamRpcHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : undefined> : RpcHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : void>;
     postHandler?: TIsEventStream extends true ? undefined : RpcPostHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : undefined>;
 }
-interface RpcEvent<TParams = undefined> extends Omit<H3Event, "context"> {
+interface RpcEvent<TParams = undefined> extends Omit<H3Event, 'context'> {
     context: RpcEventContext<TParams>;
 }
-interface RpcPostEvent<TParams = undefined, TResponse = undefined> extends Omit<H3Event, "context"> {
+interface RpcPostEvent<TParams = undefined, TResponse = undefined> extends Omit<H3Event, 'context'> {
     context: RpcPostEventContext<TParams, TResponse>;
 }
 type RpcHandler<TParams, TResponse> = (context: RpcEventContext<TParams>, event: RpcEvent<TParams>) => TResponse | Promise<TResponse>;
 type RpcPostHandler<TParams, TResponse> = (context: RpcPostEventContext<TParams, TResponse>, event: RpcPostEvent<TParams, TResponse>) => any;
 declare function isRpc(input: unknown): input is HttpRpc<any, any>;
-declare function defineRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined | never = undefined>(config: Omit<HttpRpc<false, TParams, TResponse>, "transport" | "isEventStream">): HttpRpc<false, TParams, TResponse>;
+declare function defineRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined | never = undefined>(config: Omit<HttpRpc<false, TParams, TResponse>, 'transport' | 'isEventStream'>): HttpRpc<false, TParams, TResponse>;
 declare function createHttpRpcDefinition(rpcName: string, httpPath: string, procedure: HttpRpc<any, any, any>): HttpRpcDefinition;
 declare function getRpcPath(rpcName: string, prefix?: string): string;
 declare function getRpcParamName(rpcName: string, procedure: HttpRpc<any, any, any> | WebsocketRpc<any, any>): string | undefined;
 declare function getRpcResponseName(rpcName: string, procedure: HttpRpc<any, any, any> | WebsocketRpc<any, any>): string | undefined;
 declare function registerRpc(router: Router, path: string, procedure: NamedHttpRpc<any, any, any>, opts: RouteOptions): void;
 declare function validateRpcRequestInput(event: H3Event, httpMethod: RpcHttpMethod, schema: ASchema, validator: ReturnType<typeof a.compile>): Promise<void>;
-declare function getSchemaValidator(rpcName: string, type: "params" | "response", schema: ASchema<any>): ReturnType<typeof a.compile> | undefined;
+declare function getSchemaValidator(rpcName: string, type: 'params' | 'response', schema: ASchema<any>): ReturnType<typeof a.compile> | undefined;
 
 declare class ArriService {
     name: string;
@@ -256,7 +256,7 @@ declare class ArriApp {
     readonly h3Router: Router;
     private readonly _rpcDefinitionPath;
     private readonly _rpcRoutePrefix;
-    appInfo: AppDefinition["info"];
+    appInfo: AppDefinition['info'];
     private _procedures;
     private _definitions;
     private readonly _middlewares;
@@ -280,7 +280,7 @@ interface ArriOptions {
     /**
      * Metadata to display in the __definition.json file
      */
-    appInfo?: AppDefinition["info"];
+    appInfo?: AppDefinition['info'];
     rpcRoutePrefix?: string;
     /**
      * Defaults to /__definitions
@@ -294,7 +294,7 @@ interface ArriOptions {
     onBeforeResponse?: (event: RequestHookEvent) => void | Promise<void>;
     onError?: (error: arriError, event: RequestHookEvent) => void | Promise<void>;
 }
-interface RequestHookEvent extends Omit<H3Event, "context"> {
+interface RequestHookEvent extends Omit<H3Event, 'context'> {
     context: RequestHookContext;
 }
 

package/dist/index.d.mts

@@ -55,9 +55,9 @@ declare const arriErrorResponse: AObjectSchema<{
     data?: any;
 }>;
 type arriErrorResponse = a.infer<typeof arriErrorResponse>;
-declare function defineError(statusCode: StatusCode, input?: Partial<Omit<arriErrorResponse, "code" | "stack">>): arriError;
-declare function errorResponseFromValidationErrors(errors: ValidationError["errors"], prefixText?: string): H3Error;
-declare function handleH3Error(err: unknown, event: H3Event, onError: ArriOptions["onError"], debug: boolean): Promise<void>;
+declare function defineError(statusCode: StatusCode, input?: Partial<Omit<arriErrorResponse, 'code' | 'stack'>>): arriError;
+declare function errorResponseFromValidationErrors(errors: ValidationError['errors'], prefixText?: string): H3Error;
+declare function handleH3Error(err: unknown, event: H3Event, onError: ArriOptions['onError'], debug: boolean): Promise<void>;
 
 interface RouteEvent<TPath extends string, TQuery extends Record<any, any> = any, TBody = any> extends H3Event {
     context: RouteEventContext<TPath, TQuery, TBody>;
@@ -74,7 +74,7 @@ interface ArriRoute<TPath extends string, TQuery extends AObjectSchema<any, any>
     postHandler?: (event: PostRouteEvent<TPath, InferType<TQuery>, InferType<TBody>, Awaited<TResponse>>) => any;
 }
 declare function defineRoute<TPath extends string, TQuery extends AObjectSchema<any, any> = any, TBody extends AObjectSchema<any, any> = any, TResponse = any>(route: ArriRoute<TPath, TQuery, TBody, TResponse>): ArriRoute<TPath, TQuery, TBody, TResponse>;
-type RouteOptions = Pick<ArriOptions, "onAfterResponse" | "onBeforeResponse" | "onError" | "onRequest" | "debug"> & {
+type RouteOptions = Pick<ArriOptions, 'onAfterResponse' | 'onBeforeResponse' | 'onError' | 'onRequest' | 'debug'> & {
     middleware: Middleware[];
 };
 declare function registerRoute(router: Router, route: ArriRoute<any>, opts: RouteOptions): void;
@@ -91,9 +91,9 @@ declare class ArriRouter {
     getDefinitions(): DefinitionMap;
 }
 
-declare function defineEventStreamRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined | never = undefined>(config: Omit<EventStreamRpc<TParams, TResponse>, "isEventStream" | "transport">): EventStreamRpc<TParams, TResponse>;
+declare function defineEventStreamRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined | never = undefined>(config: Omit<EventStreamRpc<TParams, TResponse>, 'isEventStream' | 'transport'>): EventStreamRpc<TParams, TResponse>;
 declare function isEventStreamRpc(input: unknown): input is EventStreamRpc<any, any>;
-interface EventStreamRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> extends Omit<HttpRpc<true, TParams, TResponse>, "handler" | "postHandler"> {
+interface EventStreamRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> extends Omit<HttpRpc<true, TParams, TResponse>, 'handler' | 'postHandler'> {
     isEventStream: true;
     handler: EventStreamRpcHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : undefined>;
 }
@@ -146,7 +146,7 @@ interface NamedWebsocketRpc<TParams extends RpcParamSchema | undefined = undefin
     name: string;
 }
 interface WebsocketRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> {
-    transport: "ws";
+    transport: 'ws';
     description?: string;
     path?: string;
     isDeprecated?: boolean;
@@ -189,7 +189,7 @@ interface WebSocketRpcHandler<TParams, TResponse> {
 /**
  * @experimental
  */
-declare function defineWebsocketRpc<TParams extends RpcParamSchema | undefined, TResponse extends RpcParamSchema | undefined>(def: Omit<WebsocketRpc<TParams, TResponse>, "transport">): WebsocketRpc<TParams, TResponse>;
+declare function defineWebsocketRpc<TParams extends RpcParamSchema | undefined, TResponse extends RpcParamSchema | undefined>(def: Omit<WebsocketRpc<TParams, TResponse>, 'transport'>): WebsocketRpc<TParams, TResponse>;
 /**
  * @experimental
  */
@@ -206,7 +206,7 @@ interface NamedHttpRpc<TIsEventStream extends boolean = false, TParams extends R
 }
 type Rpc<TIsEventStream extends boolean = false, TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> = HttpRpc<TIsEventStream, TParams, TResponse> | WebsocketRpc<TParams, TResponse>;
 interface HttpRpc<TIsEventStream extends boolean = false, TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> {
-    transport: "http";
+    transport: 'http';
     method?: RpcHttpMethod;
     path?: string;
     description?: string;
@@ -218,23 +218,23 @@ interface HttpRpc<TIsEventStream extends boolean = false, TParams extends RpcPar
     handler: TIsEventStream extends true ? EventStreamRpcHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : undefined> : RpcHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : void>;
     postHandler?: TIsEventStream extends true ? undefined : RpcPostHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : undefined>;
 }
-interface RpcEvent<TParams = undefined> extends Omit<H3Event, "context"> {
+interface RpcEvent<TParams = undefined> extends Omit<H3Event, 'context'> {
     context: RpcEventContext<TParams>;
 }
-interface RpcPostEvent<TParams = undefined, TResponse = undefined> extends Omit<H3Event, "context"> {
+interface RpcPostEvent<TParams = undefined, TResponse = undefined> extends Omit<H3Event, 'context'> {
     context: RpcPostEventContext<TParams, TResponse>;
 }
 type RpcHandler<TParams, TResponse> = (context: RpcEventContext<TParams>, event: RpcEvent<TParams>) => TResponse | Promise<TResponse>;
 type RpcPostHandler<TParams, TResponse> = (context: RpcPostEventContext<TParams, TResponse>, event: RpcPostEvent<TParams, TResponse>) => any;
 declare function isRpc(input: unknown): input is HttpRpc<any, any>;
-declare function defineRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined | never = undefined>(config: Omit<HttpRpc<false, TParams, TResponse>, "transport" | "isEventStream">): HttpRpc<false, TParams, TResponse>;
+declare function defineRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined | never = undefined>(config: Omit<HttpRpc<false, TParams, TResponse>, 'transport' | 'isEventStream'>): HttpRpc<false, TParams, TResponse>;
 declare function createHttpRpcDefinition(rpcName: string, httpPath: string, procedure: HttpRpc<any, any, any>): HttpRpcDefinition;
 declare function getRpcPath(rpcName: string, prefix?: string): string;
 declare function getRpcParamName(rpcName: string, procedure: HttpRpc<any, any, any> | WebsocketRpc<any, any>): string | undefined;
 declare function getRpcResponseName(rpcName: string, procedure: HttpRpc<any, any, any> | WebsocketRpc<any, any>): string | undefined;
 declare function registerRpc(router: Router, path: string, procedure: NamedHttpRpc<any, any, any>, opts: RouteOptions): void;
 declare function validateRpcRequestInput(event: H3Event, httpMethod: RpcHttpMethod, schema: ASchema, validator: ReturnType<typeof a.compile>): Promise<void>;
-declare function getSchemaValidator(rpcName: string, type: "params" | "response", schema: ASchema<any>): ReturnType<typeof a.compile> | undefined;
+declare function getSchemaValidator(rpcName: string, type: 'params' | 'response', schema: ASchema<any>): ReturnType<typeof a.compile> | undefined;
 
 declare class ArriService {
     name: string;
@@ -256,7 +256,7 @@ declare class ArriApp {
     readonly h3Router: Router;
     private readonly _rpcDefinitionPath;
     private readonly _rpcRoutePrefix;
-    appInfo: AppDefinition["info"];
+    appInfo: AppDefinition['info'];
     private _procedures;
     private _definitions;
     private readonly _middlewares;
@@ -280,7 +280,7 @@ interface ArriOptions {
     /**
      * Metadata to display in the __definition.json file
      */
-    appInfo?: AppDefinition["info"];
+    appInfo?: AppDefinition['info'];
     rpcRoutePrefix?: string;
     /**
      * Defaults to /__definitions
@@ -294,7 +294,7 @@ interface ArriOptions {
     onBeforeResponse?: (event: RequestHookEvent) => void | Promise<void>;
     onError?: (error: arriError, event: RequestHookEvent) => void | Promise<void>;
 }
-interface RequestHookEvent extends Omit<H3Event, "context"> {
+interface RequestHookEvent extends Omit<H3Event, 'context'> {
     context: RequestHookContext;
 }
 

package/dist/index.d.ts

@@ -55,9 +55,9 @@ declare const arriErrorResponse: AObjectSchema<{
     data?: any;
 }>;
 type arriErrorResponse = a.infer<typeof arriErrorResponse>;
-declare function defineError(statusCode: StatusCode, input?: Partial<Omit<arriErrorResponse, "code" | "stack">>): arriError;
-declare function errorResponseFromValidationErrors(errors: ValidationError["errors"], prefixText?: string): H3Error;
-declare function handleH3Error(err: unknown, event: H3Event, onError: ArriOptions["onError"], debug: boolean): Promise<void>;
+declare function defineError(statusCode: StatusCode, input?: Partial<Omit<arriErrorResponse, 'code' | 'stack'>>): arriError;
+declare function errorResponseFromValidationErrors(errors: ValidationError['errors'], prefixText?: string): H3Error;
+declare function handleH3Error(err: unknown, event: H3Event, onError: ArriOptions['onError'], debug: boolean): Promise<void>;
 
 interface RouteEvent<TPath extends string, TQuery extends Record<any, any> = any, TBody = any> extends H3Event {
     context: RouteEventContext<TPath, TQuery, TBody>;
@@ -74,7 +74,7 @@ interface ArriRoute<TPath extends string, TQuery extends AObjectSchema<any, any>
     postHandler?: (event: PostRouteEvent<TPath, InferType<TQuery>, InferType<TBody>, Awaited<TResponse>>) => any;
 }
 declare function defineRoute<TPath extends string, TQuery extends AObjectSchema<any, any> = any, TBody extends AObjectSchema<any, any> = any, TResponse = any>(route: ArriRoute<TPath, TQuery, TBody, TResponse>): ArriRoute<TPath, TQuery, TBody, TResponse>;
-type RouteOptions = Pick<ArriOptions, "onAfterResponse" | "onBeforeResponse" | "onError" | "onRequest" | "debug"> & {
+type RouteOptions = Pick<ArriOptions, 'onAfterResponse' | 'onBeforeResponse' | 'onError' | 'onRequest' | 'debug'> & {
     middleware: Middleware[];
 };
 declare function registerRoute(router: Router, route: ArriRoute<any>, opts: RouteOptions): void;
@@ -91,9 +91,9 @@ declare class ArriRouter {
     getDefinitions(): DefinitionMap;
 }
 
-declare function defineEventStreamRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined | never = undefined>(config: Omit<EventStreamRpc<TParams, TResponse>, "isEventStream" | "transport">): EventStreamRpc<TParams, TResponse>;
+declare function defineEventStreamRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined | never = undefined>(config: Omit<EventStreamRpc<TParams, TResponse>, 'isEventStream' | 'transport'>): EventStreamRpc<TParams, TResponse>;
 declare function isEventStreamRpc(input: unknown): input is EventStreamRpc<any, any>;
-interface EventStreamRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> extends Omit<HttpRpc<true, TParams, TResponse>, "handler" | "postHandler"> {
+interface EventStreamRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> extends Omit<HttpRpc<true, TParams, TResponse>, 'handler' | 'postHandler'> {
     isEventStream: true;
     handler: EventStreamRpcHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : undefined>;
 }
@@ -146,7 +146,7 @@ interface NamedWebsocketRpc<TParams extends RpcParamSchema | undefined = undefin
     name: string;
 }
 interface WebsocketRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> {
-    transport: "ws";
+    transport: 'ws';
     description?: string;
     path?: string;
     isDeprecated?: boolean;
@@ -189,7 +189,7 @@ interface WebSocketRpcHandler<TParams, TResponse> {
 /**
  * @experimental
  */
-declare function defineWebsocketRpc<TParams extends RpcParamSchema | undefined, TResponse extends RpcParamSchema | undefined>(def: Omit<WebsocketRpc<TParams, TResponse>, "transport">): WebsocketRpc<TParams, TResponse>;
+declare function defineWebsocketRpc<TParams extends RpcParamSchema | undefined, TResponse extends RpcParamSchema | undefined>(def: Omit<WebsocketRpc<TParams, TResponse>, 'transport'>): WebsocketRpc<TParams, TResponse>;
 /**
  * @experimental
  */
@@ -206,7 +206,7 @@ interface NamedHttpRpc<TIsEventStream extends boolean = false, TParams extends R
 }
 type Rpc<TIsEventStream extends boolean = false, TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> = HttpRpc<TIsEventStream, TParams, TResponse> | WebsocketRpc<TParams, TResponse>;
 interface HttpRpc<TIsEventStream extends boolean = false, TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> {
-    transport: "http";
+    transport: 'http';
     method?: RpcHttpMethod;
     path?: string;
     description?: string;
@@ -218,23 +218,23 @@ interface HttpRpc<TIsEventStream extends boolean = false, TParams extends RpcPar
     handler: TIsEventStream extends true ? EventStreamRpcHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : undefined> : RpcHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : void>;
     postHandler?: TIsEventStream extends true ? undefined : RpcPostHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : undefined>;
 }
-interface RpcEvent<TParams = undefined> extends Omit<H3Event, "context"> {
+interface RpcEvent<TParams = undefined> extends Omit<H3Event, 'context'> {
     context: RpcEventContext<TParams>;
 }
-interface RpcPostEvent<TParams = undefined, TResponse = undefined> extends Omit<H3Event, "context"> {
+interface RpcPostEvent<TParams = undefined, TResponse = undefined> extends Omit<H3Event, 'context'> {
     context: RpcPostEventContext<TParams, TResponse>;
 }
 type RpcHandler<TParams, TResponse> = (context: RpcEventContext<TParams>, event: RpcEvent<TParams>) => TResponse | Promise<TResponse>;
 type RpcPostHandler<TParams, TResponse> = (context: RpcPostEventContext<TParams, TResponse>, event: RpcPostEvent<TParams, TResponse>) => any;
 declare function isRpc(input: unknown): input is HttpRpc<any, any>;
-declare function defineRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined | never = undefined>(config: Omit<HttpRpc<false, TParams, TResponse>, "transport" | "isEventStream">): HttpRpc<false, TParams, TResponse>;
+declare function defineRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined | never = undefined>(config: Omit<HttpRpc<false, TParams, TResponse>, 'transport' | 'isEventStream'>): HttpRpc<false, TParams, TResponse>;
 declare function createHttpRpcDefinition(rpcName: string, httpPath: string, procedure: HttpRpc<any, any, any>): HttpRpcDefinition;
 declare function getRpcPath(rpcName: string, prefix?: string): string;
 declare function getRpcParamName(rpcName: string, procedure: HttpRpc<any, any, any> | WebsocketRpc<any, any>): string | undefined;
 declare function getRpcResponseName(rpcName: string, procedure: HttpRpc<any, any, any> | WebsocketRpc<any, any>): string | undefined;
 declare function registerRpc(router: Router, path: string, procedure: NamedHttpRpc<any, any, any>, opts: RouteOptions): void;
 declare function validateRpcRequestInput(event: H3Event, httpMethod: RpcHttpMethod, schema: ASchema, validator: ReturnType<typeof a.compile>): Promise<void>;
-declare function getSchemaValidator(rpcName: string, type: "params" | "response", schema: ASchema<any>): ReturnType<typeof a.compile> | undefined;
+declare function getSchemaValidator(rpcName: string, type: 'params' | 'response', schema: ASchema<any>): ReturnType<typeof a.compile> | undefined;
 
 declare class ArriService {
     name: string;
@@ -256,7 +256,7 @@ declare class ArriApp {
     readonly h3Router: Router;
     private readonly _rpcDefinitionPath;
     private readonly _rpcRoutePrefix;
-    appInfo: AppDefinition["info"];
+    appInfo: AppDefinition['info'];
     private _procedures;
     private _definitions;
     private readonly _middlewares;
@@ -280,7 +280,7 @@ interface ArriOptions {
     /**
      * Metadata to display in the __definition.json file
      */
-    appInfo?: AppDefinition["info"];
+    appInfo?: AppDefinition['info'];
     rpcRoutePrefix?: string;
     /**
      * Defaults to /__definitions
@@ -294,7 +294,7 @@ interface ArriOptions {
     onBeforeResponse?: (event: RequestHookEvent) => void | Promise<void>;
     onError?: (error: arriError, event: RequestHookEvent) => void | Promise<void>;
 }
-interface RequestHookEvent extends Omit<H3Event, "context"> {
+interface RequestHookEvent extends Omit<H3Event, 'context'> {
     context: RequestHookContext;
 }
 

package/dist/index.mjs

@@ -272,7 +272,7 @@ function createHttpRpcDefinition(rpcName, httpPath, procedure) {
     params: getRpcParamName(rpcName, procedure),
     response: getRpcResponseDefinition(rpcName, procedure),
     isDeprecated: procedure.isDeprecated,
-    isEventStream: procedure.isEventStream === true ? true : void 0
+    isEventStream: procedure.isEventStream === true ? true : undefined
   };
 }
 function getRpcPath(rpcName, prefix = "") {
@@ -287,7 +287,7 @@ function getRpcPath(rpcName, prefix = "") {
 }
 function getRpcParamName(rpcName, procedure) {
   if (!isRpcParamSchema(procedure.params)) {
-    return void 0;
+    return undefined;
   }
   const nameParts = rpcName.split(".").map(
     (part) => removeDisallowedChars(part, `!@#$%^&*()+=[]{}|\\;:'"<>,./?`)
@@ -297,7 +297,7 @@ function getRpcParamName(rpcName, procedure) {
 }
 function getRpcResponseName(rpcName, procedure) {
   if (!isRpcParamSchema(procedure.response)) {
-    return void 0;
+    return undefined;
   }
   const nameParts = rpcName.split(".").map(
     (part) => removeDisallowedChars(part, `!@#$%^&*()+=[]{}|\\;:'"<>,./?`)
@@ -307,17 +307,17 @@ function getRpcResponseName(rpcName, procedure) {
 }
 function getRpcResponseDefinition(rpcName, procedure) {
   if (!isRpcParamSchema(procedure.response)) {
-    return void 0;
+    return undefined;
   }
   const name = getRpcResponseName(rpcName, procedure);
   if (!name) {
-    return void 0;
+    return undefined;
   }
   return name;
 }
 function registerRpc(router, path, procedure, opts) {
-  const paramValidator = procedure.params ? getSchemaValidator(procedure.name, "params", procedure.params) : void 0;
-  const responseValidator = procedure.response ? getSchemaValidator(procedure.name, "response", procedure.response) : void 0;
+  const paramValidator = procedure.params ? getSchemaValidator(procedure.name, "params", procedure.params) : undefined;
+  const responseValidator = procedure.response ? getSchemaValidator(procedure.name, "response", procedure.response) : undefined;
   const httpMethod = procedure.method ?? "post";
   const handler = eventHandler(async (event) => {
     event.context.rpcName = procedure.name;
@@ -468,7 +468,7 @@ function getSchemaValidator(rpcName, type, schema) {
     return a.compile(schema);
   } catch (_) {
     console.error(`Error compiling ${type} validator for ${rpcName}`);
-    return void 0;
+    return undefined;
   }
 }
 
@@ -489,7 +489,7 @@ class EventStreamConnection {
   validator;
   serializer;
   // for some reason Rollup cannot output DTS when this is set to NodeJS.Timeout
-  pingInterval = void 0;
+  pingInterval = undefined;
   pingIntervalMs;
   eventStream;
   constructor(event, opts) {
@@ -572,8 +572,8 @@ class EventStreamConnection {
   }
 }
 function registerEventStreamRpc(router, path, procedure, opts) {
-  const paramValidator = procedure.params ? getSchemaValidator(procedure.name, "params", procedure.params) : void 0;
-  const responseValidator = procedure.response ? getSchemaValidator(procedure.name, "response", procedure.response) : void 0;
+  const paramValidator = procedure.params ? getSchemaValidator(procedure.name, "params", procedure.params) : undefined;
+  const responseValidator = procedure.response ? getSchemaValidator(procedure.name, "response", procedure.response) : undefined;
   const httpMethod = procedure.method ?? "get";
   const handler = eventHandler(async (event) => {
     event.context.rpcName = procedure.name;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arrirpc/server",
-  "version": "0.70.1",
+  "version": "0.71.0",
   "type": "module",
   "license": "MIT",
   "author": {
@@ -24,15 +24,15 @@
   "dependencies": {
     "@types/source-map-support": "^0.5.10",
     "crossws": "^0.3.1",
-    "h3": "^1.13.0",
+    "h3": "^1.13.1",
     "scule": "^1.3.0",
     "source-map-support": "^0.5.21",
     "uncrypto": "^0.1.3",
-    "@arrirpc/codegen-utils": "0.70.1",
-    "arri": "0.70.1",
-    "@arrirpc/schema": "0.70.1"
+    "@arrirpc/codegen-utils": "0.71.0",
+    "@arrirpc/schema": "0.71.0",
+    "arri": "0.71.0"
   },
   "devDependencies": {
-    "bun-types": "^1.1.42"
+    "bun-types": "^1.1.43"
   }
 }