@server/next 0.25.10 → 0.27.0

package/src/helpers/bucket.js

@@ -1,89 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import fsp from "node:fs/promises";
-
-function thinLocalBucket(root) {
-  const absolute = (name) => {
-    if (!name) throw new Error("File name is required");
-    return path.resolve(path.join(root, name));
-  };
-
-  return {
-    read: async (name) => {
-      const fullPath = absolute(name);
-      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) => {
-      const fullPath = absolute(name);
-      if (value) {
-        return fsp.writeFile(fullPath, value, type).then(() => fullPath);
-      }
-      return fs.createWriteStream(fullPath);
-    },
-    delete: async (name) => {
-      const fullPath = absolute(name);
-      try {
-        await fsp.unlink(fullPath);
-        return true;
-      } catch (error) {
-        return false;
-      }
-    },
-  };
-}
-
-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" });
-    },
-    delete: async (name) => {
-      const file = s3.file(name);
-      if (!(await file.exists())) return null;
-      return await file.delete();
-    },
-  };
-}
-
-// 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/bucket.test.js

@@ -1,51 +0,0 @@
-import bucket from "./bucket.js";
-import fsp from "node:fs/promises";
-import path from "node:path";
-import fs from "node:fs";
-
-const localBucket = bucket("./tests/uploads/");
-
-describe("bucket", () => {
-  afterAll(async () => {
-    const filePath = path.resolve("./tests/uploads/testFile.txt");
-    if (fs.existsSync(filePath)) {
-      await fsp.unlink(filePath);
-    }
-  });
-
-  it("writes a file", async () => {
-    const filePath = await localBucket.write("testFile.txt", "Hello, World!");
-    expect(filePath.endsWith("testFile.txt")).toBe(true);
-  });
-
-  it("reads a file", async () => {
-    const stream = await localBucket.read("testFile.txt");
-    expect(stream).not.toBeNull();
-    let data = "";
-    const reader = stream.getReader();
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      data += new TextDecoder().decode(value);
-    }
-    expect(data).toBe("Hello, World!");
-  });
-
-  it("deletes a file", async () => {
-    const filePath = path.resolve("./tests/uploads/testFile.txt");
-    await fsp.unlink(filePath);
-    const stream = await localBucket.read("testFile.txt");
-    expect(stream).toBeNull();
-  });
-
-  it("removes an existing file", async () => {
-    await localBucket.write("testFile.txt", "To be deleted");
-    const isDeleted = await localBucket.delete("testFile.txt");
-    expect(isDeleted).toBe(true);
-  });
-
-  it("tries to remove a non-existing file", async () => {
-    const isDeleted = await localBucket.delete("nonExistentFile.txt");
-    expect(isDeleted).toBe(false);
-  });
-});

package/src/helpers/color.js

@@ -1,30 +0,0 @@
-// Add color to a string: color('hello {bright}world{/bright}')
-// or a template literal: color`hello {bright}world{/bright}`
-// Supports NO_COLOR, multiple styles, and closing with "{/}"
-// prettier-ignore
-const map = {
-  reset: 0, bright: 1, dim: 2, under: 4, blink: 5, reverse: 7,
-
-  black: 30, red: 31, green: 32, yellow: 33,
-  blue: 34, magenta: 35, cyan: 36, white: 37,
-
-  bgblack: 40, bgred: 41, bggreen: 42, bgyellow: 43,
-  bgblue: 44, bgmagenta: 45, bgcyan: 46, bgwhite: 47,
-};
-
-const replace = (k) => {
-  if (process.env.NO_COLOR) return "";
-  if (!(k in map)) throw new Error(`"{${k}}" is not a valid color`);
-  return `\x1b[${map[k]}m`;
-};
-
-export default function color(str, ...vals) {
-  if (typeof str === "string") {
-    return str
-      .replaceAll(/\{(\w+)\}/g, (m, k) => replace(k))
-      .replaceAll(/\{\/\w*\}/g, replace("reset"));
-  }
-
-  // Template literals, put them together first and then color them
-  return color(str[0] + vals.map((v, i) => v + str[i + 1]).join(""));
-}

