@server/next 0.17.3 → 0.18.0

package/src/reply.js

@@ -0,0 +1,95 @@
+import fs from "fs/promises";
+
+import { types } from "./helpers/index.js";
+
+function Reply() {}
+
+Reply.prototype.res = { headers: {}, cookies: {} };
+
+// INTERNAL
+Reply.prototype.generateHeaders = function () {
+  const cookies = Object.entries(this.res.cookies)
+    .map(([k, { value, path = "/" }]) => `${k}=${value};Path=${path}`)
+    .join(";");
+  return { ...this.res.headers, "set-cookie": cookies };
+};
+
+// PARTIAL
+Reply.prototype.status = function (status) {
+  this.res.status = status;
+  return this;
+};
+
+// `.html`, `html`, `text/html`
+Reply.prototype.type = function (type) {
+  if (!type) return this;
+  this.res.headers["content-type"] = types[type.replace(/^\./)] || type;
+  return this;
+};
+
+// Set extra headers
+Reply.prototype.headers = function (headers) {
+  if (!headers || typeof headers !== "object") return this;
+  for (let key in headers) {
+    this.res.headers[key] = headers[key];
+  }
+  return this;
+};
+
+// Set extra cookies
+Reply.prototype.cookies = function (cookies) {
+  if (!cookies || typeof cookies !== "object") return this;
+  for (let key in cookies) {
+    if (typeof cookies[key] === "string") {
+      this.res.cookies[key] = { value: cookies[key] };
+    } else {
+      this.res.cookies[key] = cookies[key];
+    }
+  }
+  return this;
+};
+
+// FINAL
+Reply.prototype.json = function (body) {
+  return headers({ "content-type": "application/json" }).send(
+    JSON.stringify(body)
+  );
+};
+
+Reply.prototype.file = async function (path) {
+  const data = await fs.readFile(path, "utf-8");
+  if (data) return this.type(path.split(".").pop()).send(data);
+  return status(404).send();
+};
+
+Reply.prototype.send = function (body = "") {
+  const { status = 200 } = this.res;
+
+  if (typeof body === "string") {
+    // Not yet set, so infer the type from type of string
+    if (!this.res.headers["content-type"]) {
+      const isHtml = body.startsWith("<");
+      this.res.headers["content-type"] = isHtml ? "text/html" : "text/plain";
+    }
+
+    const headers = this.generateHeaders();
+    return new Response(body, { status, headers });
+  }
+
+  // This is a bit loopy, send({}) => json({}) => send('{}')
+  return this.json(body);
+};
+
+// INTERNAL
+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 cookies = (...args) => new Reply().cookies(...args);
+
+// FINAL
+export const send = (...args) => new Reply().send(...args);
+export const json = (...args) => new Reply().json(...args);
+export const file = (...args) => new Reply().file(...args);

package/src/router.js

@@ -0,0 +1,47 @@
+export default function router() {
+  if (!(this instanceof router)) {
+    return new router();
+  }
+  this.handlers = {};
+}
+
+// INTERNAL
+router.prototype.handle = function (name, middleware) {
+  if (!this.handlers[name]) {
+    this.handlers[name] = [];
+  }
+  this.handlers[name].push(middleware);
+  return this;
+};
+
+router.prototype.socket = function (path, ...middleware) {
+  return this.handle("socket", [path, ...middleware]);
+};
+
+router.prototype.get = function (path, ...middleware) {
+  return this.handle("get", [path, ...middleware]);
+};
+
+router.prototype.head = function (path, ...middleware) {
+  return this.handle("head", [path, ...middleware]);
+};
+
+router.prototype.post = function (path, ...middleware) {
+  return this.handle("post", [path, ...middleware]);
+};
+
+router.prototype.put = function (path, ...middleware) {
+  return this.handle("put", [path, ...middleware]);
+};
+
+router.prototype.patch = function (path, ...middleware) {
+  return this.handle("patch", [path, ...middleware]);
+};
+
+router.prototype.del = function (path, ...middleware) {
+  return this.handle("del", [path, ...middleware]);
+};
+
+router.prototype.options = function (path, ...middleware) {
+  return this.handle("options", [path, ...middleware]);
+};

package/src/RequestLogger.js

