@arrirpc/server 0.45.0

package/dist/index.cjs

@@ -0,0 +1,1223 @@
+'use strict';
+
+const codegenUtils = require('@arrirpc/codegen-utils');
+const arri = require('arri');
+const h3 = require('h3');
+const schema = require('@arrirpc/schema');
+const h3Sse = require('h3-sse');
+const scule = require('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);
+  return value;
+};
+class ArriServerError extends Error {
+  constructor(err) {
+    super(err.message);
+    __publicField$4(this, "code");
+    __publicField$4(this, "data");
+    this.code = err.code;
+    this.data = err.data;
+    if (err.stack) {
+      this.stack = err.stack;
+    }
+  }
+}
+const ArriServerErrorResponse = schema.a.object({
+  code: schema.a.int16(),
+  message: schema.a.string(),
+  stack: schema.a.optional(schema.a.array(schema.a.string())),
+  data: schema.a.optional(schema.a.any())
+});
+function defineError(statusCode, input = {}) {
+  const defaultVals = errorResponseDefaults[statusCode];
+  return new ArriServerError({
+    code: statusCode,
+    message: input.message ?? defaultVals?.message ?? "An unknown error occurred",
+    data: input.data
+  });
+}
+function errorResponseFromValidationErrors(errors, prefixText = `Missing or invalid parameters`) {
+  const errorParts = [];
+  for (const err of errors) {
+    const propName = err.instancePath?.split("/") ?? [];
+    if (propName.length > 0) {
+      propName.shift();
+    }
+    if (!errorParts.includes(propName.join("."))) {
+      errorParts.push(propName.join("."));
+    }
+  }
+  throw defineError(400, {
+    message: `${prefixText}: [${errorParts.join(",")}]`,
+    data: errors
+  });
+}
+const errorResponseDefaults = {
+  400: {
+    name: "BAD_REQUEST",
+    message: "Bad Request"
+  },
+  401: {
+    name: "UNAUTHORIZED",
+    message: "Unauthorized"
+  },
+  402: {
+    name: "PAYMENT_REQUIRED",
+    message: "Payment Required"
+  },
+  403: {
+    name: "FORBIDDEN",
+    message: "Forbidden"
+  },
+  404: {
+    name: "NOT_FOUND",
+    message: "Not Found"
+  },
+  405: {
+    name: "METHOD_NOT_ALLOWED",
+    message: "Method Not Allowed"
+  },
+  406: {
+    name: "NOT_ACCEPTABLE",
+    message: "Not Acceptable"
+  },
+  407: {
+    name: "PROXY_AUTHENTICATION_REQUIRED",
+    message: "Proxy Authentication Required"
+  },
+  408: {
+    name: "REQUEST_TIMEOUT",
+    message: "Request Timeout"
+  },
+  409: {
+    name: "CONFLICT",
+    message: "Conflict"
+  },
+  410: {
+    name: "GONE",
+    message: "Gone"
+  },
+  411: {
+    name: "LENGTH_REQUIRED",
+    message: "Length Required"
+  },
+  412: {
+    name: "PRECONDITION_FAILED",
+    message: "Precondition Failed"
+  },
+  413: {
+    name: "REQUEST_TOO_LONG",
+    message: "Request Entity Too Large"
+  },
+  414: {
+    name: "REQUEST_URI_TOO_LONG",
+    message: "Request-URI Too Long"
+  },
+  415: {
+    name: "UNSUPPORTED_MEDIA_TYPE",
+    message: "Unsupported Media Type"
+  },
+  416: {
+    name: "REQUESTED_RANGE_NOT_SATISFIABLE",
+    message: "Requested Range Not Satisfiable"
+  },
+  417: {
+    name: "EXPECTATION_FAILED",
+    message: "Expectation Failed"
+  },
+  418: {
+    name: "IM_A_TEAPOT",
+    message: "I'm a teapot"
+  },
+  419: {
+    name: "INSUFFICIENT_SPACE_ON_RESOURCE",
+    message: "Insufficient Space on Resource"
+  },
+  420: {
+    name: "METHOD_FAILURE",
+    message: "Method Failure"
+  },
+  421: {
+    name: "MISDIRECTED_REQUEST",
+    message: "Misdirected Request"
+  },
+  422: {
+    name: "UNPROCESSABLE_ENTITY",
+    message: "Unprocessable Entity"
+  },
+  423: {
+    name: "LOCKED",
+    message: "Locked"
+  },
+  424: {
+    name: "FAILED_DEPENDENCY",
+    message: "Failed Dependency"
+  },
+  428: {
+    name: "PRECONDITION_REQUIRED",
+    message: "Precondition Required"
+  },
+  429: {
+    name: "TOO_MANY_REQUESTS",
+    message: "Too Many Requests"
+  },
+  431: {
+    name: "REQUEST_HEADER_FIELDS_TOO_LARGE",
+    message: "Request Header Fields Too Large"
+  },
+  451: {
+    name: "UNAVAILABLE_FOR_LEGAL_REASONS",
+    message: "Unavailable For Legal Reasons"
+  },
+  500: {
+    name: "INTERNAL_SERVER_ERROR",
+    message: "Internal Server Error"
+  },
+  501: {
+    name: "NOT_IMPLEMENTED",
+    message: "Not Implemented"
+  },
+  502: {
+    name: "BAD_GATEWAY",
+    message: "Bad Gateway"
+  },
+  503: {
+    name: "SERVICE_UNAVAILABLE",
+    message: "Service Unavailable"
+  },
+  504: {
+    name: "GATEWAY_TIMEOUT",
+    message: "Gateway Timeout"
+  },
+  505: {
+    name: "HTTP_VERSION_NOT_SUPPORTED",
+    message: "HTTP Version Not Supported"
+  },
+  507: {
+    name: "INSUFFICIENT_STORAGE",
+    message: "Insufficient Storage"
+  },
+  511: {
+    name: "NETWORK_AUTHENTICATION_REQUIRED",
+    message: "Network Authentication Required"
+  }
+};
+async function handleH3Error(err, event, onError, debug) {
+  let arriErr;
+  if (err instanceof ArriServerError) {
+    arriErr = err;
+  } else if (h3.isError(err)) {
+    arriErr = new ArriServerError({
+      code: err.statusCode,
+      message: err.message,
+      stack: err.stack,
+      data: err.data
+    });
+  } else if (err instanceof Error) {
+    arriErr = new ArriServerError({
+      code: 500,
+      message: err.message,
+      data: err,
+      stack: err.stack
+    });
+  } else {
+    arriErr = new ArriServerError({
+      code: 500,
+      message: `An unknown error occurred`,
+      data: err
+    });
+  }
+  if (!arriErr) {
+    return;
+  }
+  h3.setResponseStatus(event, arriErr.code);
+  if (onError) {
+    await onError(arriErr, event);
+  }
+  if (event.handled) {
+    return;
+  }
+  return sendArriError(event, arriErr, debug);
+}
+async function sendArriError(event, error, debug) {
+  const payload = {
+    code: error.code,
+    message: error.message,
+    data: error.data
+  };
+  if (debug) {
+    payload.stack = error.stack?.split("\n").map((l) => l.trim());
+  }
+  h3.setResponseHeader(event, "Content-Type", "application/json");
+  h3.setResponseStatus(event, error.code);
+  return h3.send(event, JSON.stringify(payload));
+}
+
+function isRpcParamSchema(input) {
+  return schema.isAObjectSchema(input) || schema.isADiscriminatorSchema(input);
+}
+function isRpc(input) {
+  return typeof input === "object" && input !== null && "method" in input && codegenUtils.isRpcHttpMethod(input.method) && "handler" in input && typeof input.handler === "function";
+}
+function defineRpc(config) {
+  config.transport = "http";
+  return config;
+}
+function createHttpRpcDefinition(rpcName, httpPath, procedure) {
+  let method;
+  if (procedure.isEventStream === true) {
+    method = procedure.method ?? "get";
+  } else {
+    method = procedure.method ?? "post";
+  }
+  return {
+    transport: "http",
+    description: procedure.description,
+    path: httpPath,
+    method,
+    params: getRpcParamName(rpcName, procedure),
+    response: getRpcResponseDefinition(rpcName, procedure),
+    isDeprecated: procedure.isDeprecated,
+    isEventStream: procedure.isEventStream === true ? true : void 0
+  };
+}
+function getRpcPath(rpcName, prefix = "") {
+  const path = rpcName.split(".").map(
+    (part) => codegenUtils.removeDisallowedChars(
+      scule.kebabCase(part),
+      `!@#$%^&*()+=[]{}|\\;:'"<>,./?`
+    )
+  ).join("/");
+  const finalPath = prefix ? `/${prefix}/${path}` : `/${path}`;
+  return finalPath;
+}
+function getRpcParamName(rpcName, procedure) {
+  if (!isRpcParamSchema(procedure.params)) {
+    return void 0;
+  }
+  const nameParts = rpcName.split(".").map(
+    (part) => codegenUtils.removeDisallowedChars(part, `!@#$%^&*()+=[]{}|\\;:'"<>,./?`)
+  );
+  const paramName = procedure.params.metadata.id ?? scule.pascalCase(`${nameParts.join(`_`)}_params`);
+  return paramName;
+}
+function getRpcResponseName(rpcName, procedure) {
+  if (!isRpcParamSchema(procedure.response)) {
+    return void 0;
+  }
+  const nameParts = rpcName.split(".").map(
+    (part) => codegenUtils.removeDisallowedChars(part, `!@#$%^&*()+=[]{}|\\;:'"<>,./?`)
+  );
+  const responseName = procedure.response.metadata.id ?? scule.pascalCase(`${nameParts.join("_")}_response`);
+  return responseName;
+}
+function getRpcResponseDefinition(rpcName, procedure) {
+  if (!isRpcParamSchema(procedure.response)) {
+    return void 0;
+  }
+  const name = getRpcResponseName(rpcName, procedure);
+  if (!name) {
+    return void 0;
+  }
+  return name;
+}
+function registerRpc(router, path, procedure, opts) {
+  let responseValidator;
+  try {
+    responseValidator = procedure.response ? schema.a.compile(procedure.response) : void 0;
+  } catch (err) {
+    console.error("ERROR COMPILING VALIDATOR", err);
+  }
+  const httpMethod = procedure.method ?? "post";
+  const handler = h3.eventHandler(async (event) => {
+    event.context.rpcName = procedure.name;
+    if (h3.isPreflightRequest(event)) {
+      return "ok";
+    }
+    try {
+      if (opts.onRequest) {
+        await opts.onRequest(event);
+      }
+      if (opts.middleware.length) {
+        for (const m of opts.middleware) {
+          await m(event);
+        }
+      }
+      if (isRpcParamSchema(procedure.params)) {
+        await validateRpcRequestInput(
+          event,
+          httpMethod,
+          procedure.params
+        );
+      }
+      const response = await procedure.handler(
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        event.context,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        event
+      );
+      event.context.response = response;
+      if (opts.onBeforeResponse) {
+        await opts.onBeforeResponse(event);
+      }
+      if (typeof response === "object") {
+        if (!responseValidator?.validate(response)) {
+          const errors = schema.a.errors(procedure.response, response);
+          throw defineError(500, {
+            message: "Failed to serialize response. Response does not match specified schema",
+            data: errors
+          });
+        }
+        h3.setResponseHeader(event, "Content-Type", "application/json");
+        await h3.send(
+          event,
+          responseValidator?.serialize(response) ?? JSON.stringify(response)
+        );
+      } else {
+        h3.setResponseHeader(event, "Content-Type", "application/json");
+        await h3.send(event, `{}`);
+      }
+      if (opts.onAfterResponse) {
+        await opts.onAfterResponse(event);
+      }
+      if (procedure.postHandler) {
+        await procedure.postHandler(
+          event.context,
+          event
+        );
+      }
+    } catch (err) {
+      await handleH3Error(err, event, opts.onError, opts.debug ?? false);
+    }
+    return "";
+  });
+  switch (httpMethod) {
+    case "get":
+      router.get(path, handler);
+      break;
+    case "delete":
+      router.delete(path, handler);
+      break;
+    case "patch":
+      router.patch(path, handler);
+      break;
+    case "put":
+      router.put(path, handler);
+      break;
+    case "post":
+    default:
+      router.post(path, handler);
+      break;
+  }
+}
+async function validateRpcRequestInput(event, httpMethod, schema$1) {
+  switch (httpMethod) {
+    case "get": {
+      const parsedParams = await h3.getValidatedQuery(
+        event,
+        (input) => schema.a.safeCoerce(schema$1, 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)) {
+            errParts.push(propName);
+          }
+        }
+        const message = `Missing or invalid url query parameters: [${errParts.join(
+          ", "
+        )}]`;
+        throw defineError(400, {
+          message,
+          data: parsedParams.error
+        });
+      }
+      break;
+    }
+    case "delete":
+    case "patch":
+    case "post":
+    case "put": {
+      const body = await h3.readRawBody(event);
+      if (!body) {
+        throw defineError(400, {
+          message: `Invalid request body. Expected object. Got undefined.`
+        });
+      }
+      const parsedParams = schema.a.safeParse(schema$1, 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
+        });
+      }
+      event.context.params = parsedParams.value;
+      break;
+    }
+  }
+}
+
+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;
+};
+function defineEventStreamRpc(config) {
+  return {
+    ...config,
+    method: config.method ?? "get",
+    isEventStream: true,
+    transport: "http"
+  };
+}
+function isEventStreamRpc(input) {
+  return isRpc(input) && "isEventStream" in input && input.isEventStream === true;
+}
+class EventStreamConnection {
+  constructor(event, opts) {
+    __publicField$3(this, "lastEventId");
+    __publicField$3(this, "validationErrors");
+    __publicField$3(this, "validator");
+    __publicField$3(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");
+    this.eventStream = h3Sse.createEventStream(event);
+    this.lastEventId = this.eventStream.lastEventId;
+    this.pingIntervalMs = opts.pingInterval ?? 6e4;
+    this.serializer = opts.serializer;
+    this.validator = opts.validator;
+    this.validationErrors = opts.validationErrors;
+    this.eventStream.onClose(() => {
+      this.cleanup();
+    });
+  }
+  /**
+   * Send the stream to the client. This must be called before sending any events.
+   */
+  send() {
+    void this.eventStream.send();
+    this.pingInterval = setInterval(async () => {
+      await this.eventStream.push({
+        event: "ping",
+        data: ""
+      });
+    }, this.pingIntervalMs);
+  }
+  async push(data, eventId) {
+    if (Array.isArray(data)) {
+      const events = [];
+      for (const item of data) {
+        if (this.validator(item)) {
+          events.push({
+            id: eventId,
+            event: "message",
+            data: this.serializer(item)
+          });
+          continue;
+        }
+        const errors2 = this.validationErrors(item);
+        const errorResponse2 = defineError(500, {
+          message: "Failed to serialize response. Response does not match specified schema.",
+          data: errors2
+        });
+        events.push({
+          id: eventId,
+          event: "error",
+          data: JSON.stringify(errorResponse2)
+        });
+      }
+      await this.eventStream.push(events);
+      return;
+    }
+    if (this.validator(data)) {
+      await this.eventStream.push({
+        id: eventId,
+        event: "message",
+        data: this.serializer(data)
+      });
+      return;
+    }
+    const errors = this.validationErrors(data);
+    const errorResponse = defineError(500, {
+      message: "Failed to serialize response. Response does not match specified schema.",
+      data: errors
+    });
+    await this.eventStream.push({
+      id: eventId,
+      event: "error",
+      data: JSON.stringify(errorResponse)
+    });
+  }
+  // /**
+  //  * Push a custom event. These events will need to be parsed manually using the `onEvent` hooks of any generated clients.
+  //  * Note events with the name "error" or "message" cannot be used for custom events.
+  //  */
+  // async pushCustomEvent(event: SseEvent): Promise<void> {
+  //     if (event.event === "message") {
+  //         throw new Error(
+  //             `Event type "message" is the default event type. Therefore it cannot be used when pushing custom events.`,
+  //         );
+  //     }
+  //     if (event.event === "error") {
+  //         throw new Error(
+  //             `Event type "error" is reserved for the pushError() method. Therefore it cannot be used when pushing custom events.`,
+  //         );
+  //     }
+  // }
+  /**
+   * Publish an error event. This will trigger the `onError` hooks of any connected clients.
+   */
+  async pushError(error, eventId) {
+    await this.eventStream.push({
+      id: eventId,
+      event: "error",
+      data: JSON.stringify(error)
+    });
+  }
+  cleanup() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+    }
+  }
+  /**
+   * Tell clients that the stream has ended and close the connection.
+   */
+  async close() {
+    await this.eventStream.push({
+      event: "done",
+      data: "this stream has ended"
+    }).catch();
+    await this.eventStream.close();
+  }
+  onClose(cb) {
+    this.eventStream.onClose(cb);
+  }
+}
+function registerEventStreamRpc(router, path, procedure, opts) {
+  let responseValidator;
+  try {
+    responseValidator = procedure.response ? schema.a.compile(procedure.response) : void 0;
+  } catch (err) {
+    console.error("ERROR COMPILING VALIDATOR", err);
+  }
+  const httpMethod = procedure.method ?? "get";
+  const handler = h3.eventHandler(async (event) => {
+    event.context.rpcName = procedure.name;
+    if (h3.isPreflightRequest(event)) {
+      return "ok";
+    }
+    try {
+      if (opts.onRequest) {
+        await opts.onRequest(event);
+      }
+      if (opts.middleware.length) {
+        for (const m of opts.middleware) {
+          await m(event);
+        }
+      }
+      if (isRpcParamSchema(procedure.params)) {
+        await validateRpcRequestInput(
+          event,
+          httpMethod,
+          procedure.params
+        );
+      }
+      const stream = new EventStreamConnection(event, {
+        pingInterval: procedure.pingInterval,
+        validator: responseValidator?.validate ?? function() {
+          return true;
+        },
+        serializer: (
+          // eslint-disable-next-line @typescript-eslint/unbound-method
+          responseValidator?.serialize ?? function(_) {
+            return "";
+          }
+        ),
+        validationErrors(input) {
+          if (procedure.response) {
+            return schema.a.errors(procedure.response, input);
+          }
+          return [];
+        }
+      });
+      event.context.stream = stream;
+      await procedure.handler(
+        event.context,
+        event
+      );
+      if (!event.handled && !stream.eventStream._handled) {
+        stream.send();
+      }
+    } catch (err) {
+      await handleH3Error(err, event, opts.onError, opts.debug ?? false);
+    }
+    return "";
+  });
+  switch (httpMethod) {
+    case "get":
+      router.get(path, handler);
+      break;
+    case "delete":
+      router.delete(path, handler);
+      break;
+    case "patch":
+      router.patch(path, handler);
+      break;
+    case "put":
+      router.put(path, handler);
+      break;
+    case "post":
+    default:
+      router.post(path, handler);
+      break;
+  }
+}
+
+function defineRoute(route) {
+  return route;
+}
+function registerRoute(router, route, opts) {
+  if (typeof route.method === "string") {
+    handleRoute(router, route.method, route, opts);
+    return;
+  }
+  for (const method of route.method) {
+    handleRoute(router, method, route, opts);
+  }
+}
+function handleRoute(router, method, route, opts) {
+  const handler = h3.defineEventHandler(async (event) => {
+    if (h3.isPreflightRequest(event)) {
+      return "ok";
+    }
+    try {
+      if (opts.onRequest) {
+        await opts.onRequest(event);
+      }
+      if (opts.middleware.length) {
+        for (const m of opts.middleware) {
+          await m(event);
+        }
+      }
+      if (route.query) {
+        const query = h3.getQuery(event);
+        const parsedQuery = schema.a.safeCoerce(route.query, query);
+        if (!parsedQuery.success) {
+          const errParts = [];
+          for (const err of parsedQuery.error.errors) {
+            const errPath = err.instancePath.split("/");
+            errPath.shift();
+            const propName = errPath.join(".");
+            if (!errParts.includes(propName)) {
+              errParts.push(propName);
+            }
+          }
+          const message = `Missing or invalid url query parameters: [${errParts.join(
+            ", "
+          )}]`;
+          throw defineError(400, {
+            message
+          });
+        }
+        event.context.query = parsedQuery.value;
+      }
+      const notAllowedBodyMethods = [
+        "GET",
+        "HEAD",
+        "CONNECT",
+        "OPTIONS"
+      ];
+      if (route.body && !notAllowedBodyMethods.includes(event.method)) {
+        const body = await h3.readRawBody(event);
+        const parsedBody = schema.a.safeParse(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
+          });
+        }
+        event.context.body = parsedBody.value;
+      }
+      const response = await route.handler(event);
+      event.context.response = response;
+      if (!event.handled) {
+        if (opts.onBeforeResponse) {
+          await opts.onBeforeResponse(event);
+        }
+        if (typeof response === "object" && response) {
+          h3.setHeader(event, "Content-Type", "application/json");
+          await h3.send(event, JSON.stringify(response));
+        } else {
+          await h3.send(event, response);
+        }
+      }
+      if (opts.onAfterResponse) {
+        await opts.onAfterResponse(event);
+      }
+      if (route.postHandler) {
+        await route.postHandler(event);
+      }
+    } catch (err) {
+      await handleH3Error(err, event, opts.onError, opts.debug ?? false);
+    }
+    return "";
+  });
+  switch (method) {
+    case "head":
+      router.head(route.path, handler);
+      break;
+    case "get":
+      router.get(route.path, handler);
+      break;
+    case "delete":
+      router.delete(route.path, handler);
+      break;
+    case "patch":
+      router.patch(route.path, handler);
+      break;
+    case "post":
+      router.post(route.path, handler);
+      break;
+    case "put":
+      router.put(route.path, handler);
+      break;
+  }
+}
+
+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() {
+    __publicField$2(this, "procedures", []);
+    __publicField$2(this, "routes", []);
+    __publicField$2(this, "definitions", {});
+  }
+  rpc(procedure) {
+    procedure.transport = "http";
+    this.procedures.push(procedure);
+  }
+  wsRpc(procedure) {
+    procedure.transport = "ws";
+    this.procedures.push(procedure);
+  }
+  route(route) {
+    this.routes.push(route);
+  }
+  registerDefinitions(models) {
+    for (const key of Object.keys(models)) {
+      this.definitions[key] = models[key];
+    }
+  }
+  getProcedures() {
+    return this.procedures;
+  }
+  getRoutes() {
+    return this.routes;
+  }
+  getDefinitions() {
+    return this.definitions;
+  }
+}
+
+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;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class WsPeer {
+  constructor(peer, opts) {
+    __publicField$1(this, "_peer");
+    __publicField$1(this, "_validator");
+    __publicField$1(this, "context");
+    __publicField$1(this, "url");
+    this._peer = peer;
+    this._validator = opts.validator;
+    this.url = peer.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);
+  }
+  readyState() {
+    return this._peer.readyState;
+  }
+}
+function defineWebsocketRpc(def) {
+  def.transport = "ws";
+  return def;
+}
+function registerWebsocketRpc(router, path, rpc) {
+  let responseValidator;
+  let paramValidator;
+  try {
+    responseValidator = rpc.response ? schema.a.compile(rpc.response) : void 0;
+  } catch (err) {
+    console.error("ERROR COMPILING VALIDATOR", err);
+  }
+  try {
+    paramValidator = rpc.params ? schema.a.compile(rpc.params) : void 0;
+  } catch (err) {
+    console.error("ERROR COMPILING PARAMS", err);
+  }
+  const rpcHandler = typeof rpc.handler === "function" ? rpc.handler() : rpc.handler;
+  const handler = h3.defineWebSocketHandler({
+    upgrade(req) {
+    },
+    open(peer) {
+      const urlParts = peer.url.split("?");
+      const context = {
+        rpcName: rpc.name,
+        clientAddress: peer.addr
+      };
+      if (urlParts.length > 1) {
+        urlParts.shift();
+        const queryStr = new URLSearchParams(urlParts.join("?"));
+        const query = {};
+        for (const [key, val] of queryStr.entries()) {
+          query[key] = val;
+        }
+        context.queryParams = query;
+      }
+      const wsPeer = new WsPeer(peer, {
+        validator: responseValidator,
+        context
+      });
+      peer.ctx.__wsPeer = wsPeer;
+      rpcHandler.onOpen(peer.ctx.__wsPeer);
+    },
+    message(peer, message) {
+      if (!paramValidator) {
+        return;
+      }
+      const data = paramValidator.safeParse(message.text());
+      if (!data.success) {
+        const errorResponse = {
+          code: 400,
+          message: data.error.message,
+          data: data.error.errors,
+          stack: data.error.stack?.split("\n")
+        };
+        peer.ctx.__wsPeer.sendError(errorResponse);
+        return;
+      }
+      rpcHandler.onMessage(peer.ctx.__wsPeer, data.value);
+    },
+    close(peer, details) {
+      rpcHandler.onClose(peer.ctx.__wsPeer, details);
+    }
+  });
+  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
+  };
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const createAppDefinition = (def) => def;
+class ArriApp {
+  constructor(opts = {}) {
+    __publicField(this, "__isArri__", true);
+    __publicField(this, "h3App");
+    __publicField(this, "h3Router", h3.createRouter());
+    __publicField(this, "_rpcDefinitionPath");
+    __publicField(this, "_rpcRoutePrefix");
+    __publicField(this, "appInfo");
+    __publicField(this, "_procedures", {});
+    __publicField(this, "_definitions", {});
+    __publicField(this, "_middlewares", []);
+    __publicField(this, "_onRequest");
+    __publicField(this, "_onAfterResponse");
+    __publicField(this, "_onBeforeResponse");
+    __publicField(this, "_onError");
+    __publicField(this, "_debug");
+    __publicField(this, "definitionPath");
+    this.appInfo = opts?.appInfo;
+    this.h3App = h3.createApp({
+      debug: opts?.debug
+    });
+    this._debug = opts.debug ?? false;
+    this._onRequest = opts.onRequest;
+    this._onError = opts.onError;
+    this._onAfterResponse = opts.onAfterResponse;
+    this._onBeforeResponse = opts.onBeforeResponse;
+    this._rpcRoutePrefix = opts?.rpcRoutePrefix ?? "";
+    this._rpcDefinitionPath = opts?.rpcDefinitionPath ?? "__definition";
+    this.h3App.use(this.h3Router);
+    this.definitionPath = this._rpcRoutePrefix ? `/${this._rpcRoutePrefix}/${this._rpcDefinitionPath}`.split("//").join("/") : `/${this._rpcDefinitionPath}`;
+    this.h3Router.get(
+      this.definitionPath,
+      h3.eventHandler(() => this.getAppDefinition())
+    );
+    if (!opts.disableDefaultRoute) {
+      this.route({
+        method: ["get", "head"],
+        path: "/",
+        handler: (_) => {
+          let schemaPath;
+          if (this._rpcRoutePrefix) {
+            schemaPath = `/${this._rpcRoutePrefix}/${this._rpcDefinitionPath}`;
+          } else {
+            schemaPath = `/${this._rpcDefinitionPath}`;
+          }
+          return {
+            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.",
+            schemaPath,
+            ...this.appInfo
+          };
+        }
+      });
+    }
+    if (process.env.ARRI_DEV_MODE === "true") {
+      this.h3Router.get(
+        arri.DEV_DEFINITION_ENDPOINT,
+        h3.eventHandler(() => this.getAppDefinition())
+      );
+    }
+    this.h3Router.use(
+      "/**",
+      h3.eventHandler(async (event) => {
+        h3.setResponseStatus(event, 404);
+        const error = defineError(404);
+        try {
+          if (this._onRequest) {
+            await this._onRequest(event);
+          }
+        } catch (err) {
+          await handleH3Error(err, event, this._onError, this._debug);
+        }
+        if (event.handled) {
+          return;
+        }
+        return handleH3Error(error, event, this._onError, this._debug);
+      })
+    );
+  }
+  use(input) {
+    if (typeof input === "object" && input instanceof ArriRouter) {
+      for (const route of input.getRoutes()) {
+        this.route(route);
+      }
+      for (const rpc of input.getProcedures()) {
+        if (rpc.transport === "http") {
+          this.rpc(rpc);
+        } else {
+          this.wsRpc(rpc);
+        }
+      }
+      this.registerDefinitions(input.getDefinitions());
+      return;
+    }
+    this._middlewares.push(input);
+  }
+  rpc(procedure) {
+    procedure.transport = "http";
+    const p = procedure;
+    const path = p.path ?? getRpcPath(p.name, this._rpcRoutePrefix);
+    this._procedures[p.name] = createHttpRpcDefinition(p.name, path, p);
+    if (isRpcParamSchema(p.params)) {
+      const paramName = getRpcParamName(p.name, p);
+      if (paramName) {
+        this._definitions[paramName] = p.params;
+      }
+    }
+    if (isRpcParamSchema(p.response)) {
+      const responseName = getRpcResponseName(p.name, p);
+      if (responseName) {
+        this._definitions[responseName] = p.response;
+      }
+    }
+    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,
+      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;
+      }
+    }
+    registerWebsocketRpc(this.h3Router, path, p);
+  }
+  route(route) {
+    registerRoute(this.h3Router, route, {
+      middleware: this._middlewares,
+      onRequest: this._onRequest,
+      onError: this._onError,
+      onAfterResponse: this._onAfterResponse,
+      onBeforeResponse: this._onBeforeResponse,
+      debug: this._debug
+    });
+  }
+  registerDefinitions(definitions) {
+    for (const key of Object.keys(definitions)) {
+      this._definitions[key] = definitions[key];
+    }
+  }
+  getAppDefinition() {
+    const appDef = {
+      arriSchemaVersion: codegenUtils.SCHEMA_VERSION,
+      info: this.appInfo,
+      procedures: {},
+      definitions: this._definitions
+    };
+    for (const key of Object.keys(this._procedures)) {
+      const rpc = this._procedures[key];
+      appDef.procedures[key] = rpc;
+    }
+    return appDef;
+  }
+}
+
+const defineMiddleware = (middleware) => middleware;
+
+exports.ArriApp = ArriApp;
+exports.ArriRouter = ArriRouter;
+exports.ArriServerError = ArriServerError;
+exports.ArriServerErrorResponse = ArriServerErrorResponse;
+exports.EventStreamConnection = EventStreamConnection;
+exports.WsPeer = WsPeer;
+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.defineWebsocketRpc = defineWebsocketRpc;
+exports.errorResponseFromValidationErrors = errorResponseFromValidationErrors;
+exports.getRpcParamName = getRpcParamName;
+exports.getRpcPath = getRpcPath;
+exports.getRpcResponseName = getRpcResponseName;
+exports.handleH3Error = handleH3Error;
+exports.handleRoute = handleRoute;
+exports.isEventStreamRpc = isEventStreamRpc;
+exports.isRpc = isRpc;
+exports.isRpcParamSchema = isRpcParamSchema;
+exports.registerEventStreamRpc = registerEventStreamRpc;
+exports.registerRoute = registerRoute;
+exports.registerRpc = registerRpc;
+exports.registerWebsocketRpc = registerWebsocketRpc;
+exports.validateRpcRequestInput = validateRpcRequestInput;
+Object.keys(h3).forEach(function (k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = h3[k];
+});