@server/next 0.21.1 → 0.21.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@server/next",
-  "version": "0.21.1",
+  "version": "0.21.3",
   "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/auth.js

@@ -48,8 +48,8 @@ export default async function auth(ctx) {
 
   const auth = await options.session.get(sessionId);
   // Mmh, which one to do...
-  if (!auth) throw ServerError.AUTH_NO_SESSION();
-  // if (!auth) return; // SESSION ALREADY INVALID; no auth
+  // if (!auth) throw ServerError.AUTH_NO_SESSION();
+  if (!auth) return; // SESSION ALREADY INVALID; no auth
 
   if (!auth.provider) throw ServerError.AUTH_NO_PROVIDER();
   if (!options.provider.includes(auth.provider)) {

package/src/auth/index.js

@@ -12,16 +12,16 @@ const load = async (ctx) => {
 
 const middle = async (ctx) => {
   if (ctx.options.auth) {
-    ctx.app.post("/auth/logout", logout);
-
     if (ctx.options.auth.provider.includes("github")) {
       if (!env.GITHUB_ID) throw new Error("GITHUB_ID not defined");
       if (!env.GITHUB_SECRET) throw new Error("GITHUB_SECRET not defined");
+      ctx.app.get("/auth/logout", logout);
       ctx.app.get("/auth/login/github", providers.github.login);
       ctx.app.get("/auth/callback/github", providers.github.callback);
     }
 
     if (ctx.options.auth.provider.includes("email")) {
+      ctx.app.post("/auth/logout", logout);
       ctx.app.post("/auth/register/email", providers.email.register);
       ctx.app.post("/auth/login/email", providers.email.login);
       ctx.app.put("/auth/password/email", providers.email.password);

package/src/auth/index.test.js

@@ -61,7 +61,8 @@ describe("token", () => {
   it("cannot get the session", async () => {
     const authorization = "Bearer REqA2l022l8Q0tuI";
     const req = await api.get("/", { headers: { authorization } });
-    expect(req).not.toSucceed("Invalid session");
+    expect(req.status).toBe(404);
+    // expect(req).not.toSucceed("Invalid session");
   });
 
   it("cannot get the user", async () => {
@@ -112,7 +113,8 @@ describe("cookie", () => {
   it("can get the proper session", async () => {
     const cookie = "authentication=REqA2l022l8Q0tuI";
     const req = await api.get("/", { headers: { cookie } });
-    expect(req).not.toSucceed("Invalid session");
+    expect(req.status).toBe(404);
+    // expect(req).not.toSucceed("Invalid session");
   });
 
   it("can get the proper session", async () => {

package/src/auth/logout.js

@@ -7,7 +7,7 @@ export default async function logout(ctx) {
   if (type === "token") {
     return { token: null };
   } else if (type === "cookie") {
-    return cookies({ authorization: null }).send({});
+    return cookies({ authorization: null }).redirect("/");
   } else if (type === "jwt") {
     throw new Error("JWT auth not supported yet");
   } else if (type === "key") {

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/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

@@ -11,7 +11,7 @@ import {
   parseHeaders,
 } from "./helpers/index.js";
 
-import middle from "./middle/index.js";
+import { assets, auth } from "./middle/index.js";
 
 // Export the reply helpers
 export * from "./reply.js";
@@ -29,7 +29,7 @@ export default function server(options = {}) {
   }
 
   // Keep a copy of the options in the instance
-  this.opts = options;
+  this.opts = config(options);
   this.platform = getMachine();
 
   // TODO: find a way to remove this hack
@@ -74,7 +74,10 @@ export default function server(options = {}) {
     this.node();
   }
 
-  this.use(...middle);
+  this.use(assets);
+  if (this.opts.auth) {
+    this.use(auth({ options: this.opts, app: this }));
+  }
 }
 
 server.prototype.self = function () {
@@ -93,12 +96,11 @@ server.prototype.self = function () {
 // #region Runtimes
 // Node.js
 server.prototype.node = async function () {
-  const options = config(this.opts);
   const http = await import("http");
   http
     .createServer(async (request, response) => {
       try {
-        const ctx = await createNodeContext(request, options, this);
+        const ctx = await createNodeContext(request, this.opts, this);
         const out = await handleRequest(this.handlers, ctx);
 
         response.writeHead(out.status || 200, parseHeaders(out.headers));
@@ -125,8 +127,7 @@ server.prototype.callback = async function (request, context) {
     if (typeof Netlify === "undefined") {
       throw new Error("Netlify doesn't exist");
     }
-    const options = config(this.opts);
-    const ctx = await createWinterContext(request, options, this);
+    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 });
@@ -139,8 +140,7 @@ server.prototype.fetch = async function (request, env) {
   Object.assign(globalThis.env, env); // Extend env with the passed vars
 
   try {
-    const options = config(this.opts);
-    const ctx = await createWinterContext(request, options, this);
+    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 });
@@ -240,7 +240,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/middle/index.js

@@ -1,4 +1,5 @@
-import auth from "../auth/index.js";
+import authMod from "../auth/index.js";
 import assets from "./assets.js";
 
-export default [assets, auth.middle];
+const auth = authMod.middle;
+export { assets, auth };

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");
   });
 });