@arrirpc/server 0.55.0 → 0.57.0

package/dist/index.d.ts

@@ -1,9 +1,43 @@
 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 { StatusCode, H3Error, H3Event, H3EventContext, Router, EventStream, App } from 'h3';
+import { H3Event, StatusCode, H3Error, Router, EventStream, App } from 'h3';
 export * from 'h3';
 import { Peer, WSError } from 'crossws';
 
+interface MiddlewareEvent extends H3Event {
+    context: MiddlewareEventContext;
+}
+type Middleware = (event: MiddlewareEvent) => void | Promise<void>;
+declare const defineMiddleware: (middleware: Middleware) => Middleware;
+type ExtractParam<Path, NextPart> = Path extends `:${infer Param}` ? Record<Param, string> & NextPart : NextPart;
+type ExtractParams<Path> = Path extends `${infer Segment}/${infer Rest}` ? ExtractParam<Segment, ExtractParams<Rest>> : ExtractParam<Path, {}>;
+
+interface ArriEventContext extends Record<string, unknown> {
+}
+type RpcEventContext<TParams = undefined> = ArriEventContext & {
+    rpcName: string;
+    params: TParams;
+};
+type RpcPostEventContext<TParams = undefined, TResponse = undefined> = RpcEventContext<TParams> & {
+    response: TResponse;
+};
+type RouteEventContext<TPath extends string, TQuery extends Record<any, any> = any, TBody = any> = ArriEventContext & {
+    params: ExtractParams<TPath>;
+    query: TQuery;
+    body: TBody;
+};
+type RoutePostEventContext<TPath extends string, TQuery extends Record<any, any> = any, TBody = any, TResponse = any> = RouteEventContext<TPath, TQuery, TBody> & {
+    response: TResponse;
+};
+type MiddlewareEventContext = ArriEventContext & {
+    rpcName?: string;
+};
+type RequestHookContext = ArriEventContext & {
+    rpcName?: string;
+    params?: Record<string, unknown>;
+    response?: unknown;
+};
+
 declare class ArriServerError extends Error {
     code: number;
     data?: any;
@@ -25,34 +59,6 @@ declare function defineError(statusCode: StatusCode, input?: Partial<Omit<ArriSe
 declare function errorResponseFromValidationErrors(errors: ValidationError["errors"], prefixText?: string): H3Error;
 declare function handleH3Error(err: unknown, event: H3Event, onError: ArriOptions["onError"], debug: boolean): Promise<void>;
 
-type ArriEventContext = Record<string, any>;
-interface RpcEventContext<TParams = undefined> extends ArriEventContext, Omit<H3EventContext, "params"> {
-    rpcName: string;
-    params: TParams;
-}
-interface RpcPostEventContext<TParams = undefined, TResponse = undefined> extends RpcEventContext<TParams> {
-    response: TResponse;
-}
-interface RouteEventContext<TPath extends string, TQuery extends Record<any, any> = any, TBody = any> extends ArriEventContext, H3EventContext {
-    params: ExtractParams<TPath>;
-    query: TQuery;
-    body: TBody;
-}
-interface RoutePostEventContext<TPath extends string, TQuery extends Record<any, any> = any, TBody = any, TResponse = any> extends RouteEventContext<TPath, TQuery, TBody> {
-    response: TResponse;
-}
-interface MiddlewareEventContext extends ArriEventContext, H3EventContext {
-    rpcName?: string;
-}
-
-interface MiddlewareEvent extends H3Event {
-    context: MiddlewareEventContext;
-}
-type Middleware = (event: MiddlewareEvent) => void | Promise<void>;
-declare const defineMiddleware: (middleware: Middleware) => Middleware;
-type ExtractParam<Path, NextPart> = Path extends `:${infer Param}` ? Record<Param, string> & NextPart : NextPart;
-type ExtractParams<Path> = Path extends `${infer Segment}/${infer Rest}` ? ExtractParam<Segment, ExtractParams<Rest>> : ExtractParam<Path, {}>;
-
 interface RouteEvent<TPath extends string, TQuery extends Record<any, any> = any, TBody = any> extends H3Event {
     context: RouteEventContext<TPath, TQuery, TBody>;
 }
@@ -74,9 +80,20 @@ type RouteOptions = Pick<ArriOptions, "onAfterResponse" | "onBeforeResponse" | "
 declare function registerRoute(router: Router, route: ArriRoute<any>, opts: RouteOptions): void;
 declare function handleRoute(router: Router, method: HttpMethod, route: ArriRoute<any>, opts: RouteOptions): void;
 
+declare class ArriRouter {
+    private readonly routes;
+    private readonly definitions;
+    prefix: string;
+    constructor(routePrefix?: string);
+    route<TPath extends string, TQuery extends AObjectSchema<any, any> = any, TBody extends ASchema<any> = any, TResponse = any>(route: ArriRoute<TPath, TQuery, TBody, TResponse>): void;
+    registerDefinitions(models: DefinitionMap): void;
+    getRoutes(): ArriRoute<any, any, any, any>[];
+    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 isEventStreamRpc(input: unknown): input is EventStreamRpc<any, any>;
-interface EventStreamRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> extends Omit<Rpc<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>;
 }
@@ -185,10 +202,11 @@ declare function createWsRpcDefinition(rpcName: string, path: string, rpc: Named
 
 type RpcParamSchema<TObjectInner = any, TDiscriminatorInner = any> = AObjectSchema<TObjectInner> | ADiscriminatorSchema<TDiscriminatorInner>;
 declare function isRpcParamSchema(input: unknown): input is RpcParamSchema;
-interface NamedRpc<TIsEventStream extends boolean = false, TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> extends Rpc<TIsEventStream, TParams, TResponse> {
+interface NamedHttpRpc<TIsEventStream extends boolean = false, TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> extends HttpRpc<TIsEventStream, TParams, TResponse> {
     name: string;
 }
-interface Rpc<TIsEventStream extends boolean = false, TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined = undefined> {
+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";
     method?: RpcHttpMethod;
     path?: string;
@@ -201,7 +219,6 @@ interface Rpc<TIsEventStream extends boolean = false, TParams extends RpcParamSc
     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>;
 }
-type HttpRpc<TParams extends RpcParamSchema | undefined, TResponse extends RpcParamSchema | undefined> = Omit<Rpc<false, TParams, TResponse>, "isEventStream">;
 interface RpcEvent<TParams = undefined> extends Omit<H3Event, "context"> {
     context: RpcEventContext<TParams>;
 }
@@ -210,37 +227,31 @@ interface RpcPostEvent<TParams = undefined, TResponse = undefined> extends Omit<
 }
 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 Rpc<any, any>;
-declare function defineRpc<TParams extends RpcParamSchema | undefined = undefined, TResponse extends RpcParamSchema | undefined | never = undefined>(config: Omit<HttpRpc<TParams, TResponse>, "transport">): Rpc<false, TParams, TResponse>;
-declare function createHttpRpcDefinition(rpcName: string, httpPath: string, procedure: Rpc<any, any, any>): HttpRpcDefinition;
+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: Rpc<any, any, any> | WebsocketRpc<any, any>): string | undefined;
-declare function getRpcResponseName(rpcName: string, procedure: Rpc<any, any, any> | WebsocketRpc<any, any>): string | undefined;
-declare function registerRpc(router: Router, path: string, procedure: NamedRpc<any, any, any>, opts: RouteOptions): void;
-declare function validateRpcRequestInput(event: H3Event, httpMethod: RpcHttpMethod, schema: ASchema): Promise<void>;
+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;
 
-interface ArriRouterBase {
-    rpc: <TIsEventStream extends boolean, TParams extends AObjectSchema<any, any> | undefined, TResponse extends AObjectSchema<any, any> | undefined>(procedure: Omit<NamedRpc<TIsEventStream, TParams, TResponse>, "transport">) => void;
-    wsRpc: <TParams extends RpcParamSchema | undefined, TResponse extends RpcParamSchema | undefined>(procedure: Omit<NamedWebsocketRpc<TParams, TResponse>, "transport">) => void;
-    route: <TPath extends string, TQuery extends AObjectSchema<any, any> = any, TBody extends ASchema<any> = any, TResponse = any>(route: ArriRoute<TPath, TQuery, TBody, TResponse>) => void;
-    registerDefinitions: (definitions: DefinitionMap) => void;
-}
-declare class ArriRouter implements ArriRouterBase {
+declare class ArriService {
+    name: string;
+    constructor(name: string);
     private readonly procedures;
-    private readonly routes;
     private readonly definitions;
-    rpc<TIsEventStream extends boolean = false, TParams extends AObjectSchema<any, any> | undefined = undefined, TResponse extends AObjectSchema<any, any> | undefined = undefined>(procedure: Omit<NamedRpc<TIsEventStream, TParams, TResponse>, "transport">): void;
-    wsRpc<TParams extends RpcParamSchema | undefined, TResponse extends RpcParamSchema | undefined>(procedure: Omit<NamedWebsocketRpc<TParams, TResponse>, "transport">): void;
-    route<TPath extends string, TQuery extends AObjectSchema<any, any> = any, TBody extends ASchema<any> = any, TResponse = any>(route: ArriRoute<TPath, TQuery, TBody, TResponse>): void;
+    rpc(name: string, procedure: Rpc<any, any, any>): void;
     registerDefinitions(models: DefinitionMap): void;
-    getProcedures(): (NamedWebsocketRpc<any, any> | NamedRpc<any, any, any>)[];
-    getRoutes(): ArriRoute<any, any, any, any>[];
+    getProcedures(): (NamedWebsocketRpc<any, any> | NamedHttpRpc<any, any, any>)[];
     getDefinitions(): DefinitionMap;
 }
+declare function defineService(name: string, procedures?: Record<string, HttpRpc<any, any, any> | WebsocketRpc<any, any>>): ArriService;
 
 type DefinitionMap = Record<string, SchemaFormProperties | SchemaFormDiscriminator | SchemaFormValues>;
 declare const createAppDefinition: (def: AppDefinition) => AppDefinition;
-declare class ArriApp implements ArriRouterBase {
+declare class ArriApp {
     __isArri__: boolean;
     readonly h3App: App;
     readonly h3Router: Router;
@@ -257,9 +268,8 @@ declare class ArriApp implements ArriRouterBase {
     private readonly _debug;
     readonly definitionPath: string;
     constructor(opts?: ArriOptions);
-    use(input: Middleware | ArriRouter): void;
-    rpc<TIsEventStream extends boolean = false, TParams extends AObjectSchema<any, any> | undefined = undefined, TResponse extends AObjectSchema<any, any> | undefined = undefined>(procedure: Omit<NamedRpc<TIsEventStream, TParams, TResponse>, "transport">): void;
-    wsRpc<TParams extends RpcParamSchema | undefined, TResponse extends RpcParamSchema | undefined>(procedure: Omit<NamedWebsocketRpc<TParams, TResponse>, "transport">): void;
+    use(input: Middleware | ArriRouter | ArriService): void;
+    rpc(name: string, procedure: Rpc<any, any, any>): void;
     route<TPath extends string, TQuery extends AObjectSchema<any, any>, TBody extends ASchema<any>, TResponse = any>(route: ArriRoute<TPath, TQuery, TBody, TResponse>): void;
     registerDefinitions(definitions: DefinitionMap): void;
     getAppDefinition(): AppDefinition;
@@ -279,9 +289,12 @@ interface ArriOptions {
     disableDefaultRoute?: boolean;
     disableDefinitionRoute?: boolean;
     onRequest?: (event: MiddlewareEvent) => void | Promise<void>;
-    onAfterResponse?: (event: MiddlewareEvent) => void | Promise<void>;
-    onBeforeResponse?: (event: MiddlewareEvent) => void | Promise<void>;
-    onError?: (error: ArriServerError, event: MiddlewareEvent) => void | Promise<void>;
+    onAfterResponse?: (event: RequestHookEvent) => void | Promise<void>;
+    onBeforeResponse?: (event: RequestHookEvent) => void | Promise<void>;
+    onError?: (error: ArriServerError, event: RequestHookContext) => void | Promise<void>;
+}
+interface RequestHookEvent extends Omit<H3Event, "context"> {
+    context: RequestHookContext;
 }
 
-export { ArriApp, type ArriEventContext, type ArriOptions, type ArriRoute, ArriRouter, type ArriRouterBase, ArriServerError, ArriServerErrorResponse, type DefinitionMap, EventStreamConnection, type EventStreamConnectionOptions, type EventStreamRpc, type EventStreamRpcHandler, type EventStreamRpcHandlerContext, type ExtractParam, type ExtractParams, type HttpRpc, type Middleware, type MiddlewareEvent, type MiddlewareEventContext, type NamedRpc, type NamedWebsocketRpc, type PostRouteEvent, 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, createAppDefinition, createHttpRpcDefinition, createWsRpcDefinition, defineError, defineEventStreamRpc, defineMiddleware, defineRoute, defineRpc, defineWebsocketRpc, errorResponseFromValidationErrors, getRpcParamName, getRpcPath, getRpcResponseName, handleH3Error, handleRoute, isEventStreamRpc, isRpc, isRpcParamSchema, registerEventStreamRpc, registerRoute, registerRpc, registerWebsocketRpc, validateRpcRequestInput };
+export { ArriApp, type ArriEventContext, type ArriOptions, type ArriRoute, ArriRouter, ArriServerError, ArriServerErrorResponse, 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, 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 };

package/dist/index.mjs

@@ -2,20 +2,20 @@ import { isRpcHttpMethod, removeDisallowedChars, SCHEMA_VERSION } from '@arrirpc
 import { DEV_DEFINITION_ENDPOINT } from 'arri';
 import { isError, setResponseStatus, setResponseHeader, send, eventHandler, isPreflightRequest, readRawBody, getValidatedQuery, createEventStream, getHeader, defineEventHandler, getQuery, setHeader, defineWebSocketHandler, createRouter, createApp } from 'h3';
 export * from 'h3';
-import { a, isAObjectSchema, isADiscriminatorSchema } from '@arrirpc/schema';
+import { a, isAObjectSchema, isADiscriminatorSchema, isAdaptedSchema, validatorFromAdaptedSchema } from '@arrirpc/schema';
 import { kebabCase, pascalCase } from 'scule';
 
-var __defProp$4 = Object.defineProperty;
-var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$4 = (obj, key, value) => {
-  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$5 = Object.defineProperty;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$5 = (obj, key, value) => {
+  __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 class ArriServerError extends Error {
   constructor(err) {
     super(err.message);
-    __publicField$4(this, "code");
-    __publicField$4(this, "data");
+    __publicField$5(this, "code");
+    __publicField$5(this, "data");
     this.code = err.code;
     this.data = err.data;
     if (err.stack) {
@@ -323,12 +323,8 @@ function getRpcResponseDefinition(rpcName, procedure) {
   return name;
 }
 function registerRpc(router, path, procedure, opts) {
-  let responseValidator;
-  try {
-    responseValidator = procedure.response ? a.compile(procedure.response) : void 0;
-  } catch (err) {
-    console.error("ERROR COMPILING VALIDATOR", err);
-  }
+  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 httpMethod = procedure.method ?? "post";
   const handler = eventHandler(async (event) => {
     event.context.rpcName = procedure.name;
@@ -348,7 +344,8 @@ function registerRpc(router, path, procedure, opts) {
         await validateRpcRequestInput(
           event,
           httpMethod,
-          procedure.params
+          procedure.params,
+          paramValidator
         );
       }
       const response = await procedure.handler(
@@ -411,7 +408,7 @@ function registerRpc(router, path, procedure, opts) {
       break;
   }
 }
-async function validateRpcRequestInput(event, httpMethod, schema) {
+async function validateRpcRequestInput(event, httpMethod, schema, validator) {
   switch (httpMethod) {
     case "get": {
       const parsedParams = await getValidatedQuery(
@@ -450,8 +447,8 @@ async function validateRpcRequestInput(event, httpMethod, schema) {
           message: `Invalid request body. Expected object. Got undefined.`
         });
       }
-      const parsedParams = a.safeParse(schema, body);
-      if (!parsedParams.success) {
+      const parsedParams = validator.safeParse(body);
+      if (!parsedParams?.success) {
         const errorParts = [];
         for (const err of parsedParams.error.errors) {
           const errPath = err.instancePath.split("/");
@@ -472,11 +469,22 @@ async function validateRpcRequestInput(event, httpMethod, schema) {
     }
   }
 }
+function getSchemaValidator(rpcName, type, schema) {
+  try {
+    if (isAdaptedSchema(schema)) {
+      return validatorFromAdaptedSchema(schema);
+    }
+    return a.compile(schema);
+  } catch (err) {
+    console.error(`Error compiling ${type} validator for ${rpcName}`);
+    return void 0;
+  }
+}
 
-var __defProp$3 = Object.defineProperty;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$3 = (obj, key, value) => {
-  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => {
+  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 function defineEventStreamRpc(config) {
@@ -492,14 +500,14 @@ function isEventStreamRpc(input) {
 }
 class EventStreamConnection {
   constructor(event, opts) {
-    __publicField$3(this, "lastEventId");
-    __publicField$3(this, "validationErrors");
-    __publicField$3(this, "validator");
-    __publicField$3(this, "serializer");
+    __publicField$4(this, "lastEventId");
+    __publicField$4(this, "validationErrors");
+    __publicField$4(this, "validator");
+    __publicField$4(this, "serializer");
     // for some reason Rollup cannot output DTS when this is set to NodeJS.Timeout
-    __publicField$3(this, "pingInterval");
-    __publicField$3(this, "pingIntervalMs");
-    __publicField$3(this, "eventStream");
+    __publicField$4(this, "pingInterval");
+    __publicField$4(this, "pingIntervalMs");
+    __publicField$4(this, "eventStream");
     this.eventStream = createEventStream(event);
     this.lastEventId = getHeader(event, "Last-Event-Id");
     this.pingIntervalMs = opts.pingInterval ?? 6e4;
@@ -579,12 +587,8 @@ class EventStreamConnection {
   }
 }
 function registerEventStreamRpc(router, path, procedure, opts) {
-  let responseValidator;
-  try {
-    responseValidator = procedure.response ? a.compile(procedure.response) : void 0;
-  } catch (err) {
-    console.error("ERROR COMPILING VALIDATOR", err);
-  }
+  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 httpMethod = procedure.method ?? "get";
   const handler = eventHandler(async (event) => {
     event.context.rpcName = procedure.name;
@@ -604,7 +608,8 @@ function registerEventStreamRpc(router, path, procedure, opts) {
         await validateRpcRequestInput(
           event,
           httpMethod,
-          procedure.params
+          procedure.params,
+          paramValidator
         );
       }
       const stream = new EventStreamConnection(event, {
@@ -779,29 +784,53 @@ function handleRoute(router, method, route, opts) {
   }
 }
 
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => {
+  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class ArriRouter {
+  constructor(routePrefix = "") {
+    __publicField$3(this, "routes", []);
+    __publicField$3(this, "definitions", {});
+    __publicField$3(this, "prefix");
+    this.prefix = routePrefix;
+  }
+  route(route) {
+    route.path = `${this.prefix}${route.path}`;
+    this.routes.push(route);
+  }
+  registerDefinitions(models) {
+    for (const key of Object.keys(models)) {
+      this.definitions[key] = models[key];
+    }
+  }
+  getRoutes() {
+    return this.routes;
+  }
+  getDefinitions() {
+    return this.definitions;
+  }
+}
+
 var __defProp$2 = Object.defineProperty;
 var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField$2 = (obj, key, value) => {
   __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-class ArriRouter {
-  constructor() {
+class ArriService {
+  constructor(name) {
+    __publicField$2(this, "name");
     __publicField$2(this, "procedures", []);
-    __publicField$2(this, "routes", []);
     __publicField$2(this, "definitions", {});
+    this.name = name;
   }
-  rpc(procedure) {
-    procedure.transport = "http";
-    this.procedures.push(procedure);
-  }
-  wsRpc(procedure) {
-    procedure.transport = "ws";
+  rpc(name, procedure) {
+    procedure.name = `${this.name}.${name}`;
     this.procedures.push(procedure);
   }
-  route(route) {
-    this.routes.push(route);
-  }
   registerDefinitions(models) {
     for (const key of Object.keys(models)) {
       this.definitions[key] = models[key];
@@ -810,13 +839,17 @@ class ArriRouter {
   getProcedures() {
     return this.procedures;
   }
-  getRoutes() {
-    return this.routes;
-  }
   getDefinitions() {
     return this.definitions;
   }
 }
+function defineService(name, procedures) {
+  const service = new ArriService(name);
+  for (const key of Object.keys(procedures ?? {})) {
+    service.rpc(key, procedures[key]);
+  }
+  return service;
+}
 
 var __defProp$1 = Object.defineProperty;
 var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -998,14 +1031,21 @@ class ArriApp {
     if (!opts.disableDefinitionRoute) {
       this.h3Router.get(
         this.definitionPath,
-        eventHandler(() => this.getAppDefinition())
+        eventHandler((event) => {
+          setResponseHeader(
+            event,
+            "Content-Type",
+            "application/json"
+          );
+          return this.getAppDefinition();
+        })
       );
     }
     if (!opts.disableDefaultRoute) {
       this.route({
         method: ["get", "head"],
         path: "/",
-        handler: (_) => {
+        handler: async (_) => {
           const response = {
             title: this.appInfo?.title ?? "Arri-RPC Server",
             description: this.appInfo?.description ?? "This server utilizes Arri-RPC. Visit the schema path to see all of the available procedures.",
@@ -1028,7 +1068,14 @@ class ArriApp {
     if (process.env.ARRI_DEV_MODE === "true") {
       this.h3Router.get(
         DEV_DEFINITION_ENDPOINT,
-        eventHandler(() => this.getAppDefinition())
+        eventHandler((event) => {
+          setResponseHeader(
+            event,
+            "Content-Type",
+            "application/json"
+          );
+          return this.getAppDefinition();
+        })
       );
     }
     this.h3Router.use(
@@ -1055,23 +1102,27 @@ class ArriApp {
       for (const route of input.getRoutes()) {
         this.route(route);
       }
+      this.registerDefinitions(input.getDefinitions());
+      return;
+    }
+    if (typeof input === "object" && input instanceof ArriService) {
       for (const rpc of input.getProcedures()) {
-        if (rpc.transport === "http") {
-          this.rpc(rpc);
-        } else {
-          this.wsRpc(rpc);
-        }
+        this.rpc(rpc.name, rpc);
       }
       this.registerDefinitions(input.getDefinitions());
       return;
     }
     this._middlewares.push(input);
   }
-  rpc(procedure) {
-    procedure.transport = "http";
+  rpc(name, procedure) {
+    procedure.name = name;
     const p = procedure;
     const path = p.path ?? getRpcPath(p.name, this._rpcRoutePrefix);
-    this._procedures[p.name] = createHttpRpcDefinition(p.name, path, p);
+    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);
       if (paramName) {
@@ -1084,8 +1135,19 @@ class ArriApp {
         this._definitions[responseName] = p.response;
       }
     }
-    if (isEventStreamRpc(p)) {
-      registerEventStreamRpc(this.h3Router, path, p, {
+    if (p.transport === "http") {
+      if (isEventStreamRpc(p)) {
+        registerEventStreamRpc(this.h3Router, path, p, {
+          middleware: this._middlewares,
+          onRequest: this._onRequest,
+          onError: this._onError,
+          onAfterResponse: this._onAfterResponse,
+          onBeforeResponse: this._onBeforeResponse,
+          debug: this._debug
+        });
+        return;
+      }
+      registerRpc(this.h3Router, path, p, {
         middleware: this._middlewares,
         onRequest: this._onRequest,
         onError: this._onError,
@@ -1095,37 +1157,9 @@ class ArriApp {
       });
       return;
     }
-    registerRpc(this.h3Router, path, p, {
-      middleware: this._middlewares,
-      onRequest: this._onRequest,
-      onError: this._onError,
-      onAfterResponse: this._onAfterResponse,
-      onBeforeResponse: this._onBeforeResponse,
-      debug: this._debug
-    });
-  }
-  wsRpc(procedure) {
-    procedure.transport = "ws";
-    const p = procedure;
-    const path = procedure.path ?? getRpcPath(procedure.name, this._rpcRoutePrefix);
-    this._procedures[procedure.name] = createWsRpcDefinition(
-      procedure.name,
-      path,
-      p
-    );
-    if (isRpcParamSchema(procedure.params)) {
-      const paramName = getRpcParamName(procedure.name, p);
-      if (paramName) {
-        this._definitions[paramName] = procedure.params;
-      }
-    }
-    if (isRpcParamSchema(procedure.response)) {
-      const responseName = getRpcResponseName(procedure.name, p);
-      if (responseName) {
-        this._definitions[responseName] = procedure.response;
-      }
+    if (p.transport === "ws") {
+      registerWebsocketRpc(this.h3Router, path, p);
     }
-    registerWebsocketRpc(this.h3Router, path, p);
   }
   route(route) {
     registerRoute(this.h3Router, route, {
@@ -1159,4 +1193,4 @@ class ArriApp {
 
 const defineMiddleware = (middleware) => middleware;
 
-export { ArriApp, ArriRouter, ArriServerError, ArriServerErrorResponse, EventStreamConnection, WsPeer, createAppDefinition, createHttpRpcDefinition, createWsRpcDefinition, defineError, defineEventStreamRpc, defineMiddleware, defineRoute, defineRpc, defineWebsocketRpc, errorResponseFromValidationErrors, getRpcParamName, getRpcPath, getRpcResponseName, handleH3Error, handleRoute, isEventStreamRpc, isRpc, isRpcParamSchema, registerEventStreamRpc, registerRoute, registerRpc, registerWebsocketRpc, validateRpcRequestInput };
+export { ArriApp, ArriRouter, ArriServerError, ArriServerErrorResponse, ArriService, EventStreamConnection, WsPeer, 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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arrirpc/server",
-  "version": "0.55.0",
+  "version": "0.57.0",
   "type": "module",
   "license": "MIT",
   "author": {
@@ -28,12 +28,12 @@
     "scule": "^1.3.0",
     "source-map-support": "^0.5.21",
     "uncrypto": "^0.1.3",
-    "@arrirpc/codegen-dart": "0.55.0",
-    "@arrirpc/codegen-ts": "0.55.0",
-    "@arrirpc/codegen-utils": "0.55.0",
-    "@arrirpc/codegen-kotlin": "0.55.0",
-    "@arrirpc/schema": "0.55.0",
-    "arri": "0.55.0"
+    "@arrirpc/codegen-dart": "0.57.0",
+    "@arrirpc/codegen-kotlin": "0.57.0",
+    "@arrirpc/codegen-ts": "0.57.0",
+    "@arrirpc/codegen-utils": "0.57.0",
+    "@arrirpc/schema": "0.57.0",
+    "arri": "0.57.0"
   },
   "devDependencies": {
     "bun-types": "^1.1.20"