@arrirpc/server 0.73.0 → 0.74.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { isRpcHttpMethod, removeDisallowedChars, SCHEMA_VERSION } from '@arrirpc/codegen-utils';
-import { isError, setResponseStatus, setResponseHeader, send, eventHandler, isPreflightRequest, readRawBody, getValidatedQuery, createEventStream, getHeader, defineEventHandler, getQuery, setHeader, defineWebSocketHandler, createRouter, createApp } from 'h3';
+import { isError, setResponseStatus, setResponseHeader, send, eventHandler, isPreflightRequest, readRawBody, getValidatedQuery, createEventStream, getHeader, defineEventHandler, getQuery, setHeader, createRouter, createApp } from 'h3';
 export * from 'h3';
-import { a, isAObjectSchema, isADiscriminatorSchema, isAdaptedSchema, validatorFromAdaptedSchema } from '@arrirpc/schema';
+import { a, isAObjectSchema, isADiscriminatorSchema, errorMessageFromErrors, isASchema } from '@arrirpc/schema';
 import { kebabCase, pascalCase } from 'scule';
 
 class arriError extends Error {
@@ -289,20 +289,14 @@ function getRpcParamName(rpcName, procedure) {
   if (!isRpcParamSchema(procedure.params)) {
     return undefined;
   }
-  const nameParts = rpcName.split(".").map(
-    (part) => removeDisallowedChars(part, `!@#$%^&*()+=[]{}|\\;:'"<>,./?`)
-  );
-  const paramName = procedure.params.metadata.id ?? 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) => removeDisallowedChars(part, `!@#$%^&*()+=[]{}|\\;:'"<>,./?`)
-  );
-  const responseName = procedure.response.metadata.id ?? pascalCase(`${nameParts.join("_")}_response`);
+  const responseName = getSchemaName(rpcName, "response", procedure.response);
   return responseName;
 }
 function getRpcResponseDefinition(rpcName, procedure) {
@@ -337,7 +331,6 @@ function registerRpc(router, path, procedure, opts) {
         await validateRpcRequestInput(
           event,
           httpMethod,
-          procedure.params,
           paramValidator
         );
       }
@@ -350,18 +343,15 @@ function registerRpc(router, path, procedure, opts) {
         await opts.onBeforeResponse(event);
       }
       if (typeof response === "object") {
-        if (!responseValidator?.validate(response)) {
-          const errors = 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
           });
         }
         setResponseHeader(event, "Content-Type", "application/json");
-        await send(
-          event,
-          responseValidator?.serialize(response) ?? JSON.stringify(response)
-        );
+        await send(event, payload?.value ?? JSON.stringify(response));
       } else {
         setResponseHeader(event, "Content-Type", "application/json");
         await send(event, `{}`);
@@ -399,22 +389,22 @@ function registerRpc(router, path, procedure, opts) {
       break;
   }
 }
-async function validateRpcRequestInput(event, httpMethod, schema, validator) {
+async function validateRpcRequestInput(event, httpMethod, validator) {
   switch (httpMethod) {
     case "get": {
       const parsedParams = await getValidatedQuery(
         event,
-        (input) => a.safeCoerce(schema, 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);
           }
         }
@@ -423,7 +413,7 @@ async function validateRpcRequestInput(event, httpMethod, schema, validator) {
         )}]`;
         throw defineError(400, {
           message,
-          data: parsedParams.error
+          data: parsedParams.errors
         });
       }
       break;
@@ -438,21 +428,11 @@ async function validateRpcRequestInput(event, httpMethod, schema, 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: errorMessageFromErrors(parsedParams.errors),
+          data: parsedParams.errors
         });
       }
       event.context.params = parsedParams.value;
@@ -461,15 +441,31 @@ async function validateRpcRequestInput(event, httpMethod, schema, validator) {
   }
 }
 function getSchemaValidator(rpcName, type, schema) {
-  try {
-    if (isAdaptedSchema(schema)) {
-      return validatorFromAdaptedSchema(schema);
+  if (isASchema(schema)) {
+    try {
+      const validator = a.compile(schema);
+      return {
+        validate: validator.validate,
+        serialize: validator.serialize,
+        parse: validator.parse,
+        coerce: validator.coerce,
+        errors: (input) => a.errors(schema, input)
+      };
+    } catch (err) {
+      console.error(
+        `Error compiling ${type} validator for ${rpcName}. Error: ${err}`
+      );
     }
-    return a.compile(schema);
-  } catch (_) {
-    console.error(`Error compiling ${type} validator for ${rpcName}`);
-    return undefined;
   }
+  return undefined;
+}
+function getSchemaName(rpcName, type, schema) {
+  const cleanedName = rpcName.split(".").map(
+    (part) => removeDisallowedChars(part, `!@#$%^&*()+=[]{}|\\;:'"<>,./?`)
+  ).join("_");
+  return schema.metadata?.id ?? pascalCase(`${cleanedName}_${type}`, {
+    normalize: true
+  });
 }
 
 function defineEventStreamRpc(config) {
@@ -485,9 +481,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;
@@ -496,9 +490,7 @@ class EventStreamConnection {
     this.eventStream = createEventStream(event);
     this.lastEventId = 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();
     });
@@ -516,20 +508,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
@@ -538,15 +533,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
@@ -593,24 +588,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 a.errors(procedure.response, input);
-          }
-          return [];
-        }
+        validator: responseValidator
       });
       event.context.stream = stream;
       await procedure.handler(
@@ -673,10 +656,10 @@ function handleRoute(router, method, route, opts) {
       }
       if (route.query) {
         const query = getQuery(event);
-        const parsedQuery = a.safeCoerce(route.query, query);
+        const parsedQuery = 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(".");
@@ -701,21 +684,11 @@ function handleRoute(router, method, route, opts) {
       ];
       if (route.body && !notAllowedBodyMethods.includes(event.method)) {
         const body = await readRawBody(event);
-        const parsedBody = a.safeParse(route.body, body);
+        const parsedBody = 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: errorMessageFromErrors(parsedBody.errors),
+            data: parsedBody.errors
           });
         }
         event.context.body = parsedBody.value;
@@ -821,88 +794,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 = 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;
@@ -1013,8 +904,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);
@@ -1050,9 +939,6 @@ class ArriApp {
       });
       return;
     }
-    if (p.transport === "ws") {
-      registerWebsocketRpc(this.h3Router, path);
-    }
   }
   route(route) {
     registerRoute(this.h3Router, route, {
@@ -1086,4 +972,4 @@ class ArriApp {
 
 const defineMiddleware = (middleware) => middleware;
 
-export { ArriApp, ArriRouter, ArriService, EventStreamConnection, WsPeer, 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, ArriRouter, ArriService, EventStreamConnection, 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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arrirpc/server",
-  "version": "0.73.0",
+  "version": "0.74.0",
   "type": "module",
   "license": "MIT",
   "author": {
@@ -28,9 +28,9 @@
     "scule": "^1.3.0",
     "source-map-support": "^0.5.21",
     "uncrypto": "^0.1.3",
-    "@arrirpc/codegen-utils": "0.73.0",
-    "@arrirpc/schema": "0.73.0",
-    "arri": "0.73.0"
+    "@arrirpc/codegen-utils": "0.74.0",
+    "@arrirpc/schema": "0.74.0",
+    "arri": "0.74.0"
   },
   "devDependencies": {
     "bun-types": "^1.2.0"