@server/next 0.21.14 → 0.22.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@server/next",
-  "version": "0.21.14",
+  "version": "0.22.1",
   "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",
@@ -19,6 +19,7 @@
   },
   "scripts": {
     "start": "bun test --watch",
+    "lint": "npx @biomejs/biome lint ./src --skip=lint/style/noParameterAssign",
     "test": "bun test",
     "test:jest": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
   },

package/src/ServerError.js

@@ -3,10 +3,11 @@ export default class ServerError extends Error {
     if (typeof message === "function") {
       message = message(vars);
     }
-    for (let key in vars) {
-      if (typeof message === "string" && typeof vars[key] === "string") {
-        message = message.replaceAll(`{${key}}`, vars[key]);
-      }
+    if (typeof message !== "string") throw Error(`Invalid error ${message}`);
+    for (const key in vars) {
+      let val = vars[key];
+      if (Array.isArray(val)) val = vars[key].join(",");
+      message = message.replaceAll(`{${key}}`, val);
     }
 
     super(message);
@@ -15,7 +16,7 @@ export default class ServerError extends Error {
     this.status = status;
   }
   static extend(errors) {
-    for (let code in errors) {
+    for (const code in errors) {
       const message = errors[code]?.message || errors[code];
       const status = errors[code]?.status;
       ServerError[code] = (vars) =>

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

@@ -21,7 +21,7 @@ describe("user creation flow", () => {
     expect(register).toSucceed();
     expect(await store.keys()).toEqual([
       "user:abc@test.com",
-      "auth:" + register.headers["set-cookie"].split(";")[0].split("=")[1],
+      `auth:${register.headers["set-cookie"].split(";")[0].split("=")[1]}`,
     ]);
 
     const me = await api.get("/me");
@@ -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(";")[0].split("=")[1],
+      `auth:${login.headers["set-cookie"].split(";")[0].split("=")[1]}`,
     ]);
   });
 });

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

@@ -34,7 +34,7 @@ describe("user creation flow", () => {
 
     // CAN GET MY OWN INFO
     await (async () => {
-      const headers = { authorization: "Bearer " + token };
+      const headers = { authorization: `Bearer ${token}` };
       const me = await api.get("/me", { headers });
       expect(me).toSucceed();
       expect(me.body.email).toEqual(EMAIL);
@@ -45,7 +45,7 @@ describe("user creation flow", () => {
 
     // LOGOUT TEST
     await (async () => {
-      const headers = { authorization: "Bearer " + token };
+      const headers = { authorization: `Bearer ${token}` };
       const logout = await api.post("/auth/logout", {}, { headers });
       expect(logout).toSucceed();
       expect(await users()).toEqual(["abc@test.com"]);
@@ -63,7 +63,7 @@ describe("user creation flow", () => {
 
     // CAN GET MY OWN INFO
     await (async () => {
-      const headers = { authorization: "Bearer " + token };
+      const headers = { authorization: `Bearer ${token}` };
       const me = await api.get("/me", { headers });
       expect(me).toSucceed();
       expect(me.body.email).toEqual(EMAIL);
@@ -71,7 +71,7 @@ describe("user creation flow", () => {
 
     // UPDATE PASSWORD
     await (async () => {
-      const headers = { authorization: "Bearer " + token };
+      const headers = { authorization: `Bearer ${token}` };
       const body = { previous: PASS, updated: "22222222" };
       const update = await api.put("/auth/password/email", body, { headers });
       expect(update).toSucceed();
@@ -81,7 +81,7 @@ describe("user creation flow", () => {
 
     // LOGOUT AGAIN
     await (async () => {
-      const headers = { authorization: "Bearer " + token };
+      const headers = { authorization: `Bearer ${token}` };
       const logout = await api.post("/auth/logout", {}, { headers });
       expect(logout).toSucceed();
       expect(await users()).toEqual(["abc@test.com"]);

package/src/auth/auth.js

@@ -53,8 +53,10 @@ export default async function auth(ctx) {
 
   if (!auth.provider) throw ServerError.AUTH_NO_PROVIDER();
   if (!options.provider.includes(auth.provider)) {
-    const valid = JSON.stringify(options.provider);
-    throw ServerError.AUTH_INVALID_PROVIDER({ provider: auth.provider, valid });
+    throw ServerError.AUTH_INVALID_PROVIDER({
+      provider: auth.provider,
+      valid: options.provider,
+    });
   }
   return auth;
 }

package/src/auth/index.test.js

@@ -31,7 +31,7 @@ describe("auth", () => {
     const authorization = "Bearer REqA2l022l8Q0tuI";
     const req = await api.get("/", { headers: { authorization } });
     expect(req).not.toSucceed(
-      'Invalid provider "wrong", valid ones are: "email"',
+      "Invalid provider 'wrong', valid ones are: 'email'",
     );
   });
 });

package/src/auth/logout.js

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

package/src/auth/providers/email.js

@@ -48,15 +48,17 @@ const createSession = async (user, ctx) => {
 
   if (type === "token") {
     return status(201).json({ ...user, token: id });
-  } else if (type === "cookie") {
+  }
+  if (type === "cookie") {
     return status(302).cookies({ authentication: id }).redirect(redirect);
-  } else if (type === "jwt") {
+  }
+  if (type === "jwt") {
     throw new Error("JWT auth not supported yet");
-  } else if (type === "key") {
+  }
+  if (type === "key") {
     throw new Error("Key auth not supported yet");
-  } else {
-    throw new Error("Unknown auth type");
   }
+  throw new Error("Unknown auth type");
 };
 
 async function login(ctx) {

package/src/auth/providers/github.js

@@ -19,8 +19,8 @@ const oauth = async (code) => {
     }),
   });
   return (path) => {
-    return fch("https://api.github.com" + path, {
-      headers: { Authorization: "Bearer " + res.access_token },
+    return fch(`https://api.github.com${path}`, {
+      headers: { Authorization: `Bearer ${res.access_token}` },
     });
   };
 };
@@ -68,15 +68,17 @@ const callback = async (ctx) => {
 
   if (auth.type === "token") {
     return status(201).json({ ...user, token: auth.id });
-  } else if (auth.type === "cookie") {
+  }
+  if (auth.type === "cookie") {
     return status(302).cookies({ authentication: auth.id }).redirect(redirect);
-  } else if (auth.type === "jwt") {
+  }
+  if (auth.type === "jwt") {
     throw new Error("JWT auth not supported yet");
-  } else if (auth.type === "key") {
+  }
+  if (auth.type === "key") {
     throw new Error("Key auth not supported yet");
-  } else {
-    throw new Error("Unknown auth type");
   }
+  throw new Error("Unknown auth type");
 };
 
 export default { login, callback };

package/src/context/node.js

@@ -10,9 +10,9 @@ const chunkArray = (arr, size) =>
     ? [arr.slice(0, size), ...chunkArray(arr.slice(size), size)]
     : [arr];
 
-export default async (request, options = {}, app) => {
+export default async (request, app) => {
   const ctx = {};
-  ctx.options = options;
+  ctx.options = app.opts || {};
   ctx.req = request;
   ctx.res = { status: null, headers: {}, cookies: {} };
   ctx.method = request.method.toLowerCase();
@@ -25,7 +25,9 @@ export default async (request, options = {}, app) => {
   };
   ctx.unstableFire = (name, data) => {
     if (!events[name]) return;
-    events[name].forEach((cb) => cb(data));
+    for (const cb of events[name]) {
+      cb(data);
+    }
   };
 
   ctx.headers = parseHeaders(new Headers(chunkArray(request.rawHeaders, 2)));
@@ -33,7 +35,7 @@ export default async (request, options = {}, app) => {
   await auth.load(ctx);
 
   const https = request.connection.encrypted ? "https" : "http";
-  const host = ctx.headers.host || "localhost" + options.port;
+  const host = ctx.headers.host || `localhost:${ctx.options.port}`;
   const path = request.url.replace(/\/$/, "") || "/";
   ctx.url = new URL(path, `${https}://${host}`);
   define(ctx.url, "query", (url) =>
@@ -51,7 +53,7 @@ export default async (request, options = {}, app) => {
         ctx.body = await parseBody(
           Buffer.concat(body).toString(),
           type,
-          options.uploads,
+          ctx.options.uploads,
         );
         resolve();
       })

package/src/context/parseBody.js

@@ -2,12 +2,12 @@ import { createId } from "../helpers/index.js";
 
 function getBoundary(header) {
   if (!header) return null;
-  var items = header.split(";");
+  const items = header.split(";");
   if (items)
-    for (var j = 0; j < items.length; j++) {
-      var item = new String(items[j]).trim();
+    for (let j = 0; j < items.length; j++) {
+      const item = new String(items[j]).trim();
       if (item.indexOf("boundary") >= 0) {
-        var k = item.split("=");
+        const k = item.split("=");
         return new String(k[1]).trim();
       }
     }
@@ -48,7 +48,7 @@ export default async function parseBody(raw, contentType, bucket) {
   const body = {};
 
   const rawDataArray = rawData.split(boundary);
-  for (let item of rawDataArray) {
+  for (const item of rawDataArray) {
     // Use non-matching groups to exclude part of the result
     const name = getMatching(item, /(?:name=")(.+?)(?:")/)
       .trim()

package/src/context/winter.js

@@ -3,10 +3,10 @@ import { define, parseHeaders } from "../helpers/index.js";
 import parseBody from "./parseBody.js";
 import parseCookies from "./parseCookies.js";
 
-export default async (request, options = {}, app) => {
+export default async (request, app) => {
   const ctx = {};
   ctx.init = performance.now();
-  ctx.options = options;
+  ctx.options = app.opts || {};
   ctx.req = request;
   ctx.res = { status: null, headers: {}, cookies: {} };
   ctx.method = request.method.toLowerCase();
@@ -19,7 +19,9 @@ export default async (request, options = {}, app) => {
   };
   ctx.unstableFire = (name, data) => {
     if (!events[name]) return;
-    events[name].forEach((cb) => cb(data));
+    for (const cb of events[name]) {
+      cb(data);
+    }
   };
 
   ctx.headers = parseHeaders(request.headers);
@@ -33,7 +35,7 @@ export default async (request, options = {}, app) => {
 
   if (request.body) {
     const type = ctx.headers["content-type"];
-    ctx.body = await parseBody(request, type, options.uploads);
+    ctx.body = await parseBody(request, type, ctx.options.uploads);
   }
 
   ctx.app = app;

package/src/errors/index.js

@@ -1,17 +1,18 @@
 import ServerError from "../ServerError.js";
 
 ServerError.extend({
-  NO_STORE: `You need a 'store' to write 'ctx.session'`,
-  NO_STORE_WRITE: `You need a 'store' to write 'ctx.session.{key}'`,
-  NO_STORE_READ: `You need a 'store' to read 'ctx.session.{key}'`,
+  NO_STORE: "You need a 'store' to write 'ctx.session'",
+  NO_STORE_WRITE: "You need a 'store' to write 'ctx.session.{key}'",
+  NO_STORE_READ: "You need a 'store' to read 'ctx.session.{key}'",
 
   AUTH_ARGON_NEEDED:
     "Argon2 is needed for the auth module, please install it with 'npm i argon2'",
-  AUTH_INVALID_TYPE: `Invalid Authorization type, '{type}'`,
-  AUTH_INVALID_TOKEN: `Invalid Authorization token`,
-  AUTH_INVALID_COOKIE: `Invalid Authorization cookie`,
-  AUTH_NO_PROVIDER: `No provider passed to the option "auth.provider"`,
-  AUTH_INVALID_PROVIDER: `Invalid provider "{provider}", valid ones are: {valid}`,
+  AUTH_INVALID_TYPE: "Invalid Authorization type, '{type}'",
+  AUTH_INVALID_TOKEN: "Invalid Authorization token",
+  AUTH_INVALID_COOKIE: "Invalid Authorization cookie",
+  AUTH_NO_PROVIDER: "No provider passed to the option 'auth.provider'",
+  AUTH_INVALID_PROVIDER:
+    "Invalid provider '{provider}', valid ones are: '{valid}'",
   AUTH_NO_SESSION: { status: 401, message: "Invalid session" },
   AUTH_NO_USER: {
     status: 401,
@@ -22,14 +23,14 @@ ServerError.extend({
   LOGIN_INVALID_EMAIL: "The email you wrote is not correct",
   LOGIN_NO_PASSWORD: "The email is required to log in",
   LOGIN_INVALID_PASSWORD: "The password you wrote is not correct",
-  LOGIN_WRONG_ACCOUNT: `That email does not correspond to any account`,
-  LOGIN_WRONG_PASSWORD: `That is not the valid password`,
+  LOGIN_WRONG_ACCOUNT: "That email does not correspond to any account",
+  LOGIN_WRONG_PASSWORD: "That is not the valid password",
 
-  REGISTER_NO_EMAIL: `Email needed`,
+  REGISTER_NO_EMAIL: "Email needed",
   REGISTER_INVALID_EMAIL: "The email you wrote is not correct",
-  REGISTER_NO_PASSWORD: `Password needed`,
+  REGISTER_NO_PASSWORD: "Password needed",
   REGISTER_INVALID_PASSWORD: "The password you wrote is not correct",
-  REGISTER_EMAIL_EXISTS: `Email is already registered`,
+  REGISTER_EMAIL_EXISTS: "Email is already registered",
 });
 
 export default ServerError;

package/src/helpers/bucket.js

@@ -1,7 +1,6 @@
-import fs from "fs";
-import path from "path";
-
-import fsp from "fs/promises";
+import fs from "node:fs";
+import path from "node:path";
+import fsp from "node:fs/promises";
 
 // A fake tiny implementation of a generic bucket, it needs
 // at the very least a read(id) and write(id, value), both returning
@@ -13,7 +12,7 @@ export default function (root) {
   }
 
   const absolute = (name) => {
-    if (!name) throw new Error(`File name is required`);
+    if (!name) throw new Error("File name is required");
     return path.resolve(path.join(root, name));
   };
 
@@ -27,9 +26,8 @@ export default function (root) {
       const fullPath = absolute(name);
       if (value) {
         return fsp.writeFile(fullPath, value, type).then(() => fullPath);
-      } else {
-        return fs.createWriteStream(fullPath);
       }
+      return fs.createWriteStream(fullPath);
     },
   };
 }

package/src/helpers/config.js

@@ -8,7 +8,7 @@ export default function config(options = {}) {
 
   // Basic options
   options.port = options.port || env.PORT || 3000;
-  options.secret = options.secret || env.SECRET || "unsafe-" + createId();
+  options.secret = options.secret || env.SECRET || `unsafe-${createId()}`;
 
   // CORS
   options.cors = options.cors || env.CORS || null;

package/src/helpers/createCookies.js

@@ -9,8 +9,8 @@ export default function createCookies(cookies) {
       val = { value: val };
     }
     const { value, path, expires } = val;
-    const pathPart = ";Path=" + (path || "/");
-    const expiresPart = expires ? ";Expires=" + expires : "";
+    const pathPart = `;Path=${path || "/"}`;
+    const expiresPart = expires ? `;Expires=${expires}` : "";
     return `${key}=${value || ""}${pathPart}${expiresPart}`;
   });
 }

package/src/helpers/createId.js

@@ -1,7 +1,7 @@
 const alphabet =
   "useandom26T198340PX75pxJACKVERYMINDBUSHWOLFGQZbfghjklqvwyzrict";
 
-export let random = (bytes) => crypto.getRandomValues(new Uint8Array(bytes));
+export const random = (bytes) => crypto.getRandomValues(new Uint8Array(bytes));
 
 // Credit: https://stackoverflow.com/a/52171480/938236
 const cyrb53 = (str, seed = 0) => {
@@ -35,7 +35,7 @@ const hash = (str, size) => {
 
 const randomId = (size = 16) => {
   let id = "";
-  let bytes = random(size);
+  const bytes = random(size);
   while (size--) {
     // Using the bitwise AND operator to "cap" the value of
     // the random byte from 255 to 63, in that way we can make sure

package/src/helpers/handleRequest.js

@@ -4,14 +4,14 @@ import define from "./define.js";
 import validate from "./validate.js";
 
 export default async function handleRequest(handlers, ctx) {
-  for (let [method, matcher, ...cbs] of handlers[ctx.method]) {
+  for (const [method, matcher, ...cbs] of handlers[ctx.method]) {
     const match = pathPattern(matcher, ctx.url.pathname || "/");
     // Skip this whole middleware if there was no match
     if (!match) continue;
 
     define(ctx.url, "params", () => match);
 
-    for (let cb of cbs) {
+    for (const cb of cbs) {
       if (typeof cb === "function") {
         const res = await cb(ctx);
         const out = await parseResponse(res, ctx);

package/src/helpers/jsx.js

@@ -65,7 +65,7 @@ export const jsx = (tag, { children, ...props }) => {
         : `${altAttrs[k.toLowerCase()] || encode(k)}="${encode(v)}"`,
     )
     .join(" ");
-  if (attrStr) attrStr = " " + attrStr;
+  if (attrStr) attrStr = ` ${attrStr}`;
   if (SELFCLOSE.has(tag)) return () => `<${tag}${attrStr} />`;
   const doctype = tag === "html" ? "<!DOCTYPE html>" : "";
   return () => `${doctype}<${tag}${attrStr}>${children}</${tag}>`;

package/src/helpers/jsx.test.jsx

@@ -16,7 +16,7 @@ expect.extend({
 
 describe("jsx", () => {
   it("can render a div", () => {
-    expect(<div>Hello</div>).toRender(`<div>Hello</div>`);
+    expect(<div>Hello</div>).toRender("<div>Hello</div>");
   });
 
   it("can render an input with attributes", () => {
@@ -40,6 +40,7 @@ describe("jsx", () => {
   });
 
   it("will inject the doctype for html", () => {
+    // biome-ignore lint/a11y/useHtmlLang: This is an example, not user code
     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/helpers/types.js

@@ -30,6 +30,7 @@ export default {
   js: "text/javascript",
   json: "application/json",
   jsonld: "application/ld+json",
+  md: "text/markdown",
   mid: "audio/midi",
   midi: "audio/midi",
   mjs: "text/javascript",
@@ -55,6 +56,7 @@ export default {
   sh: "application/x-sh",
   svg: "image/svg+xml",
   tar: "application/x-tar",
+  text: "text/plain",
   tif: "image/tiff",
   tiff: "image/tiff",
   ts: "video/mp2t",

package/src/index.js

@@ -84,7 +84,7 @@ export default function server(options = {}) {
 server.prototype.self = function () {
   const cb = this.callback.bind(this);
   const proto = Object.getPrototypeOf(this);
-  for (let key in { ...proto, ...this }) {
+  for (const key in { ...proto, ...this }) {
     if (typeof this[key] === "function") {
       cb[key] = this[key].bind(this);
     } else {
@@ -97,11 +97,11 @@ server.prototype.self = function () {
 // #region Runtimes
 // Node.js
 server.prototype.node = async function () {
-  const http = await import("http");
+  const http = await import("node:http");
   http
     .createServer(async (request, response) => {
       try {
-        const ctx = await createNodeContext(request, this.opts, this);
+        const ctx = await createNodeContext(request, this);
         const out = await handleRequest(this.handlers, ctx);
 
         response.writeHead(out.status || 200, parseHeaders(out.headers));
@@ -128,7 +128,7 @@ server.prototype.callback = async function (request, context) {
     if (typeof Netlify === "undefined") {
       throw new Error("Netlify doesn't exist");
     }
-    const ctx = await createWinterContext(request, this.opts, this);
+    const ctx = await createWinterContext(request, this);
     return await handleRequest(this.handlers, ctx);
   } catch (error) {
     return new Response(error.message, { status: error.status || 500 });
@@ -140,9 +140,11 @@ 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;
+  let ctx;
+  let res;
+  let error;
   try {
-    ctx = await createWinterContext(request, this.opts, this);
+    ctx = await createWinterContext(request, this);
     res = await handleRequest(this.handlers, ctx);
   } catch (err) {
     error = err;
@@ -158,7 +160,7 @@ server.prototype.handle = function (method, path, ...middleware) {
   // Do not try to optimize, we NEED the method to remain '*' here so that
   // it doesn't auto-finish
   if (method === "*") {
-    for (let m in this.handlers) {
+    for (const m in this.handlers) {
       this.handlers[m].push([method, path, ...middleware]);
     }
   } else {
@@ -209,11 +211,11 @@ server.prototype.use = function (...middleware) {
 
 // Unwind the children routers into the main router
 server.prototype.router = function (basePath, router) {
-  basePath = ("/" + basePath + "/").replace(/^\/+/, "/").replace(/\/+$/, "/");
-  for (const method in router.handlers) {
-    router.handlers[method].forEach(([method, path, ...callbacks]) => {
+  basePath = `/${basePath}/`.replace(/^\/+/, "/").replace(/\/+$/, "/");
+  for (const m in router.handlers) {
+    for (const [method, path, ...callbacks] of router.handlers[m]) {
       this.handle(method, basePath + path.replace(/^\//, ""), ...callbacks);
-    });
+    }
   }
   return this.self();
 };
@@ -231,7 +233,7 @@ server.prototype.test = function () {
       options.headers.cookie = cookie;
     }
     const res = await this.fetch(
-      new Request("http://localhost:3000" + path, options),
+      new Request(`http://localhost:3000${path}`, options),
     );
 
     const headers = parseHeaders(res.headers);

package/src/parseResponse.js

@@ -81,15 +81,15 @@ export default async function parseResponse(out, ctx) {
   // Cookies to headers
   if (ctx.options.cookies) {
     if (Object.keys(ctx.res.cookies).length) {
-      createCookies(ctx.res.cookies).forEach((cookie) => {
+      for (const cookie of ctx.res.cookies) {
         ctx.res.headers.append("set-cookie", cookie);
-      });
+      }
     }
   }
 
   // Add the headers that are neeeded
   if (ctx?.res?.headers) {
-    for (let key in ctx.res.headers) {
+    for (const key in ctx.res.headers) {
       out.headers[key] = ctx.res.headers[key];
     }
   }

package/src/pathPattern.js

@@ -1,7 +1,7 @@
 export default function pathPattern(pattern, path) {
   if (pattern === "*") return {};
 
-  pattern = "/" + pattern.replace(/^\//, "");
+  pattern = `/${pattern.replace(/^\//, "")}`;
   pattern = pattern.replace(/\/$/, "") || "/";
   path = path.replace(/\/$/, "") || "/";
 

package/src/reply.js

@@ -1,4 +1,4 @@
-import fs from "fs/promises";
+import fs from "node:fs/promises";
 
 import { createCookies, toWeb, types } from "./helpers/index.js";
 
@@ -12,9 +12,9 @@ function Reply() {
 // INTERNAL
 Reply.prototype.generateHeaders = function () {
   const headers = new Headers(this.res.headers);
-  createCookies(this.res.cookies).forEach((cookie) => {
+  for (const cookie of createCookies(this.res.cookies)) {
     headers.append("set-cookie", cookie);
-  });
+  }
   return headers;
 };
 
@@ -27,14 +27,26 @@ Reply.prototype.status = function (status) {
 // `.html`, `html`, `text/html`
 Reply.prototype.type = function (type) {
   if (!type) return this;
-  this.res.headers["content-type"] = types[type.replace(/^\./)] || type;
-  return this;
+  type = types[type.replace(/^\./)] || type;
+  return this.headers({ "content-type": type });
+};
+
+// Prompt for download from the user side
+Reply.prototype.download = function (name, type) {
+  // filename.txt and no explicit type => add headers "text/plain"
+  if (name && !type) type = name.split(".")[1];
+
+  // Add the Content-Type if there's a type
+  if (type) this.type(type);
+
+  const filename = name ? `; filename="${name}"` : "";
+  return this.headers({ "content-disposition": `attachment${filename}` });
 };
 
 // Set extra headers
 Reply.prototype.headers = function (headers) {
   if (!headers || typeof headers !== "object") return this;
-  for (let key in headers) {
+  for (const key in headers) {
     this.res.headers[key] = headers[key];
   }
   return this;
@@ -43,7 +55,7 @@ Reply.prototype.headers = function (headers) {
 // Set extra cookies
 Reply.prototype.cookies = function (cookies) {
   if (!cookies || typeof cookies !== "object") return this;
-  for (let key in cookies) {
+  for (const key in cookies) {
     if (typeof cookies[key] === "string") {
       this.res.cookies[key] = { value: cookies[key] };
     } else {
@@ -127,8 +139,9 @@ export { Reply };
 
 // PARTIAL
 export const status = (...args) => new Reply().status(...args);
-export const type = (...args) => new Reply().type(...args);
 export const headers = (...args) => new Reply().headers(...args);
+export const type = (...args) => new Reply().type(...args);
+export const download = (...args) => new Reply().download(...args);
 export const cookies = (...args) => new Reply().cookies(...args);
 
 // FINAL

package/src/router.test.js

@@ -2,9 +2,9 @@ import server, { router, status } from "./index.js";
 
 describe("can route properly", () => {
   const apiRouter = router()
-    .get("/hello", (ctx) => "Hello " + ctx.url.pathname)
-    .put("/hello", (ctx) => "Hello " + ctx.url.pathname)
-    .post("/hello", (ctx) => "Hello " + ctx.url.pathname);
+    .get("/hello", (ctx) => `Hello ${ctx.url.pathname}`)
+    .put("/hello", (ctx) => `Hello ${ctx.url.pathname}`)
+    .post("/hello", (ctx) => `Hello ${ctx.url.pathname}`);
 
   const app = server()
     .router("/", apiRouter)

package/src/session.test.js

@@ -5,11 +5,11 @@ import server from "./index.js";
 describe("session", () => {
   const store = kv(new Map());
   const api = server({ store })
-    .get("/hello", (ctx) => "Hello " + ctx.session.a)
+    .get("/hello", (ctx) => `Hello ${ctx.session.a}`)
     .post("/hello", (ctx) => {
       if (!ctx.session.a) ctx.session.a = 0;
       ctx.session.a += 1;
-      return "Bye " + ctx.session.a;
+      return `Bye ${ctx.session.a}`;
     })
     .get("/", () => "Fallback")
     .test();
@@ -44,7 +44,7 @@ describe("session", () => {
 
 describe("missing store", () => {
   const api = server({ store: null })
-    .get("/read", (ctx) => "Bye " + ctx.session.a)
+    .get("/read", (ctx) => `Bye ${ctx.session.a}`)
     .get("/write", (ctx) => {
       ctx.session.a = "hello";
       return "All good";