package/src/helpers/config.js

@@ -1,64 +0,0 @@
-import auth from "../auth/index.js";
-import Bucket from "./bucket.js";
-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 = {}) {
-  const env = globalThis.env;
-
-  // Basic options
-  options.port = options.port || env.PORT || 3000;
-  options.secret = options.secret || env.SECRET || `unsafe-${createId()}`;
-
-  // CORS
-  options.cors = options.cors || env.CORS || null;
-  if (options.cors) {
-    if (options.cors === true) {
-      options.cors = { origin: options.cors };
-    }
-    if (typeof options.cors === "string") {
-      options.cors = { origin: options.cors };
-    }
-    if (Array.isArray(options.cors)) {
-      options.cors = { origin: options.cors };
-    }
-    if (Array.isArray(options.cors.origin)) {
-      options.cors.origin = options.cors.origin.join(",");
-    }
-    if (typeof options.cors.origin === "string") {
-      options.cors.origin = options.cors.origin.toLowerCase();
-    }
-
-    if (!options.cors.methods) {
-      options.cors.methods = "GET,POST,PUT,DELETE,PATCH,HEAD,OPTIONS";
-    }
-    if (!options.cors.headers) {
-      options.cors.headers = "*";
-    }
-  }
-
-  // Bucket
-  options.views = options.views ? Bucket(options.views) : null;
-  options.public = options.public ? Bucket(options.public) : null;
-  options.uploads = options.uploads ? Bucket(options.uploads) : null;
-
-  // Stores
-  options.store = options.store ?? null;
-  options.cookies = options.cookies ?? {};
-  if (options.store && options.cookies) {
-    options.session = { store: options.store.prefix("session:") };
-  }
-
-  // AUTH
-  options.auth = auth.parseOptions(options.auth || env.AUTH || null, options);
-
-  // OpenAPI
-  if (options.openapi) {
-    if (options.openapi === true) {
-      options.openapi = {};
-    }
-  }
-
-  return options;
-}

package/src/helpers/cookies.test.js

@@ -1,23 +0,0 @@
-import server, { cookies } from "../index.js";
-
-describe("set-cookie", () => {
-  const app = server()
-    .get("/hello", () => {
-      return cookies({ hello: "world" }).send();
-    })
-    .get("/multiple", () => {
-      return cookies({ a: "b", c: "d" }).send();
-    });
-
-  it("sets the right cookie", async () => {
-    const api = app.test();
-    const res = await api.get("/hello");
-    expect(res.headers["set-cookie"]).toBe("hello=world;Path=/");
-  });
-
-  it("can set multiple cookies", async () => {
-    const api = app.test();
-    const res = await api.get("/multiple");
-    expect(res.headers["set-cookie"]).toEqual(["a=b;Path=/", "c=d;Path=/"]);
-  });
-});

package/src/helpers/cors.js

@@ -1,24 +0,0 @@
-const localhost = /^https?:\/\/localhost(:\d+)?$/;
-
-// Based on https://expressjs.com/en/resources/middleware/cors.html#configuration-options
-export default function cors(config, origin = "") {
-  origin = origin.toLowerCase();
-
-  // When it's true, reflect the origin
-  if (config === true) return origin || null;
-
-  // A star should always return a star
-  if (config === "*") return "*";
-
-  // No origin, it's okay since that means we don't need CORS
-  if (!origin) return null;
-
-  // Coming from localhost
-  if (localhost.test(origin)) return origin;
-
-  const arr = Array.isArray(config) ? config : config.split(/\s*,\s*/g);
-  if (arr.includes(origin)) return origin;
-
-  console.warn(`CORS: Origin "${origin}" not allowed. Allowed "${config}"`);
-  return null;
-}

package/src/helpers/cors.test.js

