arri 0.13.0 → 0.16.0

package/dist/shared/{arri.165b8604.cjs → arri.beaf548c.cjs}

@@ -210,28 +210,25 @@ function isRpcParamSchema(input) {
   return arriValidate.isAObjectSchema(input) || arriValidate.isARecordSchema(input) || arriValidate.isADiscriminatorSchema(input);
 }
 function isRpc(input) {
-  if (typeof input !== "object" || input === null) {
-    return false;
-  }
-  const anyInput = input;
-  if (!arriCodegenUtils.isRpcHttpMethod(anyInput.method)) {
-    return false;
-  }
-  if (typeof anyInput.handler !== "function") {
-    return false;
-  }
-  return true;
+  return typeof input === "object" && input !== null && "method" in input && arriCodegenUtils.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 = "") {
@@ -297,70 +294,11 @@ function registerRpc(router, path, procedure, opts) {
         }
       }
       if (isRpcParamSchema(procedure.params)) {
-        switch (httpMethod) {
-          case "get": {
-            const parsedParams = await h3.getValidatedQuery(
-              event,
-              (input) => arriValidate.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 h3.readRawBody(event);
-            if (!body) {
-              throw defineError(400, {
-                statusMessage: `Invalid request body. Expected object. Got undefined.`
-              });
-            }
-            const parsedParams = arriValidate.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,
@@ -410,29 +348,297 @@ function registerRpc(router, path, procedure, opts) {
       break;
   }
 }
+async function validateRpcRequestInput(event, httpMethod, schema) {
+  switch (httpMethod) {
+    case "get": {
+      const parsedParams = await h3.getValidatedQuery(
+        event,
+        (input) => arriValidate.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 h3.readRawBody(event);
+      if (!body) {
+        throw defineError(400, {
+          statusMessage: `Invalid request body. Expected object. Got undefined.`
+        });
+      }
+      const parsedParams = arriValidate.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) {
+  h3.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);
+    h3.setResponseStatus(this.h3Event, 200);
+    const id = h3.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 h3.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 ? arriValidate.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 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;
   }
 }
 
@@ -557,6 +763,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) => {
@@ -610,11 +850,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);
         }
@@ -639,6 +874,7 @@ class ArriApp {
       for (const rpc of input.getProcedures()) {
         this.rpc(rpc);
       }
+      this.registerModels(input.getModels());
       return;
     }
     this.middlewares.push(input);
@@ -662,6 +898,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,
@@ -679,6 +925,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",
@@ -716,7 +967,8 @@ const defaultConfig = {
   clientGenerators: [],
   buildDir: ".arri",
   serverEntry: "",
-  esbuild: {}
+  esbuild: {},
+  https: false
 };
 function defineConfig(config) {
   return {
@@ -729,7 +981,8 @@ function defineConfig(config) {
     clientGenerators: config.clientGenerators ?? defaultConfig.clientGenerators,
     buildDir: config.buildDir ?? defaultConfig.buildDir,
     esbuild: config.esbuild ?? defaultConfig.esbuild,
-    serverEntry: config.serverEntry ?? ""
+    serverEntry: config.serverEntry ?? "",
+    https: config.https ?? false
   };
 }
 
@@ -738,21 +991,29 @@ exports.ArriRouter = ArriRouter;
 exports.DEV_DEFINITION_ENDPOINT = DEV_DEFINITION_ENDPOINT;
 exports.DEV_ENDPOINT_ROOT = DEV_ENDPOINT_ROOT;
 exports.ErrorResponse = ErrorResponse;
+exports.EventStreamConnection = EventStreamConnection;
 exports.createRpcDefinition = createRpcDefinition;
 exports.defaultConfig = defaultConfig;
 exports.defineConfig = defineConfig;
 exports.defineError = defineError;
+exports.defineEventStreamRpc = defineEventStreamRpc;
 exports.defineRoute = defineRoute;
 exports.defineRpc = defineRpc;
 exports.errorResponseFromValidationErrors = errorResponseFromValidationErrors;
+exports.formatSse = formatSse;
+exports.formatSseList = formatSseList;
 exports.getRpcParamName = getRpcParamName;
 exports.getRpcPath = getRpcPath;
 exports.getRpcResponseName = getRpcResponseName;
 exports.handleH3Error = handleH3Error;
 exports.handleRoute = handleRoute;
 exports.isArriConfig = isArriConfig;
+exports.isEventStreamRpc = isEventStreamRpc;
 exports.isResolvedArriConfig = isResolvedArriConfig;
 exports.isRpc = isRpc;
 exports.isRpcParamSchema = isRpcParamSchema;
+exports.registerEventStreamRpc = registerEventStreamRpc;
 exports.registerRoute = registerRoute;
 exports.registerRpc = registerRpc;
+exports.setSseHeaders = setSseHeaders;
+exports.validateRpcRequestInput = validateRpcRequestInput;