@server/next 0.18.0 → 0.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@server/next",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "An experimental reimplementation of server.js focused on the DX",
   "homepage": "https://node-server.com/",
   "repository": "https://github.com/franciscop/server-next.git",

package/src/bucket.js

@@ -7,6 +7,11 @@ import fsp from "fs/promises";
 // at the very least a read(id) and write(id, value), both returning
 // promises. If possible both are also pipeable/streamable.
 export default function (root) {
+  // Already a bucket, no need to do anything with it, just return it:
+  if (typeof root !== "string") {
+    return root;
+  }
+
   const absolute = (name) => {
     if (!name) throw new Error(`File name is required`);
     return path.resolve(path.join(root, name));

package/src/context/node.js

@@ -4,6 +4,7 @@ import parseCookies from "./parseCookies.js";
 
 export default async (request, options = {}) => {
   const ctx = {};
+  ctx.options = options;
   ctx.req = request;
   ctx.res = { status: null, headers: {}, cookies: {} };
   ctx.method = request.method.toLowerCase();
@@ -19,10 +20,23 @@ export default async (request, options = {}) => {
     Object.fromEntries(url.searchParams.entries())
   );
 
-  if (request.body) {
-    const type = ctx.headers["content-type"];
-    ctx.body = await parseBody(request, type, options.uploads);
-  }
+  await new Promise((resolve, reject) => {
+    const body = [];
+    request
+      .on("data", (chunk) => {
+        body.push(chunk);
+      })
+      .on("end", async () => {
+        const type = ctx.headers["content-type"];
+        ctx.body = await parseBody(
+          Buffer.concat(body).toString(),
+          type,
+          options.uploads
+        );
+        resolve();
+      })
+      .on("error", reject);
+  });
 
   return ctx;
 };

package/src/context/winter.js

@@ -4,6 +4,7 @@ import parseCookies from "./parseCookies.js";
 
 export default async (request, options = {}) => {
   const ctx = {};
+  ctx.options = options;
   ctx.req = request;
   ctx.res = { status: null, headers: {}, cookies: {} };
   ctx.method = request.method.toLowerCase();

package/src/helpers/StatusError.js

@@ -0,0 +1,6 @@
+export default class StatusError extends Error {
+  constructor(msg, status = 500) {
+    super(msg);
+    this.status = status;
+  }
+}

package/src/helpers/handleRequest.js

@@ -1,6 +1,7 @@
 import parseResponse from "../parseResponse.js";
 import pathPattern from "../pathPattern.js";
 import define from "./define.js";
+import validate from "./validate.js";
 
 export default async function handleRequest(handlers, ctx) {
   for (let [matcher, ...cbs] of handlers[ctx.method]) {
@@ -11,10 +12,17 @@ export default async function handleRequest(handlers, ctx) {
     define(ctx.url, "params", () => match);
 
     for (let cb of cbs) {
-      const out = await parseResponse(cb, ctx);
-      if (out) return out;
+      try {
+        validate(ctx, cb);
+        if (typeof cb === "function") {
+          const out = await parseResponse(cb, ctx);
+          if (out) return out;
+        }
+      } catch (error) {
+        return new Response(error.message, { status: error.status || 500 });
+      }
     }
   }
 
-  return Response("Not Found", { status: 404 });
+  return new Response("Not Found", { status: 404 });
 }

package/src/helpers/validate.js

@@ -0,0 +1,35 @@
+import StatusError from "./StatusError.js";
+
+export default function (ctx, schema) {
+  if (!schema || typeof schema !== "object") return;
+
+  let base;
+  try {
+    if (typeof schema?.body === "function") {
+      base = "body";
+      schema.body(ctx.body || {});
+    }
+    if (typeof schema?.body?.parse === "function") {
+      base = "body";
+      schema.body.parse(ctx.body || {});
+    }
+    if (typeof schema?.query === "function") {
+      base = "query";
+      schema.query(ctx.url.query || {});
+    }
+    if (typeof schema?.query?.parse === "function") {
+      base = "query";
+      schema.query.parse(ctx.url.query || {});
+    }
+  } catch (error) {
+    if (error.constructor.name === "ZodError") {
+      console.log(error);
+      const message = error.issues
+        .map(({ path, message }) => `[${base}.${path.join(".")}]: ${message}`)
+        .sort()
+        .join("\n");
+      throw new StatusError(message, 422);
+    }
+    throw error;
+  }
+}

package/src/parseResponse.js

@@ -9,7 +9,7 @@ export default async function parseResponse(handler, ctx) {
   if (!out && typeof out !== "string") return null;
 
   if (typeof out === "function") {
-    out = out(ctx);
+    out = await out(ctx);
   }
 
   // A plain number is a status code

package/src/reply.js

@@ -62,6 +62,17 @@ Reply.prototype.file = async function (path) {
   return status(404).send();
 };
 
+Reply.prototype.view = async function (path) {
+  return async (ctx) => {
+    if (!ctx.options.views) {
+      throw new Error("Views not enabled");
+    }
+    const data = await ctx.options.views.read(path);
+    if (data) return this.type(path.split(".").pop()).send(data);
+    return status(404).send();
+  };
+};
+
 Reply.prototype.send = function (body = "") {
   const { status = 200 } = this.res;
 
@@ -93,3 +104,4 @@ export const cookies = (...args) => new Reply().cookies(...args);
 export const send = (...args) => new Reply().send(...args);
 export const json = (...args) => new Reply().json(...args);
 export const file = (...args) => new Reply().file(...args);
+export const view = (...args) => new Reply().view(...args);