@@ -1,64 +0,0 @@
-import server from "../index.js";
-
-const origin = "http://localhost:3000/";
-
-describe("cors", () => {
-  it("can simply enable the cors", async () => {
-    const cors = "*";
-    const { headers } = await server({ cors })
-      .get("/", () => 200)
-      .test()
-      .get("/", { headers: { origin } });
-
-    expect(headers).toEqual({
-      "access-control-allow-origin": "*",
-      "access-control-allow-headers": "*",
-      "access-control-allow-methods": "GET,POST,PUT,DELETE,PATCH,HEAD,OPTIONS",
-    });
-  });
-
-  it("can disable the cors", async () => {
-    const cors = false;
-    const { headers } = await server({ cors })
-      .get("/", () => 200)
-      .test()
-      .get("/", { headers: { origin } });
-    expect(headers["access-control-allow-origin"]).toBe(undefined);
-  });
-
-  it("gets the wildcard without the origin", async () => {
-    const cors = "*";
-    const { headers } = await server({ cors })
-      .get("/", () => 200)
-      .test()
-      .get("/");
-    expect(headers["access-control-allow-origin"]).toBe("*");
-  });
-
-  it("gets the origin with true", async () => {
-    const cors = true;
-    const { headers } = await server({ cors })
-      .get("/", () => 200)
-      .test()
-      .get("/", { headers: { origin } });
-    expect(headers["access-control-allow-origin"]).toBe(origin);
-  });
-
-  it("gets the correct origin with multiple as string", async () => {
-    const cors = "https://a.com/,https://b.com/";
-    const { headers } = await server({ cors })
-      .get("/", () => 200)
-      .test()
-      .get("/", { headers: { origin: "https://b.com/" } });
-    expect(headers["access-control-allow-origin"]).toBe("https://b.com/");
-  });
-
-  it("gets the correct origin with multiple as array", async () => {
-    const cors = ["https://a.com/", "https://b.com/"];
-    const { headers } = await server({ cors })
-      .get("/", () => 200)
-      .test()
-      .get("/", { headers: { origin: "https://b.com/" } });
-    expect(headers["access-control-allow-origin"]).toBe("https://b.com/");
-  });
-});

package/src/helpers/createCookies.js

@@ -1,16 +0,0 @@
-// Takes an object and returns a string with the proper cookie values
-export default function createCookies(cookies) {
-  if (!cookies || !Object.keys(cookies).length) return [];
-  return Object.entries(cookies).map(([key, val]) => {
-    if (!val) {
-      val = { value: "", expires: new Date(0).toUTCString() };
-    }
-    if (typeof val === "string") {
-      val = { value: val };
-    }
-    const { value, path, expires } = val;
-    const pathPart = `;Path=${path || "/"}`;
-    const expiresPart = expires ? `;Expires=${expires}` : "";
-    return `${key}=${value || ""}${pathPart}${expiresPart}`;
-  });
-}

package/src/helpers/createId.js

@@ -1,51 +0,0 @@
-const alphabet =
-  "useandom26T198340PX75pxJACKVERYMINDBUSHWOLFGQZbfghjklqvwyzrict";
-
-export const random = (bytes) => crypto.getRandomValues(new Uint8Array(bytes));
-
-// Credit: https://stackoverflow.com/a/52171480/938236
-const cyrb53 = (str, seed = 0) => {
-  if (typeof str !== "string") str = String(str);
-  let h1 = 0xdeadbeef ^ seed;
-  let h2 = 0x41c6ce57 ^ seed;
-  for (let i = 0, ch; i < str.length; i++) {
-    ch = str.charCodeAt(i);
-    h1 = Math.imul(h1 ^ ch, 2654435761);
-    h2 = Math.imul(h2 ^ ch, 1597334677);
-  }
-  h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507);
-  h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909);
-  h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507);
-  h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909);
-
-  return 4294967296 * (2097151 & h2) + (h1 >>> 0);
-};
-
-const hash = (str, size) => {
-  let chars = "";
-
-  let num = cyrb53(str);
-  for (let i = 0; i < size; i++) {
-    if (num < alphabet.length) num = cyrb53(str, i);
-    chars += alphabet[num % alphabet.length];
-    num = Math.floor(num / alphabet.length);
-  }
-  return chars;
-};
-
-const randomId = (size = 16) => {
-  let id = "";
-  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
-    // that the value will be a valid index for the "chars" string.
-    id += alphabet[bytes[size] & 61];
-  }
-  return id;
-};
-
-export default function createId(source, size = 16) {
-  if (source) return hash(source, size);
-  return randomId(size);
-}