@@ -1,123 +0,0 @@
-import path from "node:path";
-import Spinnies from "spinnies";
-import color from "./color.js";
-
-const isProduction = process.env.NODE_ENV === "production";
-
-const format = (n, [below, above], limit = Infinity) => {
-  if (n < 1000) {
-    return n.toFixed(0).padStart(4, " ") + ` {dim}${below.padEnd(2, " ")}{/}`;
-  }
-  const clean = (n / 1000).toFixed(n > 90000 ? 0 : 1).padStart(4, " ");
-  if (n > 10 * limit) {
-    return `{red}${clean} ${above.padEnd(2, " ")}{/}`;
-  } else if (n > limit) {
-    return `{yellow}${clean} ${above.padEnd(2, " ")}{/}`;
-  } else {
-    return `${clean} {dim}${above.padEnd(2, " ")}{/}`;
-  }
-};
-
-const range = (char, num) => {
-  const cols = process.stdout.columns || 80;
-  let str = "";
-  for (let i = 0; i < cols; i += char.length) {
-    str += char;
-  }
-  return str;
-};
-
-function simpleType(type) {
-  const simpler = {
-    "text/html": "html",
-    "text/plain": "text",
-    "image/svg+xml": "svg",
-    "image/png": "png",
-    "text/css": "css",
-    "text/javascript": "js",
-    "application/javascript": "js",
-    "application/json": "json",
-    "text/markdown": "md",
-  };
-  return simpler[type] || type;
-}
-
-const cwd = path.resolve("./");
-
-let spinnies;
-export default function RequestLogger(ctx) {
-  this.id = Math.round(Math.random() * 100000);
-
-  if (!isProduction) {
-    if (!spinnies) {
-      spinnies = new Spinnies({ succeedColor: "white", failColor: "white" });
-    }
-    const method = ("[" + ctx.method.toLowerCase() + "]").padEnd(6, " ");
-    const text = color(`{dim}${method}{/} ${ctx.url?.path || ctx.url}`);
-    spinnies.add(`spinner-${this.id}`, { text });
-  }
-
-  this.end = function (ctx) {
-    if (isProduction) return;
-    const status = ctx.res.status;
-
-    const paddedPath = `${ctx.url?.path || ctx.url} {dim}`.padEnd(30, "─");
-    const statColor = status < 300 ? "green" : status < 500 ? "yellow" : "red";
-    const statusBlock = `{${statColor}}[${ctx.res.status}]{/}`;
-    const resSize = format(ctx.res.size || 0, ["b", "kb"], 100000);
-    const t = Math.round(ctx.time._total - ctx.time._init);
-    const resTime = format(t, ["ms", "s"], 1000);
-
-    const type = simpleType(
-      ctx.res.type || ctx.res.headers["content-type"] || "----"
-    );
-    const method = ("[" + ctx.method + "]").padEnd(6, " ");
-    const reqText = `{dim}${method}{/} ${paddedPath}`;
-    const resText = `${statusBlock} ${resSize} ${resTime} ${type}`;
-    const text = color(`${reqText}─›{/} ${resText}`);
-
-    this.text = text;
-    if (statColor !== "red") {
-      spinnies.succeed(`spinner-${this.id}`, { text });
-    } else {
-      spinnies.fail(`spinner-${this.id}`, { text });
-    }
-  };
-
-  this.error = function (err) {
-    const cols = process.stdout.columns || 80;
-    console.log(color("{red}  ┌───────┬" + range("─").slice(12) + "┐{/}"));
-    console.log(
-      color(
-        `{red}  │ {bright}{red}Error{/} {red}│{/} ${err.message.padEnd(
-          cols - 14,
-          " "
-        )} {red}│{/}`
-      )
-    );
-    console.log(color("{red}  ├───────┼" + range("─").slice(12) + "┤{/}"));
-    console.log(
-      color(
-        err.stack
-          .split("\n")
-          .slice(1)
-          .map((line, i) => {
-            line = line.replace(/\s*at\s/, "");
-            line = line.replace("file://" + cwd, "{dim}$PWD{/}");
-            return (
-              `{red}  │{/} ${i === 0 ? "Trace" : "     "} {red}│{/} ` +
-              line.padEnd(cols - 6, " ") +
-              " {red}│{/}"
-            );
-          })
-          .join("\n")
-      )
-    );
-    console.log(color("{red}  └───────┴" + range("─").slice(12) + "┘{/}"));
-  };
-
-  this.reprint = function () {
-    if (isProduction) return;
-    console.log(color(`{red}✖{/} `) + this.text);
-  };
-}

package/src/ServerUrl.js

@@ -1,68 +0,0 @@
-import { inspect } from "util";
-
-const colors = {
-  string: process.env.NO_COLOR ? "" : "\x1b[32m",
-  number: process.env.NO_COLOR ? "" : "\x1b[33m",
-};
-
-const properties = [
-  "hash",
-  "host",
-  "hostname",
-  "href",
-  "origin",
-  "params",
-  "password",
-  "path",
-  "pathname",
-  "port",
-  "protocol",
-  "query",
-  "search",
-  "searchParams",
-  "username",
-];
-
-export default class ServerUrl extends URL {
-  constructor(urlString) {
-    super(urlString);
-
-    const custom = {
-      port: +this.port || null,
-      path: this.pathname,
-      params: {},
-      query: this.getQuery(this.searchParams.entries()),
-    };
-
-    for (let key of properties) {
-      const value = key in custom ? custom[key] : this[key];
-      Object.defineProperty(this, key, {
-        value,
-        enumerable: true,
-        writable: true,
-      });
-    }
-  }
-
-  [inspect.custom]() {
-    const props = Object.keys(this)
-      .map((key) => {
-        const color = colors[typeof this[key]] || "";
-        return `  ${key}: ${color}${inspect(this[key])}\x1b[0m`;
-      })
-      .join("\n");
-    return `ServerUrl {\n${props}\n}`;
-  }
-
-  getQuery(entries) {
-    const query = {};
-    for (const [key, value] of entries) {
-      query[key] = value;
-    }
-    return query;
-  }
-
-  toString() {
-    return this.href;
-  }
-}

