arri 0.13.0 → 0.15.1

package/dist/shared/{arri.cc0da87a.mjs → arri.28516ef9.mjs}

@@ -1,4 +1,4 @@
-import { createError, isError, setResponseStatus, send, eventHandler, isPreflightRequest, readRawBody, getValidatedQuery, setResponseHeader, defineEventHandler, getQuery, setHeader, createRouter, createApp, sendError } from 'h3';
+import { createError, isError, setResponseStatus, send, eventHandler, isPreflightRequest, setResponseHeader, readRawBody, getValidatedQuery, setHeaders, getHeader, sendStream, defineEventHandler, getQuery, setHeader, createRouter, createApp, sendError } from 'h3';
 import { a, isAObjectSchema, isARecordSchema, isADiscriminatorSchema } from 'arri-validate';
 import { isRpcHttpMethod, removeDisallowedChars } from 'arri-codegen-utils';
 import { kebabCase, pascalCase } from 'scule';
@@ -208,28 +208,25 @@ function isRpcParamSchema(input) {
   return isAObjectSchema(input) || isARecordSchema(input) || isADiscriminatorSchema(input);
 }
 function isRpc(input) {
-  if (typeof input !== "object" || input === null) {
-    return false;
-  }
-  const anyInput = input;
-  if (!isRpcHttpMethod(anyInput.method)) {
-    return false;
-  }
-  if (typeof anyInput.handler !== "function") {
-    return false;
-  }
-  return true;
+  return typeof input === "object" && input !== null && "method" in input && isRpcHttpMethod(input.method) && "handler" in input && typeof input.handler === "function";
 }
 function defineRpc(config) {
   return config;
 }
 function createRpcDefinition(rpcName, httpPath, procedure) {
+  let method;
+  if (procedure.isEventStream === true) {
+    method = procedure.method ?? "get";
+  } else {
+    method = procedure.method ?? "post";
+  }
   return {
     description: procedure.description,
     path: httpPath,
-    method: procedure.method ?? "post",
+    method,
     params: getRpcParamName(rpcName, procedure),
-    response: getRpcResponseDefinition(rpcName, procedure)
+    response: getRpcResponseDefinition(rpcName, procedure),
+    isEventStream: procedure.isEventStream === true ? true : void 0
   };
 }
 function getRpcPath(rpcName, prefix = "") {
@@ -295,70 +292,11 @@ function registerRpc(router, path, procedure, opts) {
         }
       }
       if (isRpcParamSchema(procedure.params)) {
-        switch (httpMethod) {
-          case "get": {
-            const parsedParams = await getValidatedQuery(
-              event,
-              (input) => a.safeCoerce(procedure.params, 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, {
-                statusMessage: message,
-                data: parsedParams.error
-              });
-            }
-            break;
-          }
-          case "delete":
-          case "patch":
-          case "post":
-          case "put": {
-            const body = await readRawBody(event);
-            if (!body) {
-              throw defineError(400, {
-                statusMessage: `Invalid request body. Expected object. Got undefined.`
-              });
-            }
-            const parsedParams = a.safeParse(
-              procedure.params,
-              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, {
-                statusMessage: `Invalid request body. Affected properties [${errorParts.join(
-                  ", "
-                )}]`,
-                data: parsedParams.error
-              });
-            }
-            event.context.params = parsedParams.value;
-            break;
-          }
-          default:
-            break;
-        }
+        await validateRpcRequestInput(
+          event,
+          httpMethod,
+          procedure.params
+        );
       }
       const response = await procedure.handler(
         event.context,
@@ -408,29 +346,297 @@ function registerRpc(router, path, procedure, opts) {
       break;
   }
 }
+async function validateRpcRequestInput(event, httpMethod, schema) {
+  switch (httpMethod) {
+    case "get": {
+      const parsedParams = await getValidatedQuery(
+        event,
+        (input) => a.safeCoerce(schema, 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, {
+          statusMessage: message,
+          data: parsedParams.error
+        });
+      }
+      break;
+    }
+    case "delete":
+    case "patch":
+    case "post":
+    case "put": {
+      const body = await readRawBody(event);
+      if (!body) {
+        throw defineError(400, {
+          statusMessage: `Invalid request body. Expected object. Got undefined.`
+        });
+      }
+      const parsedParams = a.safeParse(schema, 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, {
+          statusMessage: `Invalid request body. Affected properties [${errorParts.join(
+            ", "
+          )}]`,
+          data: parsedParams.error
+        });
+      }
+      event.context.params = parsedParams.value;
+      break;
+    }
+  }
+}
 