package/src/helpers/define.js

@@ -1,18 +0,0 @@
-// An amazing lazy-definition. It will _not_ parse these properties
-// until needed, and once it has parsed them, it'll replace itself
-// with the value at once, hence it's called 0-1 times even if the
-// properties are accessed 0-N times
-export default function define(obj, key, cb) {
-  Object.defineProperty(obj, key, {
-    configurable: true,
-    get() {
-      const value = cb(obj);
-      Object.defineProperty(obj, key, {
-        configurable: true,
-        writable: true,
-        value,
-      });
-      return obj[key];
-    },
-  });
-}

package/src/helpers/getMachine.js

@@ -1,26 +0,0 @@
-function getProvider() {
-  if (typeof Netlify !== "undefined") return "netlify";
-  return null;
-}
-
-function getRuntime() {
-  if (typeof Bun !== "undefined") return "bun";
-  if (typeof Deno !== "undefined") return "deno";
-  if (globalThis.process?.versions?.node) return "node";
-  return null;
-}
-
-function getProduction() {
-  // Can I cry now?
-  if (typeof Netlify !== "undefined")
-    return Netlify.env.get("NETLIFY_DEV") !== "true";
-  return process.env.NODE_ENV === "production";
-}
-
-export default function getMachine() {
-  return {
-    provider: getProvider(),
-    runtime: getRuntime(),
-    production: getProduction(),
-  };
-}

package/src/helpers/handleRequest.js

@@ -1,34 +0,0 @@
-import parseResponse from "../parseResponse.js";
-import pathPattern from "../pathPattern.js";
-import define from "./define.js";
-import validate from "./validate.js";
-
-export default async function handleRequest(handlers, ctx) {
-  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 (const cb of cbs) {
-      if (typeof cb === "function") {
-        const res = await cb(ctx);
-        const out = await parseResponse(res, ctx);
-        if (out) return out;
-      } else {
-        validate(ctx, cb);
-      }
-    }
-
-    // When it's an HTTP method, break free after it's done (which will 404)
-    if (method !== "*") break;
-  }
-
-  // In Netlify, a non-response is perfectly valid, which would indicate
-  // the edge function to just go ahead and consume the original resource
-  if (ctx.machine.provider === "netlify") return;
-
-  // In other environments, a non-response is wrong and we should 404 then
-  return new Response("Not Found", { status: 404 });
-}

package/src/helpers/index.js

@@ -1,11 +0,0 @@
-export { default as createCookies } from "./createCookies.js";
-export { default as createId } from "./createId.js";
-export { default as config } from "./config.js";
-export { default as cors } from "./cors.js";
-export { default as define } from "./define.js";
-export { default as getMachine } from "./getMachine.js";
-export { default as handleRequest } from "./handleRequest.js";
-export { default as iterate } from "./iterate.js";
-export { default as parseHeaders } from "./parseHeaders.js";
-export { default as toWeb } from "./toWeb.js";
-export { default as types } from "./types.js";

package/src/helpers/iterate.js

@@ -1,8 +0,0 @@
-export default async function iterate(stream, cb) {
-  const reader = stream.getReader();
-  while (true) {
-    const chunk = await reader.read();
-    if (chunk.done || !chunk.value) return;
-    cb(chunk.value);
-  }
-}

package/src/helpers/parseHeaders.js

@@ -1,15 +0,0 @@
-export default (raw) => {
-  const headers = {};
-  for (let [key, value] of raw.entries()) {
-    key = key.toLowerCase();
-    if (headers[key]) {
-      if (!Array.isArray(headers[key])) {
-        headers[key] = [headers[key]];
-      }
-      headers[key].push(value);
-    } else {
-      headers[key] = value;
-    }
-  }
-  return headers;
-};

package/src/helpers/toWeb.js

@@ -1,15 +0,0 @@
-export default function toWeb(nodeStream) {
-  if (typeof ReadableStream === "undefined") {
-    throw new Error("Environment not supported, please report this as a bug");
-  }
-  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();
-    },
-  });
-}

