@server/next 0.21.2 → 0.21.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@server/next",
-  "version": "0.21.2",
+  "version": "0.21.4",
   "description": "A fully-fledged web server with routing, file uploads, sessions, static files, schema validation, websockets, testing, etc.",
   "homepage": "https://server-js.com/",
   "repository": "https://github.com/franciscop/server-next.git",

package/src/auth/auth-cookie.test.js

@@ -16,17 +16,17 @@ describe("user creation flow", () => {
     .test();
 
   // Bun's bug: https://github.com/oven-sh/bun/issues/6348
-  it.skip("can create a new user", async () => {
+  it("can create a new user", async () => {
     const register = await api.post("/auth/register/email", CREDENTIALS);
     expect(register).toSucceed();
     expect(await store.keys()).toEqual([
       "user:abc@test.com",
-      "auth:" + register.headers["set-cookie"].split("=")[1],
+      "auth:" + register.headers["set-cookie"].split(";")[0].split("=")[1],
     ]);
 
     const me = await api.get("/me");
     expect(me).toSucceed();
-    expect(me.data.email).toEqual(EMAIL);
+    expect(me.body.email).toEqual(EMAIL);
 
     const logout = await api.post("/auth/logout");
     expect(logout).toSucceed();
@@ -36,7 +36,7 @@ describe("user creation flow", () => {
     expect(login).toSucceed();
     expect(await store.keys()).toEqual([
       "user:abc@test.com",
-      "auth:" + login.headers["set-cookie"].split("=")[1],
+      "auth:" + login.headers["set-cookie"].split(";")[0].split("=")[1],
     ]);
   });
 });

package/src/auth/auth-token.test.js

@@ -18,7 +18,7 @@ describe("user creation flow", () => {
     .test();
 
   // Bun's bug: https://github.com/oven-sh/bun/issues/6348
-  it.skip("tests a long user flow with tokens", async () => {
+  it("tests a long user flow with tokens", async () => {
     // The latest updated token
     let token;
 
@@ -28,8 +28,8 @@ describe("user creation flow", () => {
       expect(register).toSucceed();
 
       expect(await users()).toEqual(["abc@test.com"]);
-      expect(await sessions()).toEqual([register.data.token]);
-      return register.data.token;
+      expect(await sessions()).toEqual([register.body.token]);
+      return register.body.token;
     })();
 
     // CAN GET MY OWN INFO
@@ -37,7 +37,7 @@ describe("user creation flow", () => {
       const headers = { authorization: "Bearer " + token };
       const me = await api.get("/me", { headers });
       expect(me).toSucceed();
-      expect(me.data.email).toEqual(EMAIL);
+      expect(me.body.email).toEqual(EMAIL);
 
       expect(await users()).toEqual(["abc@test.com"]);
       expect(await sessions()).toEqual([token]);
@@ -57,8 +57,8 @@ describe("user creation flow", () => {
       const login = await api.post("/auth/login/email", CREDENTIALS);
       expect(login).toSucceed();
       expect(await users()).toEqual(["abc@test.com"]);
-      expect(await sessions()).toEqual([login.data.token]);
-      return login.data.token;
+      expect(await sessions()).toEqual([login.body.token]);
+      return login.body.token;
     })();
 
     // CAN GET MY OWN INFO
@@ -66,7 +66,7 @@ describe("user creation flow", () => {
       const headers = { authorization: "Bearer " + token };
       const me = await api.get("/me", { headers });
       expect(me).toSucceed();
-      expect(me.data.email).toEqual(EMAIL);
+      expect(me.body.email).toEqual(EMAIL);
     })();
 
     // UPDATE PASSWORD
@@ -103,8 +103,8 @@ describe("user creation flow", () => {
       });
       expect(login).toSucceed();
       expect(await users()).toEqual(["abc@test.com"]);
-      expect(await sessions()).toEqual([login.data.token]);
-      return login.data.token;
+      expect(await sessions()).toEqual([login.body.token]);
+      return login.body.token;
     })();
   });
 });

package/src/auth/providers/email.js

@@ -88,7 +88,7 @@ async function register(ctx) {
 
   const time = new Date().toISOString().replace(/\.[0-9]*/, "");
   const user = {
-    id: createId(user.email),
+    id: createId(email),
     email,
     password: await hash.hash(password),
     time,

package/src/context/node.js

@@ -17,6 +17,17 @@ export default async (request, options = {}, app) => {
   ctx.res = { status: null, headers: {}, cookies: {} };
   ctx.method = request.method.toLowerCase();
 
+  // Private
+  const events = {};
+  ctx.unstableOn = (name, callback) => {
+    events[name] = events[name] || [];
+    events[name].push(callback);
+  };
+  ctx.unstableFire = (name, data) => {
+    if (!events[name]) return;
+    events[name].forEach((cb) => cb(data));
+  };
+
   ctx.headers = parseHeaders(new Headers(chunkArray(request.rawHeaders, 2)));
   ctx.cookies = parseCookies(ctx.headers.cookie);
   await auth.load(ctx);
@@ -26,7 +37,7 @@ export default async (request, options = {}, app) => {
   const path = request.url.replace(/\/$/, "") || "/";
   ctx.url = new URL(path, `${https}://${host}`);
   define(ctx.url, "query", (url) =>
-    Object.fromEntries(url.searchParams.entries())
+    Object.fromEntries(url.searchParams.entries()),
   );
 
   await new Promise((resolve, reject) => {
@@ -40,7 +51,7 @@ export default async (request, options = {}, app) => {
         ctx.body = await parseBody(
           Buffer.concat(body).toString(),
           type,
-          options.uploads
+          options.uploads,
         );
         resolve();
       })

package/src/context/winter.js

@@ -5,18 +5,30 @@ import parseCookies from "./parseCookies.js";
 
 export default async (request, options = {}, app) => {
   const ctx = {};
+  ctx.init = performance.now();
   ctx.options = options;
   ctx.req = request;
   ctx.res = { status: null, headers: {}, cookies: {} };
   ctx.method = request.method.toLowerCase();
 
+  // Private
+  const events = {};
+  ctx.unstableOn = (name, callback) => {
+    events[name] = events[name] || [];
+    events[name].push(callback);
+  };
+  ctx.unstableFire = (name, data) => {
+    if (!events[name]) return;
+    events[name].forEach((cb) => cb(data));
+  };
+
   ctx.headers = parseHeaders(request.headers);
   ctx.cookies = parseCookies(ctx.headers.cookie);
   await auth.load(ctx);
 
   ctx.url = new URL(request.url.replace(/\/$/, ""));
   define(ctx.url, "query", (url) =>
-    Object.fromEntries(url.searchParams.entries())
+    Object.fromEntries(url.searchParams.entries()),
   );
 
   if (request.body) {

package/src/helpers/config.js

@@ -3,7 +3,7 @@ import createId from "./createId.js";
 
 // Big mess; parse all of the options for server, which can be at launch time
 // or dynamically per-request for the functions (so have to read ENV inside)
-export default function config(options) {
+export default function config(options = {}) {
   const env = globalThis.env;
 
   // Basic options

package/src/helpers/jsx.js

@@ -1,5 +1,9 @@
 const entities = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" };
-const encode = (str = "") => str.replace(/[&<>"]/g, (tag) => entities[tag]);
+const encode = (str = "") => {
+  if (typeof str === "number") str = String(str);
+  if (typeof str !== "string") return ""; // nullify not-strings
+  return str.replace(/[&<>"]/g, (tag) => entities[tag]);
+};
 
 const SELFCLOSE = new Set(
   "area,base,br,col,embed,hr,img,input,link,meta,source,track,wbr".split(","),
@@ -13,7 +17,7 @@ export const jsx = (tag, { children, ...props }) => {
   if (typeof tag === "function") return tag({ children, ...props });
 
   if (props.dangerouslySetInnerHTML)
-    children = props.dangerouslySetInnerHTML.__html;
+    children = () => props.dangerouslySetInnerHTML.__html;
   if (!children) children = [];
   if (typeof children === "string") children = [children];
   children = (Array.isArray(children) ? children : [children])
@@ -22,12 +26,19 @@ export const jsx = (tag, { children, ...props }) => {
     .join("");
   if (!tag) return () => children;
   let attrStr = Object.entries(props || {})
+    .filter(([k, v]) => k !== "dangerouslySetInnerHTML")
     .filter(([k, v]) => !/on[A-Z]/.test(k) && typeof v !== "function")
-    .map(([k, v]) => `${altAttrs[k.toLowerCase()] || encode(k)}="${encode(v)}"`)
+    .filter(([k, v]) => v !== false)
+    .map(([k, v]) =>
+      v === true
+        ? altAttrs[k.toLowerCase()] || encode(k)
+        : `${altAttrs[k.toLowerCase()] || encode(k)}="${encode(v)}"`,
+    )
     .join(" ");
   if (attrStr) attrStr = " " + attrStr;
   if (SELFCLOSE.has(tag)) return () => `<${tag}${attrStr} />`;
-  return () => `<${tag}${attrStr}>${children}</${tag}>`;
+  const doctype = tag === "html" ? "<!DOCTYPE html>" : "";
+  return () => `${doctype}<${tag}${attrStr}>${children}</${tag}>`;
 };
 export const jsxDEV = jsx;
 export const Fragment = "";

package/src/helpers/jsx.test.jsx

@@ -0,0 +1,48 @@
+import { jsx } from "./jsx.js";
+
+const $ = (code) => code();
+
+expect.extend({
+  toRender(fn, rendered) {
+    const html = fn();
+    if (this.isNot) {
+      const msg = `Expected "${html}"  to render differently`;
+      return { pass: html === rendered, message: () => msg };
+    }
+    const msg = `Expected "${html}" to be rendered as "${rendered}"`;
+    return { pass: html === rendered, message: () => msg };
+  },
+});
+
+describe("jsx", () => {
+  it("can render a div", () => {
+    expect(<div>Hello</div>).toRender(`<div>Hello</div>`);
+  });
+
+  it("can render an input with attributes", () => {
+    expect(<input name="hello" />).toRender(`<input name="hello" />`);
+  });
+
+  it("will stringify an attribute", () => {
+    expect(<input value={5.2} />).toRender('<input value="5.2" />');
+  });
+
+  it("will ignore a boolean attribute", () => {
+    expect(<input disabled />).toRender("<input disabled />");
+    expect(<input disabled={true} />).toRender("<input disabled />");
+    expect(<input disabled={false} />).toRender("<input />");
+  });
+
+  it("will remove events", () => {
+    expect(<input onChange={() => console.log("hello")} />).toRender(
+      "<input />",
+    );
+  });
+
+  it("will inject the doctype for html", () => {
+    expect(<html>Hello</html>).toRender("<!DOCTYPE html><html>Hello</html>");
+    expect(<html lang="en">Hello</html>).toRender(
+      `<!DOCTYPE html><html lang="en">Hello</html>`,
+    );
+  });
+});

package/src/index.js

@@ -116,7 +116,7 @@ server.prototype.node = async function () {
         response.end();
       }
     })
-    .listen(options.port);
+    .listen(this.opts.port);
 };
 
 // Netlify
@@ -139,12 +139,16 @@ server.prototype.fetch = async function (request, env) {
   if (env?.upgrade(request)) return;
   Object.assign(globalThis.env, env); // Extend env with the passed vars
 
+  let ctx, res, error;
   try {
-    const ctx = await createWinterContext(request, this.opts, this);
-    return await handleRequest(this.handlers, ctx);
-  } catch (error) {
-    return new Response(error.message, { status: error.status || 500 });
+    ctx = await createWinterContext(request, this.opts, this);
+    res = await handleRequest(this.handlers, ctx);
+  } catch (err) {
+    error = err;
+    res = new Response(error.message, { status: error.status || 500 });
   }
+  ctx?.unstableFire("finish", { ...ctx, error, res, end: performance.now() });
+  return res;
 };
 
 // #region HTTP methods
@@ -240,7 +244,7 @@ server.prototype.test = function () {
     } else {
       body = await res.text();
     }
-    return { status: res.status, headers, body, data: body };
+    return { status: res.status, headers, body };
   };
   return {
     app: this,

package/src/index.test.js

@@ -45,13 +45,13 @@ describe("return different types", () => {
     .test();
 
   it("can get the plain text", async () => {
-    const { data } = await api.get("/text");
-    expect(data).toBe("Hello world");
+    const { body } = await api.get("/text");
+    expect(body).toBe("Hello world");
   });
 
   it("can get the array", async () => {
-    const { data } = await api.get("/array");
-    expect(data).toEqual(["Hello world"]);
+    const { body } = await api.get("/array");
+    expect(body).toEqual(["Hello world"]);
   });
 
   it("can get the object", async () => {
@@ -71,19 +71,17 @@ describe("simple post works", () => {
     .post("/", (ctx) => status(201).send(ctx.body))
     .test();
 
-  // Bun's bug: https://github.com/oven-sh/bun/issues/6348
-  it.skip("can post new data", async () => {
-    const { data, status, headers } = await api.post("/", "New Data");
+  it("can post new data", async () => {
+    const { body, status, headers } = await api.post("/", "New Data");
     expect(status).toBe(201);
-    expect(data).toBe("New Data");
+    expect(body).toBe("New Data");
     expect(headers["content-type"]).toBe("text/plain; charset=utf-8");
   });
 
-  // Bun's bug: https://github.com/oven-sh/bun/issues/6348
-  it.skip("will return JSON", async () => {
-    const { data, status, headers } = await api.post("/", { hello: "world" });
+  it("will return JSON", async () => {
+    const { body, status, headers } = await api.post("/", { hello: "world" });
     expect(status).toBe(201);
-    expect(data).toEqual({ hello: "world" });
+    expect(body).toEqual({ hello: "world" });
     expect(headers["content-type"]).toBe("application/json; charset=utf-8");
   });
 });

package/src/middle/assets.js

@@ -2,7 +2,7 @@ import { type } from "../reply.js";
 
 export default async function assets(ctx) {
   if (!ctx.options.public) return;
-  if (!ctx.method !== "get") return;
+  if (ctx.method !== "get") return;
   try {
     // TODO: streaming
     // Read it as buffer (null)

package/src/middle/assets.test.js

@@ -0,0 +1,10 @@
+import server from "../";
+
+describe("static assets", () => {
+  it("can serve a simple file", async () => {
+    const app = server({ public: "./src/middle/" }).test();
+    const { body, headers } = await app.get("/assets.test.js");
+    expect(body).toInclude("describe");
+    expect(headers["content-type"]).toBe("text/javascript");
+  });
+});

package/src/router.test.js

@@ -20,27 +20,27 @@ describe("can route properly", () => {
 
   it("can get fallback when nothing matches", async () => {
     const res = await api.get("/");
-    expect(res.data).toBe("Fallback");
+    expect(res.body).toBe("Fallback");
   });
 
   it("can get the base get", async () => {
     const res = await api.get("/hello");
-    expect(res.data).toBe("Hello /hello");
+    expect(res.body).toBe("Hello /hello");
   });
 
   it("can get the nested get", async () => {
     const res = await api.get("/api/hello");
-    expect(res.data).toBe("Hello /api/hello");
+    expect(res.body).toBe("Hello /api/hello");
   });
 
   it("can post to the base get", async () => {
     const res = await api.post("/hello");
-    expect(res.data).toBe("Hello /hello");
+    expect(res.body).toBe("Hello /hello");
   });
 
   it("can post to the nested get", async () => {
     const res = await api.post("/api/hello");
-    expect(res.data).toBe("Hello /api/hello");
+    expect(res.body).toBe("Hello /api/hello");
   });
 
   it("no status reuse", async () => {

package/src/session.test.js

@@ -20,22 +20,22 @@ describe("session", () => {
     await store.set("session:REqA2l022l8Q0tuIRtqLOPUy", { a: 0 });
 
     const res = await api.get("/hello", options);
-    expect(res.data).toBe("Hello 0");
+    expect(res.body).toBe("Hello 0");
 
     const res2 = await api.post("/hello", {}, options);
-    expect(res2.data).toBe("Bye 1");
+    expect(res2.body).toBe("Bye 1");
 
     const res3 = await api.get("/hello", options);
-    expect(res3.data).toBe("Hello 1");
+    expect(res3.body).toBe("Hello 1");
     expect(await store.get("session:REqA2l022l8Q0tuIRtqLOPUy")).toEqual({
       a: 1,
     });
 
     const res4 = await api.post("/hello", {}, options);
-    expect(res4.data).toBe("Bye 2");
+    expect(res4.body).toBe("Bye 2");
 
     const res5 = await api.get("/hello", options);
-    expect(res5.data).toBe("Hello 2");
+    expect(res5.body).toBe("Hello 2");
     expect(await store.get("session:REqA2l022l8Q0tuIRtqLOPUy")).toEqual({
       a: 2,
     });
@@ -54,12 +54,12 @@ describe("missing store", () => {
   it("cannot read a session without a store", async () => {
     const res = await api.get("/read");
     expect(res.status).toBe(500);
-    expect(res.data).toBe("You need a 'store' to read 'ctx.session.a'");
+    expect(res.body).toBe("You need a 'store' to read 'ctx.session.a'");
   });
 
   it("cannot write a session without a store", async () => {
     const res = await api.get("/write");
     expect(res.status).toBe(500);
-    expect(res.data).toBe("You need a 'store' to write 'ctx.session.a'");
+    expect(res.body).toBe("You need a 'store' to write 'ctx.session.a'");
   });
 });

package/src/test/toSucceed.js

@@ -10,17 +10,17 @@ const spaceOrEnter = (msg) => {
 };
 
 export default function toSucceed(request, message) {
-  const pass = request.status >= 200 && request.status < 300;
+  const pass = request.status >= 200 && request.status < 400;
 
-  if (message && JSON.stringify(request.data) !== JSON.stringify(message)) {
+  if (message && JSON.stringify(request.body) !== JSON.stringify(message)) {
     if (pass) {
       return {
         message: () =>
           `${reset}Expected body:${spaceOrEnter(
-            message
+            message,
           )}${this.utils.printExpected(message)}\nReceived body:${spaceOrEnter(
-            request.data
-          )}${this.utils.printReceived(request.data)}`,
+            request.body,
+          )}${this.utils.printReceived(request.body)}`,
         pass,
       };
     }
@@ -28,10 +28,10 @@ export default function toSucceed(request, message) {
     return {
       message: () =>
         `${reset}Expected error:${spaceOrEnter(
-          message
+          message,
         )}${this.utils.printExpected(message)}\nReceived error:${spaceOrEnter(
-          request.data
-        )}${this.utils.printReceived(request.data)}`,
+          request.body,
+        )}${this.utils.printReceived(request.body)}`,
       pass: !pass,
     };
   }
@@ -40,9 +40,9 @@ export default function toSucceed(request, message) {
     return {
       message: () =>
         `${reset}Expected ${this.utils.printExpected(
-          request.status
+          request.status,
         )} to be an error code, received body:\n${this.utils.printExpected(
-          request.data
+          request.body,
         )}`,
       pass: true,
     };
@@ -51,11 +51,11 @@ export default function toSucceed(request, message) {
   return {
     message: () =>
       `${reset}Expected ${this.utils.printReceived(
-        request.status
+        request.status,
       )} to succeed, received body:\n${this.utils.printReceived(
-        request.data,
+        request.body,
         null,
-        2
+        2,
       )}`,
     pass: false,
   };

package/src/url.test.js

@@ -7,8 +7,8 @@ describe("can match the url", () => {
       .get("/*", (ctx) => ctx.url.params)
       .test();
 
-    const { data, headers } = await api.get("/hello");
-    expect(data).toEqual({ id: "hello" });
+    const { body, headers } = await api.get("/hello");
+    expect(body).toEqual({ id: "hello" });
     expect(headers["content-type"]).toEqual("application/json; charset=utf-8");
   });
 
@@ -19,8 +19,8 @@ describe("can match the url", () => {
       .get("/*", (ctx) => ctx.url.params)
       .test();
 
-    const { data, headers, ...rest } = await api.get("/hello");
-    expect(data).toEqual({ id: "hello" });
+    const { body, headers, ...rest } = await api.get("/hello");
+    expect(body).toEqual({ id: "hello" });
     expect(headers["content-type"]).toEqual("application/json; charset=utf-8");
   });
 });