-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);
+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$1(this, "procedures", []);
-    __publicField$1(this, "routes", []);
+function setSseHeaders(event) {
+  setHeaders(event, {
+    "Transfer-Encoding": "chunked",
+    "Content-Type": "text/event-stream",
+    Connection: "keep-alive",
+    "Cache-Control": "no-cache"
+  });
+}
+function defineEventStreamRpc(config) {
+  return {
+    ...config,
+    method: config.method ?? "get",
+    isEventStream: true
+  };
+}
+function isEventStreamRpc(input) {
+  return isRpc(input) && "isEventStream" in input && input.isEventStream === true;
+}
+function formatSse({ id, data, event }) {
+  const parts = [];
+  if (id) {
+    parts.push(`id: ${id}`);
   }
-  rpc(procedure) {
-    this.procedures.push(procedure);
+  if (event) {
+    parts.push(`event: ${event}`);
   }
-  route(route) {
-    this.routes.push(route);
+  parts.push(`data: ${data}`);
+  const payload = `${parts.join("\n")}
+
+`;
+  return payload;
+}
+function formatSseList(events) {
+  let output = "";
+  for (const event of events) {
+    output += formatSse(event);
   }
-  getProcedures() {
-    return this.procedures;
+  return output;
+}
+class EventStreamConnection {
+  constructor(event, opts) {
+    __publicField$2(this, "lastEventId");
+    __publicField$2(this, "writable");
+    __publicField$2(this, "readable");
+    __publicField$2(this, "writer");
+    __publicField$2(this, "encoder");
+    __publicField$2(this, "serializer");
+    __publicField$2(this, "h3Event");
+    __publicField$2(this, "pingInterval");
+    __publicField$2(this, "pingIntervalMs");
+    this.h3Event = event;
+    setSseHeaders(this.h3Event);
+    setResponseStatus(this.h3Event, 200);
+    const id = getHeader(event, "Last-Event-ID");
+    this.lastEventId = id;
+    const { readable, writable } = new TransformStream();
+    this.writable = writable;
+    this.readable = readable;
+    this.writer = writable.getWriter();
+    this.encoder = new TextEncoder();
+    this.pingIntervalMs = opts.pingInterval ?? 6e4;
+    this.serializer = opts.serializer;
   }
-  getRoutes() {
-    return this.routes;
+  /**
+   * Start sending the event stream to the client
+   */
+  start() {
+    this.h3Event._handled = true;
+    void sendStream(this.h3Event, this.readable);
+    this.pingInterval = setInterval(async () => {
+      await this.publishEvent({
+        id: this.lastEventId,
+        event: "ping",
+        data: ""
+      });
+    }, this.pingIntervalMs);
+  }
+  async push(data, eventId) {
+    if (Array.isArray(data)) {
+      const events = [];
+      for (const item of data) {
+        events.push({
+          id: eventId,
+          event: "message",
+          data: this.serializer(item)
+        });
+      }
+      await this.publishEvents(events);
+      return;
+    }
+    await this.publishEvent({
+      id: eventId,
+      event: "message",
+      data: this.serializer(data)
+    });
+  }
+  // /**
+  //  * 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.publishEvent({
+      id: eventId,
+      event: "error",
+      data: JSON.stringify(error)
+    });
+  }
+  async publishEvents(events) {
+    const payload = formatSseList(events);
+    await this.writer.write(this.encoder.encode(payload));
+  }
+  async publishEvent(event) {
+    const payload = formatSse(event);
+    await this.writer.write(this.encoder.encode(payload));
+  }
+  async cleanup() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+    }
+    try {
+      await this.writer.close();
+    } catch (_) {
+    }
+  }
+  /**
+   * Tell clients that the stream has ended and close the connection.
+   */
+  async end() {
+    await this.publishEvent({
+      event: "done",
+      data: "this stream has ended"
+    }).catch();
+    this.h3Event.node.res.end();
+    await this.cleanup();
+  }
+  on(event, callback) {
+    switch (event) {
+      case "disconnect":
+        this.h3Event.node.req.on("close", async () => {
+          await callback();
+          await this.cleanup();
+        });
+        break;
+      case "end":
+        this.h3Event.node.req.on("end", callback);
+        break;
+    }
+  }
+}
+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 httpMethod = procedure.method ?? "get";
+  const handler = eventHandler(async (event) => {
+    event.context.rpcName = procedure.name;
+    if (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 connection = new EventStreamConnection(event, {
+        pingInterval: procedure.pingInterval,
+        serializer: responseValidator?.serialize ?? function(_) {
+          return "";
+        }
+      });
+      event.context.connection = connection;
+      await procedure.handler(event.context, event);
+    } catch (err) {
+      await handleH3Error(err, event, opts.onError);
+    }
+    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;
   }
 }
 