package/src/helpers/types.js

@@ -1,81 +0,0 @@
-// From https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
-export default {
-  aac: "audio/aac",
-  abw: "application/x-abiword",
-  arc: "application/x-freearc",
-  avif: "image/avif",
-  avi: "video/x-msvideo",
-  azw: "application/vnd.amazon.ebook",
-  bin: "application/octet-stream",
-  bmp: "image/bmp",
-  bz: "application/x-bzip",
-  bz2: "application/x-bzip2",
-  cda: "application/x-cdf",
-  csh: "application/x-csh",
-  css: "text/css",
-  csv: "text/csv",
-  doc: "application/msword",
-  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-  eot: "application/vnd.ms-fontobject",
-  epub: "application/epub+zip",
-  gz: "application/gzip",
-  gif: "image/gif",
-  htm: "text/html",
-  html: "text/html",
-  ico: "image/vnd.microsoft.icon",
-  ics: "text/calendar",
-  jar: "application/java-archive",
-  jpeg: "image/jpeg",
-  jpg: "image/jpeg",
-  js: "text/javascript",
-  json: "application/json",
-  jsonld: "application/ld+json",
-  md: "text/markdown",
-  mid: "audio/midi",
-  midi: "audio/midi",
-  mjs: "text/javascript",
-  mp3: "audio/mpeg",
-  mp4: "video/mp4",
-  mpeg: "video/mpeg",
-  mpkg: "application/vnd.apple.installer+xml",
-  odp: "application/vnd.oasis.opendocument.presentation",
-  ods: "application/vnd.oasis.opendocument.spreadsheet",
-  odt: "application/vnd.oasis.opendocument.text",
-  oga: "audio/ogg",
-  ogv: "video/ogg",
-  ogx: "application/ogg",
-  opus: "audio/opus",
-  otf: "font/otf",
-  png: "image/png",
-  pdf: "application/pdf",
-  php: "application/x-httpd-php",
-  ppt: "application/vnd.ms-powerpoint",
-  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-  rar: "application/vnd.rar",
-  rtf: "application/rtf",
-  sh: "application/x-sh",
-  svg: "image/svg+xml",
-  tar: "application/x-tar",
-  text: "text/plain",
-  tif: "image/tiff",
-  tiff: "image/tiff",
-  ts: "video/mp2t",
-  ttf: "font/ttf",
-  txt: "text/plain",
-  vsd: "application/vnd.visio",
-  wav: "audio/wav",
-  weba: "audio/webm",
-  webm: "video/webm",
-  webp: "image/webp",
-  woff: "font/woff",
-  woff2: "font/woff2",
-  xhtml: "application/xhtml+xml",
-  xls: "application/vnd.ms-excel",
-  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-  xml: "application/xml",
-  xul: "application/vnd.mozilla.xul+xml",
-  zip: "application/zip",
-  "3gp": "video/3gpp",
-  "3g2": "video/3gpp2",
-  "7z": "application/x-7z-compressed",
-};

package/src/helpers/validate.js

@@ -1,34 +0,0 @@
-import StatusError from "./StatusError.js";
-
-export default function validate(ctx, schema) {
-  if (!schema || typeof schema !== "object") return;
-
-  let base;
-  try {
-    if (typeof schema?.body === "function") {
-      base = "body";
-      schema.body(ctx.body || {});
-    }
-    if (typeof schema?.body?.parse === "function") {
-      base = "body";
-      schema.body.parse(ctx.body || {});
-    }
-    if (typeof schema?.query === "function") {
-      base = "query";
-      schema.query(ctx.url.query || {});
-    }
-    if (typeof schema?.query?.parse === "function") {
-      base = "query";
-      schema.query.parse(ctx.url.query || {});
-    }
-  } catch (error) {
-    if (error.name === "ZodError" || error.constructor.name === "ZodError") {
-      const message = error.issues
-        .map(({ path, message }) => `[${base}.${path.join(".")}]: ${message}`)
-        .sort()
-        .join("\n");
-      throw new StatusError(message, 422);
-    }
-    throw error;
-  }
-}