package/src/ServerUrl.test.js

@@ -1,63 +0,0 @@
-import ServerUrl from "./ServerUrl.js";
-
-describe("getUrl()", () => {
-  it("can parse a basic URL", () => {
-    const url = new ServerUrl("https://example.com/");
-
-    // Extended values
-    expect(url.path).toEqual("/");
-    expect(url.query).toEqual({});
-
-    // Base values
-    expect(url.href).toBe("https://example.com/");
-    expect(url.pathname).toEqual("/");
-    expect(url.protocol).toBe("https:");
-    expect(url.username).toBe("");
-    expect(url.password).toBe("");
-    expect(url.host).toBe("example.com");
-    expect(url.hostname).toBe("example.com");
-    expect(url.port).toBe(null);
-
-    expect(Object.keys(url)).toEqual([
-      "hash",
-      "host",
-      "hostname",
-      "href",
-      "origin",
-      "params",
-      "password",
-      "path",
-      "pathname",
-      "port",
-      "protocol",
-      "query",
-      "search",
-      "searchParams",
-      "username",
-    ]);
-  });
-
-  it("can parse localhost", () => {
-    const url = new ServerUrl("http://localhost:3000/");
-
-    // Extended values
-    expect(url.path).toEqual("/");
-    expect(url.query).toEqual({});
-    expect(url.params).toEqual({});
-
-    // Base values
-    expect(url.href).toBe("http://localhost:3000/");
-    expect(url.pathname).toEqual("/");
-    expect(url.protocol).toBe("http:");
-    expect(url.username).toBe("");
-    expect(url.password).toBe("");
-    expect(url.host).toBe("localhost:3000");
-    expect(url.hostname).toBe("localhost");
-    expect(url.port).toBe(3000);
-  });
-
-  it("can be stringified", () => {
-    const url = new ServerUrl("http://localhost:3000/");
-    expect(url + "").toBe("http://localhost:3000/");
-  });
-});

package/src/getMime.js

@@ -1,48 +0,0 @@
-import fs from "node:fs";
-import fsp from "node:fs/promises";
-import { spawn } from "node:child_process";
-
-// These are some mime types that are not properly produced by
-// the file --mime-type command, and can be inferred by their
-// filename extension easily
-// Note: text/javascript is the recommended now https://stackoverflow.com/a/876805/938236
-const extensions = {
-  css: "text/css",
-  js: "text/javascript",
-};
-
-const exists = (file) => {
-  return fsp.stat(file, fs.constants.F_OK).then(
-    (stat) => stat.isFile(),
-    () => false
-  );
-};
-
-function cmd(...args) {
-  const { stdout: stream } = spawn(...args);
-  const chunks = [];
-  return new Promise((resolve, reject) => {
-    stream.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
-    stream.on("error", (err) => reject(err));
-    stream.on("end", () =>
-      resolve(Buffer.concat(chunks).toString("utf8").trim())
-    );
-  });
-}
-
-export default async function (file) {
-  const cwd = await fsp.realpath("./");
-  file = await fsp.realpath(file);
-
-  const ext = file.split(".").pop();
-  if (extensions[ext]) return extensions[ext];
-
-  // It _is_ a file
-  if (!(await exists(file))) return false;
-  // Inside the CWD directory
-  if (!file.startsWith(cwd)) return false;
-
-  // The two conditions above give us enough confidence to run
-  // this, but even then we use spawn() to avoid some nasty injections
-  return cmd("file", ["--mime-type", "-b", file]);
-}

package/src/logger.js

@@ -1,21 +0,0 @@
-import color from "./color.js";
-
-const isProduction = process.env.NODE_ENV === "production";
-
-const header = function ({ api, options }) {
-  if (isProduction) return;
-  const routes = Object.values(api).flat().length;
-  console.clear();
-  console.log(
-    color(
-      `{green}Started server successfully{/} (${routes} routes). See app in the browser:
-
-🔗 {under}http://localhost:${options.port}/{/}
-
-{dim}Press [ctrl+c] to exit the server.{/}
-`
-    )
-  );
-};
-
-export default { header };