@arrirpc/server 0.72.0 → 0.74.0

package/README.md

@@ -15,10 +15,9 @@ Parameters and responses are defined using [@arrirpc/schema](/languages/ts/ts-sc
         - [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)
+        - [Adding to the RPC Context](#adding-to-the-rpc-context)
 - [Key Concepts](#key-concepts)
     - [Arri Definition File](#arri-definition-file)
     - [How Procedures Map To Endpoints](#how-procedures-map-to-endpoints)
@@ -291,70 +290,6 @@ stream.close()
 stream.onClosed(cb: () => any)
 ```
 
-### Creating Websocket Procedures (Experimental
-
-Very experimental. Do not use in production.
-
-```ts
-// Websocket procedures work really well with discriminated unions
-const IncomingMsg = a.discriminator('type', {
-    FOO: a.object({
-        message: a.string(),
-    }),
-    PING: a.object({
-        message: a.string(),
-    })
-});
-
-const OutgoingMsg = a.discriminator('type', {
-    BAR: a.object({
-        message: a.string(),
-    }),
-    PONG: a.object({
-    message: a.string()
-    })
-});
-
-export default defineWebsocketRpc(
-    params: IncomingMsg,
-    response: OutgoingMsg,
-    handler: {
-        onOpen: (peer) => {},
-        onMessage: (peer, message) => {
-            switch(message.type) {
-                case "FOO":
-                    peer.send({
-                        type: "BAR",
-                        message: "You sent a FOO message"
-                    });
-                    break;
-                case "PING":
-                    peer.send({
-                        type: "PONG",
-                        message: "You sent a PING message"
-                    });
-                    break;
-            }
-        },
-        onError: (peer, error) => {}
-    }
-)
-```
-
-Under the hood Websocket RPCs use [crossws](https://crossws.unjs.io/).
-
-The possible payloads sent by the server will look like the following:
-
-```
-event: message
-data: <response serialized to json>
-```
-
-```
-event: error
-data: {"code": <some-err-code>, "message": <some-error-msg>}
-```
-
 ### Adding Non-RPC Routes
 
 You can also add generic endpoints for instances when a message-based RPC endpoint doesn't fit.

package/dist/index.cjs

@@ -290,20 +290,14 @@ function getRpcParamName(rpcName, procedure) {
   if (!isRpcParamSchema(procedure.params)) {
     return undefined;
   }
-  const nameParts = rpcName.split(".").map(
-    (part) => codegenUtils.removeDisallowedChars(part, `!@#$%^&*()+=[]{}|\\;:'"<>,./?`)
-  );
-  const paramName = procedure.params.metadata.id ?? scule.pascalCase(`${nameParts.join(`_`)}_params`);
+  const paramName = getSchemaName(rpcName, "params", procedure.params);
   return paramName;
 }
 function getRpcResponseName(rpcName, procedure) {
   if (!isRpcParamSchema(procedure.response)) {
     return undefined;
   }
-  const nameParts = rpcName.split(".").map(
-    (part) => codegenUtils.removeDisallowedChars(part, `!@#$%^&*()+=[]{}|\\;:'"<>,./?`)
-  );
-  const responseName = procedure.response.metadata.id ?? scule.pascalCase(`${nameParts.join("_")}_response`);
+  const responseName = getSchemaName(rpcName, "response", procedure.response);
   return responseName;
 }
 function getRpcResponseDefinition(rpcName, procedure) {
@@ -338,7 +332,6 @@ function registerRpc(router, path, procedure, opts) {
         await validateRpcRequestInput(
           event,
           httpMethod,
-          procedure.params,
           paramValidator
         );
       }
@@ -351,18 +344,15 @@ function registerRpc(router, path, procedure, opts) {
         await opts.onBeforeResponse(event);
       }
       if (typeof response === "object") {
-        if (!responseValidator?.validate(response)) {
-          const errors = schema.a.errors(procedure.response, response);
+        const payload = responseValidator?.serialize(response);
+        if (payload && payload.success !== true) {
           throw defineError(500, {
             message: "Failed to serialize response. Response does not match specified schema",
-            data: errors
+            data: payload?.errors
           });
         }
         h3.setResponseHeader(event, "Content-Type", "application/json");
-        await h3.send(
-          event,
-          responseValidator?.serialize(response) ?? JSON.stringify(response)
-        );
+        await h3.send(event, payload?.value ?? JSON.stringify(response));
       } else {
         h3.setResponseHeader(event, "Content-Type", "application/json");
         await h3.send(event, `{}`);
@@ -400,22 +390,22 @@ function registerRpc(router, path, procedure, opts) {
       break;
   }
 }
-async function validateRpcRequestInput(event, httpMethod, schema$1, validator) {
+async function validateRpcRequestInput(event, httpMethod, validator) {
   switch (httpMethod) {
     case "get": {
       const parsedParams = await h3.getValidatedQuery(
         event,
-        (input) => schema.a.safeCoerce(schema$1, input)
+        (input) => validator.coerce(input)
       );
       if (parsedParams.success) {
         event.context.params = parsedParams.value;
       } else {
         const errParts = [];
-        for (const err of parsedParams.error.errors) {
-          const errPath = err.instancePath.split("/");
-          errPath.shift();
-          const propName = errPath.join(".");
-          if (!errParts.includes(propName)) {
+        for (const err of parsedParams.errors) {
+          const errPath = err.instancePath?.split("/");
+          errPath?.shift();
+          const propName = errPath?.join(".");
+          if (propName && !errParts.includes(propName)) {
             errParts.push(propName);
           }
         }
@@ -424,7 +414,7 @@ async function validateRpcRequestInput(event, httpMethod, schema$1, validator) {
         )}]`;
         throw defineError(400, {
           message,
-          data: parsedParams.error
+          data: parsedParams.errors
         });
       }
       break;
@@ -439,21 +429,11 @@ async function validateRpcRequestInput(event, httpMethod, schema$1, validator) {
           message: `Invalid request body. Expected object. Got undefined.`
         });
       }
-      const parsedParams = validator.safeParse(body);
+      const parsedParams = validator.parse(body);
       if (!parsedParams?.success) {
-        const errorParts = [];
-        for (const err of parsedParams.error.errors) {
-          const errPath = err.instancePath.split("/");
-          errPath.shift();
-          if (!errorParts.includes(errPath.join("."))) {
-            errorParts.push(errPath.join("."));
-          }
-        }
         throw defineError(400, {
-          message: `Invalid request body. Affected properties [${errorParts.join(
-            ", "
-          )}]`,
-          data: parsedParams.error
+          message: schema.errorMessageFromErrors(parsedParams.errors),
+          data: parsedParams.errors
         });
       }
       event.context.params = parsedParams.value;
@@ -462,15 +442,31 @@ async function validateRpcRequestInput(event, httpMethod, schema$1, validator) {
   }
 }
 function getSchemaValidator(rpcName, type, schema$1) {
-  try {
-    if (schema.isAdaptedSchema(schema$1)) {
-      return schema.validatorFromAdaptedSchema(schema$1);
+  if (schema.isASchema(schema$1)) {
+    try {
+      const validator = schema.a.compile(schema$1);
+      return {
+        validate: validator.validate,
+        serialize: validator.serialize,
+        parse: validator.parse,
+        coerce: validator.coerce,
+        errors: (input) => schema.a.errors(schema$1, input)
+      };
+    } catch (err) {
+      console.error(
+        `Error compiling ${type} validator for ${rpcName}. Error: ${err}`
+      );
     }
-    return schema.a.compile(schema$1);
-  } catch (_) {
-    console.error(`Error compiling ${type} validator for ${rpcName}`);
-    return undefined;
   }
+  return undefined;
+}
+function getSchemaName(rpcName, type, schema) {
+  const cleanedName = rpcName.split(".").map(
+    (part) => codegenUtils.removeDisallowedChars(part, `!@#$%^&*()+=[]{}|\\;:'"<>,./?`)
+  ).join("_");
+  return schema.metadata?.id ?? scule.pascalCase(`${cleanedName}_${type}`, {
+    normalize: true
+  });
 }
 
 function defineEventStreamRpc(config) {
@@ -486,9 +482,7 @@ function isEventStreamRpc(input) {
 }
 class EventStreamConnection {
   lastEventId;
-  validationErrors;
   validator;
-  serializer;
   // for some reason Rollup cannot output DTS when this is set to NodeJS.Timeout
   pingInterval = undefined;
   pingIntervalMs;
@@ -497,9 +491,7 @@ class EventStreamConnection {
     this.eventStream = h3.createEventStream(event);
     this.lastEventId = h3.getHeader(event, "Last-Event-Id");
     this.pingIntervalMs = opts.pingInterval ?? 6e4;
-    this.serializer = opts.serializer;
     this.validator = opts.validator;
-    this.validationErrors = opts.validationErrors;
     this.eventStream.onClosed(() => {
       this.cleanup();
     });
@@ -517,20 +509,23 @@ class EventStreamConnection {
     }, this.pingIntervalMs);
   }
   async push(data, eventId) {
+    if (!this.validator) return;
     if (Array.isArray(data)) {
       const results = [];
       const events = [];
       for (const item of data) {
-        if (this.validator(item)) {
+        if (this.validator.validate(item)) {
           events.push({
             id: eventId,
             event: "message",
-            data: this.serializer(item)
+            data: this.validator.serialize(
+              item
+            ).value
           });
           results.push({ success: true });
           continue;
         }
-        const errors2 = this.validationErrors(item);
+        const errors2 = this.validator.errors(item);
         results.push({
           success: false,
           errors: errors2
@@ -539,15 +534,15 @@ class EventStreamConnection {
       await this.eventStream.push(events);
       return results;
     }
-    if (this.validator(data)) {
+    if (this.validator.validate(data)) {
       await this.eventStream.push({
         id: eventId,
         event: "message",
-        data: this.serializer(data)
+        data: this.validator.serialize(data).value
       });
       return { success: true };
     }
-    const errors = this.validationErrors(data);
+    const errors = this.validator.errors(data);
     return {
       success: false,
       errors
@@ -594,24 +589,12 @@ function registerEventStreamRpc(router, path, procedure, opts) {
         await validateRpcRequestInput(
           event,
           httpMethod,
-          procedure.params,
           paramValidator
         );
       }
       const stream = new EventStreamConnection(event, {
         pingInterval: procedure.pingInterval,
-        validator: responseValidator?.validate ?? function() {
-          return true;
-        },
-        serializer: responseValidator?.serialize ?? function(_) {
-          return "";
-        },
-        validationErrors(input) {
-          if (procedure.response) {
-            return schema.a.errors(procedure.response, input);
-          }
-          return [];
-        }
+        validator: responseValidator
       });
       event.context.stream = stream;
       await procedure.handler(
@@ -674,10 +657,10 @@ function handleRoute(router, method, route, opts) {
       }
       if (route.query) {
         const query = h3.getQuery(event);
-        const parsedQuery = schema.a.safeCoerce(route.query, query);
+        const parsedQuery = schema.a.coerce(route.query, query);
         if (!parsedQuery.success) {
           const errParts = [];
-          for (const err of parsedQuery.error.errors) {
+          for (const err of parsedQuery.errors) {
             const errPath = err.instancePath.split("/");
             errPath.shift();
             const propName = errPath.join(".");
@@ -702,21 +685,11 @@ function handleRoute(router, method, route, opts) {
       ];
       if (route.body && !notAllowedBodyMethods.includes(event.method)) {
         const body = await h3.readRawBody(event);
-        const parsedBody = schema.a.safeParse(route.body, body);
+        const parsedBody = schema.a.parse(route.body, body);
         if (!parsedBody.success) {
-          const errorParts = [];
-          for (const err of parsedBody.error.errors) {
-            const errPath = err.instancePath.split("/");
-            errPath.shift();
-            if (!errorParts.includes(errPath.join("."))) {
-              errorParts.push(errPath.join("."));
-            }
-          }
           throw defineError(400, {
-            message: `Invalid request body. Affected properties [${errorParts.join(
-              ", "
-            )}]`,
-            data: parsedBody.error
+            message: schema.errorMessageFromErrors(parsedBody.errors),
+            data: parsedBody.errors
           });
         }
         event.context.body = parsedBody.value;
@@ -822,88 +795,6 @@ function defineService(name, procedures) {
   return service;
 }
 
-class WsPeer {
-  _peer;
-  _validator;
-  context;
-  url;
-  constructor(peer, opts) {
-    this._peer = peer;
-    this._validator = opts.validator;
-    this.url = peer.websocket.url ?? "";
-    this.context = opts.context;
-  }
-  send(data) {
-    if (!this._validator) {
-      return;
-    }
-    if (!this._validator.validate(data)) {
-      return;
-    }
-    const payload = this._validator.serialize(data);
-    return this._peer.send(`event: message
-data: ${payload}`);
-  }
-  sendError(err) {
-    return this._peer.send(`event: error
-data: ${JSON.stringify(err)}`);
-  }
-  close() {
-    throw new Error("close() is not yet implemented on WsPeer");
-  }
-  subscribe(channel) {
-    this._peer.subscribe(channel);
-  }
-  unsubscribe(channel) {
-    this._peer.unsubscribe(channel);
-  }
-  publish(channel, message) {
-    if (!this._validator) {
-      return;
-    }
-    if (!this._validator.validate(message)) {
-      const err = {
-        code: 500,
-        message: `Error serializing message on server. The payload doesn't match the specified schema.`,
-        data: {
-          payload: message
-        }
-      };
-      this.sendError(err);
-      return;
-    }
-    const payload = this._validator.serialize(message);
-    this._peer.publish(channel, payload);
-  }
-}
-function defineWebsocketRpc(def) {
-  def.transport = "ws";
-  return def;
-}
-function registerWebsocketRpc(router, path, _rpc) {
-  const handler = h3.defineWebSocketHandler({
-    upgrade(_req) {
-    },
-    open(_) {
-    },
-    message(_, __) {
-    },
-    close(_, __) {
-    }
-  });
-  router.use(path, handler);
-}
-function createWsRpcDefinition(rpcName, path, rpc) {
-  return {
-    transport: "ws",
-    path,
-    params: getRpcParamName(rpcName, rpc),
-    response: getRpcResponseName(rpcName, rpc),
-    isDeprecated: rpc.isDeprecated,
-    description: rpc.description
-  };
-}
-
 const createAppDefinition = (def) => def;
 class ArriApp {
   __isArri__ = true;
@@ -1014,8 +905,6 @@ class ArriApp {
     const path = p.path ?? getRpcPath(p.name, this._rpcRoutePrefix);
     if (p.transport === "http") {
       this._procedures[p.name] = createHttpRpcDefinition(p.name, path, p);
-    } else if (p.transport === "ws") {
-      this._procedures[p.name] = createWsRpcDefinition(p.name, path, p);
     }
     if (isRpcParamSchema(p.params)) {
       const paramName = getRpcParamName(p.name, p);
@@ -1051,9 +940,6 @@ class ArriApp {
       });
       return;
     }
-    if (p.transport === "ws") {
-      registerWebsocketRpc(this.h3Router, path);
-    }
   }
   route(route) {
     registerRoute(this.h3Router, route, {
@@ -1091,23 +977,21 @@ exports.ArriApp = ArriApp;
 exports.ArriRouter = ArriRouter;
 exports.ArriService = ArriService;
 exports.EventStreamConnection = EventStreamConnection;
-exports.WsPeer = WsPeer;
 exports.arriError = arriError;
 exports.arriErrorResponse = arriErrorResponse;
 exports.createAppDefinition = createAppDefinition;
 exports.createHttpRpcDefinition = createHttpRpcDefinition;
-exports.createWsRpcDefinition = createWsRpcDefinition;
 exports.defineError = defineError;
 exports.defineEventStreamRpc = defineEventStreamRpc;
 exports.defineMiddleware = defineMiddleware;
 exports.defineRoute = defineRoute;
 exports.defineRpc = defineRpc;
 exports.defineService = defineService;
-exports.defineWebsocketRpc = defineWebsocketRpc;
 exports.errorResponseFromValidationErrors = errorResponseFromValidationErrors;
 exports.getRpcParamName = getRpcParamName;
 exports.getRpcPath = getRpcPath;
 exports.getRpcResponseName = getRpcResponseName;
+exports.getSchemaName = getSchemaName;
 exports.getSchemaValidator = getSchemaValidator;
 exports.handleH3Error = handleH3Error;
 exports.handleRoute = handleRoute;
@@ -1117,7 +1001,6 @@ exports.isRpcParamSchema = isRpcParamSchema;
 exports.registerEventStreamRpc = registerEventStreamRpc;
 exports.registerRoute = registerRoute;
 exports.registerRpc = registerRpc;
-exports.registerWebsocketRpc = registerWebsocketRpc;
 exports.validateRpcRequestInput = validateRpcRequestInput;
 Object.prototype.hasOwnProperty.call(h3, '__proto__') &&
     !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&

package/dist/index.d.cts

@@ -1,8 +1,7 @@
-import { HttpMethod, WsRpcDefinition, RpcHttpMethod, HttpRpcDefinition, SchemaFormProperties, SchemaFormDiscriminator, SchemaFormValues, AppDefinition } from '@arrirpc/codegen-utils';
-import { AObjectSchema, a, ValidationError, ASchema, InferType, ValueError, CompiledValidator, ADiscriminatorSchema } from '@arrirpc/schema';
+import { HttpMethod, RpcHttpMethod, HttpRpcDefinition, SchemaFormProperties, SchemaFormDiscriminator, SchemaFormValues, AppDefinition } from '@arrirpc/codegen-utils';
+import { AObjectSchema, a, ValueError, ASchema, InferType, ADiscriminatorSchema, Result } from '@arrirpc/schema';
 import { H3Event, StatusCode, H3Error, Router, EventStream, App } from 'h3';
 export * from 'h3';
-import { Peer, WSError } from 'crossws';
 
 interface MiddlewareEvent extends H3Event {
     context: MiddlewareEventContext;
@@ -56,7 +55,7 @@ declare const arriErrorResponse: AObjectSchema<{
 }>;
 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 errorResponseFromValidationErrors(errors: ValueError[], 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 {
@@ -91,7 +90,7 @@ 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<TResponse extends RpcParamSchema<any>, TParams extends RpcParamSchema<any> | undefined = 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'> {
     isEventStream: true;
@@ -102,16 +101,12 @@ interface EventStreamRpcHandlerContext<TParams = any, TResponse = any> extends R
     stream: EventStreamConnection<TResponse>;
 }
 interface EventStreamConnectionOptions<TData> {
-    validator: (input: unknown) => input is TData;
-    validationErrors: (input: unknown) => ValueError[];
-    serializer: (input: TData) => string;
+    validator?: RequestValidator<TData>;
     pingInterval?: number;
 }
 declare class EventStreamConnection<TData> {
     readonly lastEventId?: string;
-    private readonly validationErrors;
-    private readonly validator;
-    private readonly serializer;
+    private readonly validator?;
     private pingInterval;
     private readonly pingIntervalMs;
     readonly eventStream: EventStream;
@@ -142,69 +137,12 @@ declare function registerEventStreamRpc(router: Router, path: string, procedure:
     name: string;
 }, opts: RouteOptions): void;
 
-interface NamedWebsocketRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> extends WebsocketRpc<TParams, TResponse> {
-    name: string;
-}
-interface WebsocketRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> {
-    transport: 'ws';
-    description?: string;
-    path?: string;
-    isDeprecated?: boolean;
-    params: TParams;
-    response: TResponse;
-    pingInterval?: boolean;
-    handler: WebSocketRpcHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : undefined> | (() => WebSocketRpcHandler<TParams extends RpcParamSchema ? InferType<TParams> : undefined, TResponse extends RpcParamSchema ? InferType<TResponse> : undefined>);
-}
-interface WsPeerOpts<TResponse> {
-    validator?: CompiledValidator<ASchema<TResponse>>;
-    context: WsPeerContext;
-}
-interface WsPeerContext extends Record<string, any> {
-    rpcName: string;
-    queryParams?: Record<string, string>;
-    clientAddress?: string;
-}
-declare class WsPeer<TResponse> {
-    private readonly _peer;
-    private readonly _validator?;
-    context: WsPeerContext;
-    url: string;
-    constructor(peer: Peer, opts: WsPeerOpts<TResponse>);
-    send(data: TResponse): number | void;
-    sendError(err: arriErrorResponse): number | void | undefined;
-    close(): void;
-    subscribe(channel: string): void;
-    unsubscribe(channel: string): void;
-    publish(channel: string, message: TResponse): void;
-}
-interface WebSocketRpcHandler<TParams, TResponse> {
-    onOpen: (peer: WsPeer<TResponse>) => void;
-    onMessage: (peer: WsPeer<TResponse>, message: TParams) => void;
-    onClose: (peer: WsPeer<TResponse>, details: {
-        code?: number;
-        reason?: string;
-    }) => void;
-    onError: (peer: WsPeer<TResponse>, error: WSError) => void;
-}
-/**
- * @experimental
- */
-declare function defineWebsocketRpc<TParams extends RpcParamSchema | undefined, TResponse extends RpcParamSchema | undefined>(def: Omit<WebsocketRpc<TParams, TResponse>, 'transport'>): WebsocketRpc<TParams, TResponse>;
-/**
- * @experimental
- */
-declare function registerWebsocketRpc(router: Router, path: string, _rpc: NamedWebsocketRpc<any, any>): void;
-/**
- * @experimental
- */
-declare function createWsRpcDefinition(rpcName: string, path: string, rpc: NamedWebsocketRpc<any, any>): WsRpcDefinition;
-
-type RpcParamSchema<TObjectInner = any, TDiscriminatorInner = any> = AObjectSchema<TObjectInner> | ADiscriminatorSchema<TDiscriminatorInner>;
-declare function isRpcParamSchema(input: unknown): input is RpcParamSchema;
+type RpcParamSchema<T = any> = AObjectSchema<T> | ADiscriminatorSchema<T>;
+declare function isRpcParamSchema(input: unknown): input is RpcParamSchema<any>;
 interface NamedHttpRpc<TIsEventStream extends boolean = false, TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> extends HttpRpc<TIsEventStream, TParams, TResponse> {
     name: string;
 }
-type Rpc<TIsEventStream extends boolean = false, TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> = HttpRpc<TIsEventStream, TParams, TResponse> | WebsocketRpc<TParams, TResponse>;
+type Rpc<TIsEventStream extends boolean = false, TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> = HttpRpc<TIsEventStream, TParams, TResponse>;
 interface HttpRpc<TIsEventStream extends boolean = false, TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> {
     transport: 'http';
     method?: RpcHttpMethod;
@@ -215,8 +153,8 @@ interface HttpRpc<TIsEventStream extends boolean = false, TParams extends RpcPar
     isDeprecated?: boolean;
     isEventStream?: TIsEventStream;
     pingInterval?: TIsEventStream extends true ? number : undefined;
-    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>;
+    handler: TIsEventStream extends true ? EventStreamRpcHandler<TParams extends RpcParamSchema<any> ? InferType<TParams> : undefined, TResponse extends RpcParamSchema<any> ? InferType<TResponse> : undefined> : RpcHandler<TParams extends RpcParamSchema<any> ? InferType<TParams> : undefined, TResponse extends RpcParamSchema<any> ? InferType<TResponse> : void>;
+    postHandler?: TIsEventStream extends true ? undefined : RpcPostHandler<TParams extends RpcParamSchema<any> ? InferType<TParams> : undefined, TResponse extends RpcParamSchema<any> ? InferType<TResponse> : undefined>;
 }
 interface RpcEvent<TParams = undefined> extends Omit<H3Event, 'context'> {
     context: RpcEventContext<TParams>;
@@ -230,11 +168,19 @@ 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 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 getRpcParamName(rpcName: string, procedure: HttpRpc<any, any, any>): string | undefined;
+declare function getRpcResponseName(rpcName: string, procedure: HttpRpc<any, 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 validateRpcRequestInput(event: H3Event, httpMethod: RpcHttpMethod, validator: RequestValidator): Promise<void>;
+type RequestValidator<T = any> = {
+    validate: (input: unknown) => input is T;
+    errors: (input: unknown) => ValueError[];
+    coerce: (input: unknown) => Result<T>;
+    parse: (input: unknown) => Result<T>;
+    serialize: (input: any) => Result<string>;
+};
+declare function getSchemaValidator<T extends Record<string, any> = any>(rpcName: string, type: 'params' | 'response', schema: RpcParamSchema<T>): RequestValidator<T> | undefined;
+declare function getSchemaName(rpcName: string, type: 'params' | 'response', schema: RpcParamSchema<any>): string;
 
 declare class ArriService {
     name: string;
@@ -243,10 +189,10 @@ declare class ArriService {
     private readonly definitions;
     rpc(name: string, procedure: Rpc<any, any, any>): void;
     registerDefinitions(models: DefinitionMap): void;
-    getProcedures(): (NamedWebsocketRpc<any, any> | NamedHttpRpc<any, any, any>)[];
+    getProcedures(): NamedHttpRpc<any, any, any>[];
     getDefinitions(): DefinitionMap;
 }
-declare function defineService(name: string, procedures?: Record<string, HttpRpc<any, any, any> | WebsocketRpc<any, any>>): ArriService;
+declare function defineService(name: string, procedures?: Record<string, HttpRpc<any, any, any>>): ArriService;
 
 type DefinitionMap = Record<string, SchemaFormProperties | SchemaFormDiscriminator | SchemaFormValues>;
 declare const createAppDefinition: (def: AppDefinition) => AppDefinition;
@@ -298,4 +244,4 @@ interface RequestHookEvent extends Omit<H3Event, 'context'> {
     context: RequestHookContext;
 }
 
-export { ArriApp, type ArriEventContext, type ArriOptions, type ArriRoute, ArriRouter, ArriService, type DefinitionMap, EventStreamConnection, type EventStreamConnectionOptions, type EventStreamRpc, type EventStreamRpcHandler, type EventStreamRpcHandlerContext, type ExtractParam, type ExtractParams, type HttpRpc, type Middleware, type MiddlewareEvent, type MiddlewareEventContext, type NamedHttpRpc, type NamedWebsocketRpc, type PostRouteEvent, type RequestHookContext, type RequestHookEvent, type RouteEvent, type RouteEventContext, type RouteOptions, type RoutePostEventContext, type Rpc, type RpcEvent, type RpcEventContext, type RpcHandler, type RpcParamSchema, type RpcPostEvent, type RpcPostEventContext, type RpcPostHandler, type SsePushResult, type WebSocketRpcHandler, type WebsocketRpc, WsPeer, type WsPeerContext, arriError, arriErrorResponse, createAppDefinition, createHttpRpcDefinition, createWsRpcDefinition, defineError, defineEventStreamRpc, defineMiddleware, defineRoute, defineRpc, defineService, defineWebsocketRpc, errorResponseFromValidationErrors, getRpcParamName, getRpcPath, getRpcResponseName, getSchemaValidator, handleH3Error, handleRoute, isEventStreamRpc, isRpc, isRpcParamSchema, registerEventStreamRpc, registerRoute, registerRpc, registerWebsocketRpc, validateRpcRequestInput };
+export { ArriApp, type ArriEventContext, type ArriOptions, type ArriRoute, ArriRouter, ArriService, type DefinitionMap, EventStreamConnection, type EventStreamConnectionOptions, type EventStreamRpc, type EventStreamRpcHandler, type EventStreamRpcHandlerContext, type ExtractParam, type ExtractParams, type HttpRpc, type Middleware, type MiddlewareEvent, type MiddlewareEventContext, type NamedHttpRpc, type PostRouteEvent, type RequestHookContext, type RequestHookEvent, type RequestValidator, type RouteEvent, type RouteEventContext, type RouteOptions, type RoutePostEventContext, type Rpc, type RpcEvent, type RpcEventContext, type RpcHandler, type RpcParamSchema, type RpcPostEvent, type RpcPostEventContext, type RpcPostHandler, type SsePushResult, arriError, arriErrorResponse, createAppDefinition, createHttpRpcDefinition, defineError, defineEventStreamRpc, defineMiddleware, defineRoute, defineRpc, defineService, errorResponseFromValidationErrors, getRpcParamName, getRpcPath, getRpcResponseName, getSchemaName, getSchemaValidator, handleH3Error, handleRoute, isEventStreamRpc, isRpc, isRpcParamSchema, registerEventStreamRpc, registerRoute, registerRpc, validateRpcRequestInput };