@@ -555,6 +761,40 @@ function handleRoute(router, method, route, opts) {
   }
 }
 
+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 ArriRouter {
+  constructor() {
+    __publicField$1(this, "procedures", []);
+    __publicField$1(this, "routes", []);
+    __publicField$1(this, "models", {});
+  }
+  rpc(procedure) {
+    this.procedures.push(procedure);
+  }
+  route(route) {
+    this.routes.push(route);
+  }
+  registerModels(models) {
+    for (const key of Object.keys(models)) {
+      this.models[key] = models[key];
+    }
+  }
+  getProcedures() {
+    return this.procedures;
+  }
+  getRoutes() {
+    return this.routes;
+  }
+  getModels() {
+    return this.models;
+  }
+}
+
 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) => {
@@ -608,11 +848,6 @@ class ArriApp {
           if (this.onRequest) {
             await this.onRequest(event);
           }
-          if (this.middlewares.length) {
-            for (const m of this.middlewares) {
-              await m(event);
-            }
-          }
         } catch (err) {
           await handleH3Error(err, event, this.onError);
         }
@@ -637,6 +872,7 @@ class ArriApp {
       for (const rpc of input.getProcedures()) {
         this.rpc(rpc);
       }
+      this.registerModels(input.getModels());
       return;
     }
     this.middlewares.push(input);
@@ -660,6 +896,16 @@ class ArriApp {
         this.models[responseName] = procedure.response;
       }
     }
+    if (isEventStreamRpc(procedure)) {
+      registerEventStreamRpc(this.h3Router, path, procedure, {
+        middleware: this.middlewares,
+        onRequest: this.onRequest,
+        onError: this.onError,
+        onAfterResponse: this.onAfterResponse,
+        onBeforeResponse: this.onBeforeResponse
+      });
+      return;
+    }
     registerRpc(this.h3Router, path, procedure, {
       middleware: this.middlewares,
       onRequest: this.onRequest,
@@ -677,6 +923,11 @@ class ArriApp {
       onBeforeResponse: this.onBeforeResponse
     });
   }
+  registerModels(models) {
+    for (const key of Object.keys(models)) {
+      this.models[key] = models[key];
+    }
+  }
   getAppDefinition() {
     const appDef = {
       arriSchemaVersion: "0.0.2",
@@ -731,4 +982,4 @@ function defineConfig(config) {
   };
 }
 
-export { ArriApp as A, DEV_ENDPOINT_ROOT as D, ErrorResponse as E, DEV_DEFINITION_ENDPOINT as a, isRpc as b, createRpcDefinition as c, defineRpc as d, getRpcParamName as e, getRpcResponseName as f, getRpcPath as g, defineError as h, isRpcParamSchema as i, errorResponseFromValidationErrors as j, handleH3Error as k, isArriConfig as l, isResolvedArriConfig as m, defaultConfig as n, defineConfig as o, ArriRouter as p, defineRoute as q, registerRpc as r, registerRoute as s, handleRoute as t };
+export { ArriApp as A, EventStreamConnection as B, registerEventStreamRpc as C, DEV_ENDPOINT_ROOT as D, ErrorResponse as E, DEV_DEFINITION_ENDPOINT as a, isRpc as b, createRpcDefinition as c, defineRpc as d, getRpcParamName as e, getRpcResponseName as f, getRpcPath as g, defineError as h, isRpcParamSchema as i, errorResponseFromValidationErrors as j, handleH3Error as k, isArriConfig as l, isResolvedArriConfig as m, defaultConfig as n, defineConfig as o, ArriRouter as p, defineRoute as q, registerRpc as r, registerRoute as s, handleRoute as t, setSseHeaders as u, validateRpcRequestInput as v, defineEventStreamRpc as w, isEventStreamRpc as x, formatSse as y, formatSseList as z };