@server/next 0.25.10 → 0.27.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@server/next",
-  "version": "0.25.10",
+  "version": "0.27.0",
   "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",
@@ -12,15 +12,16 @@
     "title": "Server JS - A modern web server for Bun and Node.js",
     "home": "./docs/index.html",
     "menu": {
-      "About": "/",
       "Documentation": "/documentation",
       "Github": "https://github.com/franciscop/server-next"
     }
   },
   "scripts": {
+    "build": "bunx tsup src/index.ts --format esm --dts --out-dir . --target node24",
     "start": "bun test --watch",
     "lint": "npx @biomejs/biome lint ./src --skip=lint/style/noParameterAssign --skip=lint/suspicious/noExplicitAny --skip=lint/suspicious/noConfusingVoidType",
-    "test": "bun test && check-dts ./src/**",
+    "test": "npm run test:bun && tsc --noEmit",
+    "test:bun": "bun test",
     "test:jest": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
   },
   "keywords": [
@@ -29,25 +30,28 @@
     "server.js"
   ],
   "type": "module",
-  "main": "src/index.js",
-  "types": "src/index.d.ts",
+  "main": "index.js",
+  "types": "index.d.ts",
   "files": [
-    "src/",
-    "jsx-dev-runtime.js"
+    "src/jsx/"
   ],
   "exports": {
-    ".": "./src/index.js",
-    "./jsx-runtime": "./src/helpers/jsx.js",
-    "./jsx-dev-runtime": "./src/helpers/jsx.js"
+    ".": "./index.js",
+    "./jsx-runtime": "./src/jsx/jsx-dev-runtime.js",
+    "./jsx-dev-runtime": "./src/jsx/jsx-dev-runtime.js"
   },
   "devDependencies": {
-    "argon2": "^0.40.3",
+    "@types/bun": "^1.3.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.10.0",
     "check-dts": "^0.8.2",
     "jest": "^29.7.0",
-    "polystore": "^0.14.1"
+    "polystore": "^0.14.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=24.11.0"
   },
   "engineStrict": true,
   "jest": {

package/readme.md

@@ -0,0 +1 @@
+# Server JS

package/src/{helpers/jsx.js → jsx/jsx-dev-runtime.js}

@@ -1,7 +1,13 @@
-const entities = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" };
+const entities = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+};
+
 const encode = (str = "") => {
   if (typeof str === "number") str = String(str);
-  if (typeof str !== "string") return ""; // nullify not-strings
+  if (typeof str !== "string") return "";
   return str.replace(/[&<>"]/g, (tag) => entities[tag]);
 };
 
@@ -17,60 +23,69 @@ const altAttrs = {
 const isValidChild = (child) => child || child === "" || child === 0;
 
 const escapeCSS = (value) => String(value).replace(/[<>&"'`]/g, "\\$&");
+
 const minifyCss = (str) =>
   str
     .replace(/\s+/g, " ")
-    .replace(/(?!<\")\/\*[^\*]+\*\/(?!\")/g, "")
+    .replace(/(?!<")\/\*[^*]+\*\/(?!")/g, "")
     .replace(/(\w|\*) (\{)/g, "$1$2")
     .replace(/(\}) (\w|\*)/g, "$1$2")
     .replace(/(\{) (\w)/g, "$1$2")
-    .replace(/(\w)(\:) /g, "$1$2")
-    .replace(/(\;) (\})/g, "$1$2")
-    .replace(/(\;) (\w)/g, "$1$2")
-    .replace(/\;(\})/g, "$1")
+    .replace(/(\w)(:) /g, "$1$2")
+    .replace(/(;) (\})/g, "$1$2")
+    .replace(/(;) (\w)/g, "$1$2")
+    .replace(/;(\})/g, "$1")
     .replace(/(\w), (\w)/g, "$1,$2")
     .replace(/(\w), (\w)/g, "$1,$2")
     .replace(/(\{) (\w)/g, "$1$2")
     .trim();
 
-export const jsx = (tag, { children, ...props }) => {
+const jsx = (tag, { children, ...props }) => {
   if (typeof tag === "function") return tag({ children, ...props });
 
-  // If they include an explicit <script>, let them be, just render it
-  // without escaping
   if (tag === "script" && children) {
     const src = children;
     children = () => src;
   }
+
   if (tag === "style" && children && typeof children === "string") {
     const src = minifyCss(escapeCSS(children));
     children = () => src;
   }
-  if (props.dangerouslySetInnerHTML)
+
+  if (props?.dangerouslySetInnerHTML) {
     children = () => props.dangerouslySetInnerHTML.__html;
+  }
 
   if (!isValidChild(children)) children = [];
   if (typeof children === "string") children = [children];
+
   children = (Array.isArray(children) ? children : [children])
     .flat()
     .map((c) => (typeof c === "function" ? c() : encode(c)))
     .join("");
+
   if (!tag) return () => children;
+
   let attrStr = Object.entries(props || {})
-    .filter(([k, v]) => k !== "dangerouslySetInnerHTML")
+    .filter(([k]) => k !== "dangerouslySetInnerHTML")
     .filter(([k, v]) => !/on[A-Z]/.test(k) && typeof v !== "function")
-    .filter(([k, v]) => v !== false)
+    .filter(([, v]) => v !== false)
     .map(([k, v]) =>
       v === true
         ? altAttrs[k.toLowerCase()] || encode(k)
-        : `${altAttrs[k.toLowerCase()] || encode(k)}="${encode(v)}"`,
+        : `${altAttrs[k.toLowerCase()] || encode(k)}="${encode(String(v))}"`,
     )
     .join(" ");
+
   if (attrStr) attrStr = ` ${attrStr}`;
+
   if (SELFCLOSE.has(tag)) return () => `<${tag}${attrStr} />`;
+
   const doctype = tag === "html" ? "<!DOCTYPE html>" : "";
   return () => `${doctype}<${tag}${attrStr}>${children}</${tag}>`;
 };
-export const jsxs = jsx;
-export const jsxDEV = jsx;
-export const Fragment = "";
+
+const Fragment = "";
+
+export { jsx, jsx as jsxs, jsx as jsxDEV, Fragment };

package/src/{helpers/jsx.test.jsx → jsx/jsx-runtime.test.jsx}

@@ -1,4 +1,4 @@
-const $ = (code) => code();
+/** @jsxImportSource . */
 
 expect.extend({
   toRender(fn, rendered) {

package/src/ServerError.js

@@ -1,27 +0,0 @@
-export default class ServerError extends Error {
-  constructor(code, status, message, vars = {}) {
-    if (typeof message === "function") {
-      message = message(vars);
-    }
-    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);
-    this.code = code;
-    this.message = message;
-    this.status = status;
-  }
-  static extend(errors) {
-    for (const code in errors) {
-      const message = errors[code]?.message || errors[code];
-      const status = errors[code]?.status;
-      ServerError[code] = (vars) =>
-        new ServerError(code, status, message, vars);
-    }
-    return errors;
-  }
-}

package/src/auth/NoSession.js

@@ -1,19 +0,0 @@
-import { ServerError } from "../index.js";
-
-class NoSession {}
-
-export default new Proxy(NoSession, {
-  get(target, key) {
-    if (target[key]) return target[key];
-    if (key === "then") return target[key];
-    if (typeof key === "symbol") return target[key];
-    throw ServerError.NO_STORE_READ({ key });
-  },
-  set(target, key, value) {
-    if (target[key] || key === "then" || typeof key === "symbol") {
-      target[key] = value;
-    } else {
-      throw ServerError.NO_STORE_WRITE({ key });
-    }
-  },
-});

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

@@ -1,42 +0,0 @@
-import "../test/toSucceed.js";
-
-import kv from "polystore";
-
-import server from "../index.js";
-
-describe("user creation flow", () => {
-  // These are obviously mock data
-  const EMAIL = "abc@test.com";
-  const PASS = "11111111";
-  const CREDENTIALS = { email: EMAIL, password: PASS };
-
-  const store = kv(new Map());
-  const api = server({ store, auth: "cookie:email" })
-    .get("/me", (ctx) => ctx.user || "No data")
-    .test();
-
-  // Bun's bug: https://github.com/oven-sh/bun/issues/6348
-  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(";")[0].split("=")[1]}`,
-    ]);
-
-    const me = await api.get("/me");
-    expect(me).toSucceed();
-    expect(me.body.email).toEqual(EMAIL);
-
-    const logout = await api.post("/auth/logout");
-    expect(logout).toSucceed();
-    expect(await store.keys()).toEqual(["user:abc@test.com"]);
-
-    const login = await api.post("/auth/login/email", CREDENTIALS);
-    expect(login).toSucceed();
-    expect(await store.keys()).toEqual([
-      "user:abc@test.com",
-      `auth:${login.headers["set-cookie"].split(";")[0].split("=")[1]}`,
-    ]);
-  });
-});

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

@@ -1,110 +0,0 @@
-import "../test/toSucceed.js";
-
-import kv from "polystore";
-
-import server from "../index.js";
-
-describe("user creation flow", () => {
-  // These are obviously mock data
-  const EMAIL = "abc@test.com";
-  const PASS = "11111111";
-  const CREDENTIALS = { email: EMAIL, password: PASS };
-
-  const store = kv(new Map());
-  const sessions = () => store.prefix("auth:").keys();
-  const users = () => store.prefix("user:").keys();
-  const api = server({ store, auth: "token:email" })
-    .get("/me", (ctx) => ctx.user || "No data")
-    .test();
-
-  // Bun's bug: https://github.com/oven-sh/bun/issues/6348
-  it("tests a long user flow with tokens", async () => {
-    // The latest updated token
-    let token;
-
-    // REGISTER A NEW USER
-    token = await (async () => {
-      const register = await api.post("/auth/register/email", CREDENTIALS);
-      expect(register).toSucceed();
-
-      expect(await users()).toEqual(["abc@test.com"]);
-      expect(await sessions()).toEqual([register.body.token]);
-      return register.body.token;
-    })();
-
-    // CAN GET MY OWN INFO
-    await (async () => {
-      const headers = { authorization: `Bearer ${token}` };
-      const me = await api.get("/me", { headers });
-      expect(me).toSucceed();
-      expect(me.body.email).toEqual(EMAIL);
-
-      expect(await users()).toEqual(["abc@test.com"]);
-      expect(await sessions()).toEqual([token]);
-    })();
-
-    // LOGOUT TEST
-    await (async () => {
-      const headers = { authorization: `Bearer ${token}` };
-      const logout = await api.post("/auth/logout", {}, { headers });
-      expect(logout).toSucceed();
-      expect(await users()).toEqual(["abc@test.com"]);
-      expect(await sessions()).toEqual([]);
-    })();
-
-    // LOGIN FOR THE FIRST TIME
-    token = await (async () => {
-      const login = await api.post("/auth/login/email", CREDENTIALS);
-      expect(login).toSucceed();
-      expect(await users()).toEqual(["abc@test.com"]);
-      expect(await sessions()).toEqual([login.body.token]);
-      return login.body.token;
-    })();
-
-    // CAN GET MY OWN INFO
-    await (async () => {
-      const headers = { authorization: `Bearer ${token}` };
-      const me = await api.get("/me", { headers });
-      expect(me).toSucceed();
-      expect(me.body.email).toEqual(EMAIL);
-    })();
-
-    // UPDATE PASSWORD
-    await (async () => {
-      const headers = { authorization: `Bearer ${token}` };
-      const body = { previous: PASS, updated: "22222222" };
-      const update = await api.put("/auth/password/email", body, { headers });
-      expect(update).toSucceed();
-      expect(await users()).toEqual(["abc@test.com"]);
-      expect(await sessions()).toEqual([token]);
-    })();
-
-    // LOGOUT AGAIN
-    await (async () => {
-      const headers = { authorization: `Bearer ${token}` };
-      const logout = await api.post("/auth/logout", {}, { headers });
-      expect(logout).toSucceed();
-      expect(await users()).toEqual(["abc@test.com"]);
-      expect(await sessions()).toEqual([]);
-    })();
-
-    // LOGIN WITH OLD PASSWORD
-    await (async () => {
-      const login = await api.post("/auth/login/email", CREDENTIALS);
-      expect(login).not.toSucceed();
-      expect(await users()).toEqual(["abc@test.com"]);
-    })();
-
-    // LOGIN WITH NEW PASSWORD
-    token = await (async () => {
-      const login = await api.post("/auth/login/email", {
-        ...CREDENTIALS,
-        password: "22222222",
-      });
-      expect(login).toSucceed();
-      expect(await users()).toEqual(["abc@test.com"]);
-      expect(await sessions()).toEqual([login.body.token]);
-      return login.body.token;
-    })();
-  });
-});

package/src/auth/auth.js

@@ -1,62 +0,0 @@
-import { ServerError } from "../index.js";
-
-const validateToken = (authorization) => {
-  const [type, id] = authorization.trim().split(" ");
-  if (type.toLowerCase() !== "bearer") {
-    throw ServerError.AUTH_INVALID_TYPE({ type });
-  }
-  if (id.length !== 16) {
-    throw ServerError.AUTH_INVALID_TOKEN();
-  }
-  return id;
-};
-
-const validateCookie = (authorization) => {
-  if (authorization.length !== 16) {
-    throw ServerError.AUTH_INVALID_COOKIE();
-  }
-  return authorization;
-};
-
-const findSessionId = (ctx) => {
-  const type = ctx.options.auth.type;
-
-  if (type === "token") {
-    // If the user is not authenticated, there's no auth to retrieve
-    if (!ctx.headers.authorization) return;
-
-    // Check the authentication header
-    return validateToken(ctx.headers.authorization);
-  }
-
-  if (type === "cookie") {
-    // If the user is not authenticated, there's no auth to retrieve
-    if (!ctx.cookies.authentication) return;
-
-    return validateCookie(ctx.cookies.authentication);
-  }
-
-  throw new Error(`Invalid auth type "${type}"`);
-};
-
-export default async function auth(ctx) {
-  if (!ctx.options.auth) return; // NO AUTH AT ALL; nothing to do here
-  const options = ctx.options.auth;
-
-  const sessionId = findSessionId(ctx);
-  if (!sessionId) return; // NO SESSION FOUND; no auth
-
-  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.provider) throw ServerError.AUTH_NO_PROVIDER();
-  if (!options.provider.includes(auth.provider)) {
-    throw ServerError.AUTH_INVALID_PROVIDER({
-      provider: auth.provider,
-      valid: options.provider,
-    });
-  }
-  return auth;
-}

package/src/auth/index.js

@@ -1,104 +0,0 @@
-import auth from "./auth.js";
-import logout from "./logout.js";
-import providers from "./providers/index.js";
-import session from "./session.js";
-import user from "./user.js";
-
-const parseOptions = (auth, all) => {
-  if (!auth) return null;
-
-  if (typeof auth === "string") {
-    const [type, provider] = auth.split(":");
-    auth = { type, provider };
-  }
-  // if (typeof auth.type === "string") {
-  //   auth.type = auth.type.split("|").filter(Boolean);
-  // }
-  if (typeof auth.provider === "string") {
-    auth.provider = auth.provider.split("|").filter(Boolean);
-  }
-  if (!auth.type) {
-    throw new Error("Auth options needs a type");
-  }
-  // if (!auth.type.length) {
-  //   throw new Error("Auth options needs a type");
-  // }
-  if (!auth.provider || !auth.provider.length) {
-    throw new Error("Auth options needs a provider");
-  }
-  const providerNotFound = auth.provider.find((p) => !providers[p]);
-  if (providerNotFound) {
-    throw new Error(
-      `Provider "${providerNotFound}" not found, available ones are "${Object.keys(providers).join('", "')}"`,
-    );
-  }
-
-  if (!auth.session && all.store) {
-    auth.session = all.store.prefix("auth:");
-  }
-  if (!auth.store && all.store) {
-    auth.store = all.store.prefix("user:");
-  }
-  if (!auth.cleanUser) {
-    auth.cleanUser = (fullUser) => {
-      const { password, token, ...user } = fullUser;
-      return user;
-    };
-  }
-  if (!auth.redirect) {
-    auth.redirect = "/user";
-  }
-  return auth;
-};
-
-const load = async (ctx) => {
-  ctx.session = await session(ctx);
-  ctx.auth = await auth(ctx);
-  ctx.user = await user(ctx);
-};
-
-const middle = async (ctx) => {
-  if (ctx.options.auth) {
-    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",
-        { tags: "Auth", title: "Github logout" },
-        logout,
-      );
-      ctx.app.get(
-        "/auth/login/github",
-        { tags: "Auth" },
-        providers.github.login,
-      );
-      ctx.app.get(
-        "/auth/callback/github",
-        { tags: "Auth", title: "Github callback" },
-        providers.github.callback,
-      );
-    }
-
-    if (ctx.options.auth.provider.includes("email")) {
-      ctx.app.post("/auth/logout", { tags: "Auth" }, logout);
-      ctx.app.post(
-        "/auth/register/email",
-        { tags: "Auth" },
-        providers.email.register,
-      );
-      ctx.app.post(
-        "/auth/login/email",
-        { tags: "Auth" },
-        providers.email.login,
-      );
-      ctx.app.put(
-        "/auth/password/email",
-        { tags: "Auth" },
-        providers.email.password,
-      );
-      ctx.app.put("/auth/reset/email", { tags: "Auth" }, providers.email.reset);
-    }
-  }
-};
-
-export default { load, parseOptions, middle };

package/src/auth/index.test.js

@@ -1,133 +0,0 @@
-import "../test/toSucceed.js";
-
-import kv from "polystore";
-
-import server from "../index.js";
-
-const ID = "REqA2l022l8Q0tuI";
-
-describe("auth", () => {
-  it("requires a provider", async () => {
-    expect(() => server({ auth: "token" })).toThrow(
-      "Auth options needs a provider",
-    );
-    expect(() => server({ auth: "token:" })).toThrow(
-      "Auth options needs a provider",
-    );
-  });
-
-  it("requires a valid provider", async () => {
-    expect(() => server({ auth: "token:nonexisting" })).toThrow(
-      /Provider \"nonexisting\" not found, available ones are/,
-    );
-  });
-
-  it("provider must belong", async () => {
-    const store = kv(new Map());
-    const api = server({ store, auth: "token:email" })
-      .get("/", (ctx) => ctx.auth)
-      .test();
-
-    store.set(`auth:${ID}`, {
-      id: ID,
-      type: "token",
-      provider: "wrong",
-      user: "QypOn5SQApyOPdUp",
-      email: "abc@test.com",
-      time: "2024-07-01T03:21:40Z",
-    });
-    const authorization = "Bearer REqA2l022l8Q0tuI";
-    const req = await api.get("/", { headers: { authorization } });
-    expect(req).not.toSucceed(
-      "Invalid provider 'wrong', valid ones are: 'email'",
-    );
-  });
-});
-
-describe("token", () => {
-  const store = kv(new Map());
-  const api = server({ store, auth: "token:email" })
-    .get("/", (ctx) => ctx.auth)
-    .test();
-
-  afterEach(async () => {
-    await store.del(`auth:${ID}`);
-  });
-
-  it("should be Bearer", async () => {
-    const authorization = "Basic REqA2l022l8Q0tuI";
-    const req = await api.get("/", { headers: { authorization } });
-    expect(req).not.toSucceed("Invalid Authorization type, 'Basic'");
-  });
-
-  it("should have the proper token", async () => {
-    const authorization = "Bearer hola";
-    const req = await api.get("/", { headers: { authorization } });
-    expect(req).not.toSucceed("Invalid Authorization token");
-  });
-
-  it("cannot get the session", async () => {
-    const authorization = "Bearer REqA2l022l8Q0tuI";
-    const req = await api.get("/", { headers: { authorization } });
-    expect(req.status).toBe(404);
-    // expect(req).not.toSucceed("Invalid session");
-  });
-
-  it("cannot get the user", async () => {
-    store.set(`auth:${ID}`, {
-      id: ID,
-      type: "token",
-      provider: "email",
-      user: "QypOn5SQApyOPdUp",
-      email: "abc@test.com",
-      time: "2024-07-01T03:21:40Z",
-    });
-    const authorization = "Bearer REqA2l022l8Q0tuI";
-    const req = await api.get("/", { headers: { authorization } });
-    expect(req).not.toSucceed("Credentials do not correspond to a user");
-  });
-
-  it("cannot get the user", async () => {
-    store.set("auth:REqA2l022l8Q0tuI", {
-      id: "REqA2l022l8Q0tuI",
-      type: "token",
-      provider: "email",
-      user: "QypOn5SQApyOPdUp",
-      email: "abc@test.com",
-      time: "2024-07-01T03:21:40Z",
-    });
-    store.set("user:QypOn5SQApyOPdUp", {
-      id: "QypOn5SQApyOPdUp",
-      email: "abc@test.com",
-    });
-    const authorization = "Bearer REqA2l022l8Q0tuI";
-    const req = await api.get("/", { headers: { authorization } });
-    expect(req).toSucceed();
-  });
-});
-
-describe("cookie", () => {
-  const store = kv(new Map());
-  const api = server({ store, auth: "cookie:email" })
-    .get("/", (ctx) => ctx.auth)
-    .test();
-
-  it("should have the proper token in email", async () => {
-    const cookie = "authentication=hello";
-    const req = await api.get("/", { headers: { cookie } });
-    expect(req).not.toSucceed("Invalid Authorization cookie");
-  });
-
-  it("can get the proper session", async () => {
-    const cookie = "authentication=REqA2l022l8Q0tuI";
-    const req = await api.get("/", { headers: { cookie } });
-    expect(req.status).toBe(404);
-    // expect(req).not.toSucceed("Invalid session");
-  });
-
-  it("can get the proper session", async () => {
-    const cookie = "authentication=REqA2l022l8Q0tuI";
-    const req = await api.get("/", { headers: { cookie } });
-    expect(req).not.toSucceed();
-  });
-});