@server/next 0.24.0 → 0.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@server/next",
-  "version": "0.24.0",
+  "version": "0.25.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",

package/src/auth/index.js

@@ -4,6 +4,53 @@ 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);
@@ -54,4 +101,4 @@ const middle = async (ctx) => {
   }
 };
 
-export default { load, middle };
+export default { load, parseOptions, middle };

package/src/auth/index.test.js

@@ -7,11 +7,19 @@ import server from "../index.js";
 const ID = "REqA2l022l8Q0tuI";
 
 describe("auth", () => {
-  it("requires a provider", () => {
-    const store = kv(new Map());
-    const api = server({ store, auth: "token:email" })
-      .get("/", (ctx) => ctx.auth)
-      .test();
+  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 () => {

package/src/context/parseBody.js

@@ -3,24 +3,18 @@ import { createId } from "../helpers/index.js";
 function getBoundary(header) {
   if (!header) return null;
   const items = header.split(";");
-  if (items)
-    for (let j = 0; j < items.length; j++) {
-      const item = new String(items[j]).trim();
-      if (item.indexOf("boundary") >= 0) {
-        const k = item.split("=");
-        return new String(k[1]).trim();
-      }
+  for (const item of items) {
+    const trimmedItem = item.trim();
+    if (trimmedItem.startsWith("boundary=")) {
+      return trimmedItem.split("=")[1].trim();
     }
+  }
   return null;
 }
 
 function getMatching(string, regex) {
-  // Helper function when using non-matching groups
   const matches = string.match(regex);
-  if (!matches || matches.length < 2) {
-    return "";
-  }
-  return matches[1];
+  return matches?.[1] ? matches[1] : "";
 }
 
 const saveFile = async (name, value, bucket) => {
@@ -30,48 +24,76 @@ const saveFile = async (name, value, bucket) => {
   return id;
 };
 
+// Utility function to split a buffer
+function splitBuffer(buffer, delimiter) {
+  const result = [];
+  let start = 0;
+  let index = buffer.indexOf(delimiter, start);
+
+  while (index !== -1) {
+    result.push(buffer.slice(start, index));
+    start = index + delimiter.length;
+    index = buffer.indexOf(delimiter, start);
+  }
+
+  result.push(buffer.slice(start));
+  return result;
+}
+
+const BREAK = "\r\n\r\n";
+
 export default async function parseBody(raw, contentType, bucket) {
-  const rawData = typeof raw === "string" ? raw : await raw.clone().text();
-  if (!rawData) return {};
+  const rawBuffer =
+    typeof raw === "string"
+      ? Buffer.from(raw)
+      : Buffer.from(await raw.arrayBuffer());
+  if (!rawBuffer) return {};
 
   if (!contentType || /text\/plain/.test(contentType)) {
-    return rawData;
+    return rawBuffer.toString(); // Return as plain text
   }
 
   if (/application\/json/.test(contentType)) {
-    return JSON.parse(rawData);
+    return JSON.parse(rawBuffer.toString()); // Parse JSON
   }
 
   const boundary = getBoundary(contentType);
   if (!boundary) return null;
 
   const body = {};
+  const boundaryBuffer = Buffer.from(`--${boundary}`);
+  const parts = splitBuffer(rawBuffer, boundaryBuffer);
+
+  for (const part of parts) {
+    if (part.length === 0 || part.equals(Buffer.from("--\r\n"))) continue;
 
-  const rawDataArray = rawData.split(boundary);
-  for (const item of rawDataArray) {
-    // Use non-matching groups to exclude part of the result
-    const name = getMatching(item, /(?:name=")(.+?)(?:")/)
+    const partString = part.toString();
+    const name = getMatching(partString, /(?:name=")(.+?)(?:")/)
       .trim()
       .replace(/\[\]$/, "");
     if (!name) continue;
 
-    let value = getMatching(item, /(?:\r\n\r\n)([\S\s]*)(?:\r\n--$)/);
-    if (!value) continue;
+    const filename = getMatching(partString, /(?:filename=")(.*?)(?:")/).trim();
 
-    // Check whether we have a filename. If we do, assign it to the value
-    const filename = getMatching(item, /(?:filename=")(.*?)(?:")/).trim();
-    if (filename) {
-      value = await saveFile(filename, value, bucket);
-    }
+    if (!part.includes(BREAK)) continue;
 
-    // Save the key-value, accounting for possibly repeated keys
-    if (body[name]) {
-      if (!Array.isArray(body[name])) {
-        body[name] = [body[name]];
-      }
-      body[name].push(value);
+    // Content starts after headers and "\r\n\r\n",  remove trailing CRLF
+    const content = part.slice(part.indexOf(BREAK) + 4, part.length - 2);
+
+    if (filename) {
+      // Save binary content as a file
+      body[name] = await saveFile(filename, content, bucket);
     } else {
-      body[name] = value;
+      // Treat content as text
+      const value = content.toString().trim();
+      if (body[name]) {
+        if (!Array.isArray(body[name])) {
+          body[name] = [body[name]];
+        }
+        body[name].push(value);
+      } else {
+        body[name] = value;
+      }
     }
   }
 

package/src/context/parseBody.test.js

@@ -51,8 +51,10 @@ describe("parseBody", () => {
     const matchMd = expect.stringMatching(/^\w{16}.md$/);
     const matchTxt = expect.stringMatching(/^\w{16}.txt$/);
     expect(body).toMatchObject({
+      hello: "world",
       profile: matchMd,
-      gallery: [matchTxt, matchTxt],
+      gallery: matchTxt,
+      test: ["test message 123456", "test message number two"],
     });
   });
 });

package/src/helpers/bucket.js

@@ -2,27 +2,31 @@ 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
-// 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;
-  }
-
+function thinLocalBucket(root) {
   const absolute = (name) => {
     if (!name) throw new Error("File name is required");
     return path.resolve(path.join(root, name));
   };
 
   return {
-    path: root,
-    read: (name, type = "utf8") => {
+    read: async (name) => {
       const fullPath = absolute(name);
-      return fsp.readFile(fullPath, type);
+      const stats = await fsp.stat(fullPath).catch(() => null);
+      if (!stats || !stats.isFile()) return null;
+
+      const nodeStream = fs.createReadStream(fullPath);
+      return new ReadableStream({
+        start(controller) {
+          nodeStream.on("data", (chunk) => controller.enqueue(chunk));
+          nodeStream.on("end", () => controller.close());
+          nodeStream.on("error", (err) => controller.error(err));
+        },
+        cancel() {
+          nodeStream.destroy();
+        },
+      });
     },
-    write: (name, value, type = "utf8") => {
+    write: (name, value, type) => {
       const fullPath = absolute(name);
       if (value) {
         return fsp.writeFile(fullPath, value, type).then(() => fullPath);
@@ -31,3 +35,41 @@ export default function (root) {
     },
   };
 }
+
+function thinBunBucket(s3) {
+  return {
+    read: async (name) => {
+      const file = s3.file(name);
+      if (!(await file.exists())) return null;
+      return await file.stream();
+    },
+    write: async (name, value) => {
+      const file = s3.file(name);
+      if (value) {
+        await file.write(value);
+        return name;
+      }
+      return s3.presign(name, { expiresIn: 3600, acl: "public-read-write" });
+    },
+  };
+}
+
+// A fake tiny implementation of a generic bucket, it needs
+// 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) {
+  if (!root) return null;
+
+  // Already a bucket, no need to do anything with it, just return it:
+  if (typeof root === "string") {
+    return thinLocalBucket(root);
+  }
+
+  // Bun's S3
+  if (root.file && root.write) {
+    return thinBunBucket(root);
+  }
+
+  // Assuming the base is already implementing our API
+  return root;
+}

package/src/helpers/config.js

@@ -1,3 +1,4 @@
+import auth from "../auth/index.js";
 import Bucket from "./bucket.js";
 import createId from "./createId.js";
 
@@ -50,37 +51,7 @@ export default function config(options = {}) {
   }
 
   // AUTH
-  options.auth = options.auth || env.AUTH || null;
-  if (options.auth) {
-    if (typeof options.auth !== "object") {
-      const [type, provider] = options.auth.split(":");
-      options.auth = { type, provider };
-    }
-    if (typeof options.auth.provider === "string") {
-      options.auth.provider === options.auth.provider.split("|");
-    }
-    if (!options.auth.type) {
-      throw new Error("Auth options needs a type");
-    }
-    if (!options.auth.provider) {
-      throw new Error("Auth options needs a provider");
-    }
-    if (!options.auth.session && options.store) {
-      options.auth.session = options.store.prefix("auth:");
-    }
-    if (!options.auth.store && options.store) {
-      options.auth.store = options.store.prefix("user:");
-    }
-    if (!options.auth.cleanUser) {
-      options.auth.cleanUser = (fullUser) => {
-        const { password, token, ...user } = fullUser;
-        return user;
-      };
-    }
-    if (!options.auth.redirect) {
-      options.auth.redirect = "/user";
-    }
-  }
+  options.auth = auth.parseOptions(options.auth || env.AUTH || null, options);
 
   // OpenAPI
   if (options.openapi) {

package/src/index.d.ts

@@ -66,7 +66,7 @@ type ExtractPathParams<Path extends string> =
 type ParamTypeMap = {
   string: string;
   number: number;
-  boolean: boolean;
+  date: Date;
 };
 
 type InferParamType<T extends string> = T extends keyof ParamTypeMap

package/src/middle/assets.js

@@ -3,9 +3,11 @@ import { type } from "../reply.js";
 export default async function assets(ctx) {
   if (!ctx.options.public) return;
   if (ctx.method !== "get") return;
+  // The homepage _cannot_ be a file by definition. We could consider sending
+  // `index.html`, but that's easy with `.get('/', () => file('index.html'))
+  if (ctx.url.pathname === "/") return;
   try {
     // TODO: streaming
-    // Read it as buffer (null)
     const asset = await ctx.options.public.read(ctx.url.pathname, null);
     if (!asset) return;
     return type(ctx.url.pathname.split(".").pop()).send(asset);

package/src/middle/assets.test.js

@@ -3,8 +3,8 @@ 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");
+    const res = await app.get("/assets.test.js");
+    expect(res.body).toInclude("describe");
+    expect(res.headers["content-type"]).toBe("text/javascript");
   });
 });

package/src/parseResponse.js

@@ -10,6 +10,10 @@ export default async function parseResponse(out, ctx) {
     out = await out(ctx);
   }
 
+  if (out instanceof Blob) {
+    out = new Response(out, { headers: { "Content-Type": blob.type } });
+  }
+
   // A plain number is a status code
   if (typeof out === "number") {
     out = new Response(undefined, { status: out });
@@ -26,11 +30,6 @@ export default async function parseResponse(out, ctx) {
     out = json(out);
   }
 
-  // if (out instanceof Readable) {
-  // if (out?.prototype?.name === 'Readable') {
-  //   out = new Response(Readable.toWeb(out));
-  // }
-
   if (!(out instanceof Response)) {
     throw new Error(`Invalid response type ${out}`);
   }

package/src/reply.js

@@ -122,6 +122,7 @@ Reply.prototype.send = function (body = "") {
 
   // WebStream already, just pass it through
   if (name === "ReadableStream") {
+    const headers = this.generateHeaders();
     return new Response(body, { status, headers });
   }