@thi.ng/server 0.1.0

package/server.js

@@ -0,0 +1,213 @@
+import { isFunction } from "@thi.ng/checks";
+import { readText } from "@thi.ng/file-io";
+import { ConsoleLogger } from "@thi.ng/logger";
+import { preferredTypeForPath } from "@thi.ng/mime";
+import { Router } from "@thi.ng/router";
+import { createReadStream } from "node:fs";
+import * as http from "node:http";
+import * as https from "node:https";
+import { pipeline, Transform } from "node:stream";
+import { createBrotliCompress, createDeflate, createGzip } from "node:zlib";
+import { parseCoookies } from "./utils/cookies.js";
+import { parseSearchParams } from "./utils/formdata.js";
+const MISSING = "__missing";
+class Server {
+  constructor(opts = {}) {
+    this.opts = opts;
+    this.logger = opts.logger ?? new ConsoleLogger("server");
+    const routes = [
+      {
+        id: MISSING,
+        match: ["__404__"],
+        handlers: {
+          get: async ({ res }) => this.missing(res)
+        }
+      },
+      ...this.opts.routes ?? []
+    ];
+    this.router = new Router({
+      default: MISSING,
+      prefix: opts.prefix ?? "/",
+      trim: opts.trim ?? true,
+      routes: routes.map(this.compileRoute.bind(this))
+    });
+  }
+  logger;
+  router;
+  server;
+  async start() {
+    const ssl = this.opts.ssl;
+    const port = this.opts.port ?? (ssl ? 443 : 8080);
+    const host = this.opts.host ?? "localhost";
+    try {
+      this.server = ssl ? https.createServer(
+        {
+          key: readText(ssl.key, this.logger),
+          cert: readText(ssl.cert, this.logger)
+        },
+        this.listener.bind(this)
+      ) : http.createServer({}, this.listener.bind(this));
+      this.server.listen(port, host, void 0, () => {
+        this.logger.info(
+          `starting server: http${ssl ? "s" : ""}://${host}:${port}`
+        );
+      });
+      return true;
+    } catch (e) {
+      this.logger.severe(e);
+      return false;
+    }
+  }
+  async stop() {
+    if (this.server) {
+      this.logger.info(`stopping server...`);
+      this.server.close();
+    }
+    return true;
+  }
+  async listener(req, res) {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    if (this.opts.host && this.opts.host !== url.host) {
+      res.writeHead(503).end();
+      return;
+    }
+    const path = decodeURIComponent(url.pathname);
+    try {
+      const query = parseSearchParams(url.searchParams);
+      const match = this.router.route(path);
+      const route = this.router.routeForID(match.id).spec;
+      const rawCookies = req.headers["set-cookie"]?.join(";");
+      const cookies = rawCookies ? parseCoookies(rawCookies) : {};
+      const ctx = {
+        server: this,
+        logger: this.logger,
+        req,
+        res,
+        path,
+        query,
+        cookies,
+        route,
+        match
+      };
+      if (match.id === MISSING) {
+        this.runHandler(route.handlers.get, ctx);
+        return;
+      }
+      let method = ctx.query?.__method || req.method.toLowerCase();
+      if (method === "head" && !route.handlers.head && route.handlers.get) {
+        method = "get";
+      }
+      const handler = route.handlers[method];
+      if (handler) {
+        this.runHandler(handler, ctx);
+      } else {
+        res.writeHead(405).end();
+      }
+    } catch (e) {
+      this.logger.warn("error:", e.message);
+      res.writeHead(500).end();
+    }
+  }
+  async runHandler({ fn, pre, post }, ctx) {
+    const runPhase = async (fns) => {
+      for (let f of fns) {
+        if (!await f(ctx)) {
+          ctx.res.end();
+          return false;
+        }
+      }
+      return true;
+    };
+    try {
+      if (pre && !await runPhase(pre)) return;
+      await fn(ctx);
+      if (post && !await runPhase(post)) return;
+      ctx.res.end();
+    } catch (e) {
+      this.logger.warn(`handler error:`, e);
+      if (!ctx.res.headersSent) {
+        ctx.res.writeHead(500).end();
+      }
+    }
+  }
+  compileRoute(route) {
+    const compilePhase = (handler, phase) => {
+      const fns = [];
+      for (let x of this.opts.intercept ?? []) {
+        if (x[phase]) fns.push(x[phase].bind(x));
+      }
+      if (!isFunction(handler)) {
+        for (let x of handler.intercept ?? []) {
+          if (x[phase]) fns.push(x[phase].bind(x));
+        }
+      }
+      return fns.length ? phase === "post" ? fns.reverse() : fns : void 0;
+    };
+    const result = { ...route, handlers: {} };
+    for (let method in route.handlers) {
+      const handler = route.handlers[method];
+      result.handlers[method] = {
+        fn: isFunction(handler) ? handler : handler.fn,
+        pre: compilePhase(handler, "pre"),
+        post: compilePhase(handler, "post")
+      };
+    }
+    return result;
+  }
+  addRoutes(routes) {
+    for (let r of routes) {
+      this.logger.debug("registering route:", r.id, r.match);
+    }
+    this.router.addRoutes(routes.map(this.compileRoute.bind(this)));
+    this.logger.debug(this.router.index);
+  }
+  sendFile({ req, res }, path, headers, compress = false) {
+    const mime = headers?.["content-type"] ?? preferredTypeForPath(path);
+    const accept = req.headers["accept-encoding"];
+    const encoding = compress && accept ? [
+      { mode: "br", tx: createBrotliCompress },
+      { mode: "gzip", tx: createGzip },
+      { mode: "deflate", tx: createDeflate }
+    ].find((x) => accept.includes(x.mode)) : void 0;
+    return new Promise((resolve) => {
+      try {
+        this.logger.debug("sending file:", path, "mime:", mime, accept);
+        const src = createReadStream(path);
+        const mergedHeaders = { "content-type": mime, ...headers };
+        if (encoding) {
+          mergedHeaders["content-encoding"] = encoding.mode;
+        }
+        res.writeHead(200, mergedHeaders);
+        const finalize = (err) => {
+          if (err) res.end();
+          resolve();
+        };
+        encoding ? pipeline(src, encoding.tx(), res, finalize) : pipeline(src, res, finalize);
+      } catch (e) {
+        this.logger.warn(e.message);
+        this.missing(res);
+        resolve();
+      }
+    });
+  }
+  unauthorized(res) {
+    res.writeHead(403, "Forbidden").end();
+  }
+  unmodified(res) {
+    res.writeHead(304, "Not modified").end();
+  }
+  missing(res) {
+    res.writeHead(404, "Not found").end();
+  }
+  redirectTo(res, location) {
+    res.writeHead(302, { location }).end();
+  }
+  redirectToRoute(res, route) {
+    this.redirectTo(res, this.router.format(route));
+  }
+}
+const server = (opts) => new Server(opts);
+export {
+  Server,
+  server
+};

package/static.d.ts

@@ -0,0 +1,78 @@
+import type { Fn, MaybePromise, Predicate } from "@thi.ng/api";
+import { type HashAlgo } from "@thi.ng/file-io";
+import type { OutgoingHttpHeaders } from "node:http";
+import type { Interceptor, ServerRoute } from "./api.js";
+/**
+ * Static file configuration options.
+ */
+export interface StaticOpts {
+    /**
+     * Path to local root directory for static assets. Also see
+     * {@link StaticOpts.prefix}
+     *
+     * @defaultValue `.` (current cwd)
+     */
+    rootDir: string;
+    /**
+     * Filter predicate to exclude files from being served. Called with the
+     * absolute local file path. If the function returns false, the server
+     * produces a 404 response. By default all files (within
+     * {@link StaticOpts.rootDir}) will be allowed.
+     */
+    filter: Predicate<string>;
+    /**
+     * Base URL prefix for static assets.  Also see {@link StaticOpts.rootDir}
+     *
+     * @defaultValue "static"
+     */
+    prefix: string;
+    /**
+     * Additional route specific interceptors.
+     */
+    intercept: Interceptor[];
+    /**
+     * Additional common headers (e.g. cache control) for all static files
+     */
+    headers: OutgoingHttpHeaders;
+    /**
+     * If true (default: false), files will be served with brotli, gzip or deflate
+     * compression (if the client supports it).
+     *
+     * @defaultValue false
+     */
+    compress: boolean;
+    /**
+     * User defined function to compute an Etag value for given file path. The
+     * file is guaranteed to exist when this function is called.
+     */
+    etag: Fn<string, MaybePromise<string>>;
+}
+/**
+ * Defines a configurable {@link ServerRoute} and handler for serving static
+ * files from a local directory (optionally with compression, see
+ * {@link StaticOpts.compress} for details).
+ *
+ * @param opts
+ */
+export declare const staticFiles: ({ prefix, rootDir, intercept, filter, compress, etag, headers, }?: Partial<StaticOpts>) => ServerRoute;
+/**
+ * Etag header value function for {@link StaticOpts.etag}. Computes Etag based
+ * on file modified date.
+ *
+ * @remarks
+ * Also see {@link etagFileHash}.
+ *
+ * @param path
+ */
+export declare const etagFileTimeModified: (path: string) => string;
+/**
+ * Higher-order Etag header value function for {@link StaticOpts.etag}. Computes
+ * Etag value by computing the hash digest of a given file. Uses MD5 by default.
+ *
+ * @remarks
+ * Also see {@link etagFileTimeModified}.
+ *
+ * @param algo
+ */
+export declare const etagFileHash: (algo?: HashAlgo) => (path: string) => Promise<string>;
+//# sourceMappingURL=static.d.ts.map

package/static.js

@@ -0,0 +1,69 @@
+import { fileHash as $fileHash } from "@thi.ng/file-io";
+import { preferredTypeForPath } from "@thi.ng/mime";
+import { existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { isUnmodified } from "./utils/cache.js";
+const staticFiles = ({
+  prefix = "static",
+  rootDir = ".",
+  intercept = [],
+  filter = () => true,
+  compress = false,
+  etag,
+  headers
+} = {}) => ({
+  id: "__static",
+  match: [prefix, "+"],
+  handlers: {
+    head: {
+      fn: async (ctx) => {
+        const path = join(rootDir, ...ctx.match.rest);
+        const $headers = await __fileHeaders(
+          path,
+          ctx,
+          filter,
+          etag,
+          headers
+        );
+        if (!$headers) return;
+        ctx.res.writeHead(200, {
+          "content-type": preferredTypeForPath(path),
+          ...$headers
+        });
+      },
+      intercept
+    },
+    get: {
+      fn: async (ctx) => {
+        const path = join(rootDir, ...ctx.match.rest);
+        const $headers = await __fileHeaders(
+          path,
+          ctx,
+          filter,
+          etag,
+          headers
+        );
+        if (!$headers) return;
+        return ctx.server.sendFile(ctx, path, $headers, compress);
+      },
+      intercept
+    }
+  }
+});
+const __fileHeaders = async (path, ctx, filter, etag, headers) => {
+  if (!(existsSync(path) && filter(path))) {
+    return ctx.server.missing(ctx.res);
+  }
+  if (etag) {
+    const etagValue = await etag(path);
+    return isUnmodified(etagValue, ctx.req.headers["if-none-match"]) ? ctx.server.unmodified(ctx.res) : { ...headers, etag: etagValue };
+  }
+  return { ...headers };
+};
+const etagFileTimeModified = (path) => String(statSync(path).mtimeMs);
+const etagFileHash = (algo = "md5") => (path) => $fileHash(path, void 0, algo);
+export {
+  etagFileHash,
+  etagFileTimeModified,
+  staticFiles
+};

package/utils/cache.d.ts

@@ -0,0 +1,2 @@
+export declare const isUnmodified: (etag: string, header?: string) => boolean;
+//# sourceMappingURL=cache.d.ts.map

package/utils/cache.js

@@ -0,0 +1,4 @@
+const isUnmodified = (etag, header) => header ? header.includes(",") ? header.split(/,\s+/g).some((x) => x === etag) : header === etag : false;
+export {
+  isUnmodified
+};

package/utils/cookies.d.ts

@@ -0,0 +1,7 @@
+export interface ParseCookieOpts {
+    domain: string;
+    path: string;
+    now: number;
+}
+export declare const parseCoookies: (rawCookies?: string, { domain, path, now, }?: Partial<ParseCookieOpts>) => Record<string, string>;
+//# sourceMappingURL=cookies.d.ts.map

package/utils/cookies.js

@@ -0,0 +1,43 @@
+const parseCoookies = (rawCookies = "", {
+  domain = "localhost",
+  path = "/",
+  now = Date.now()
+} = {}) => {
+  const res = {};
+  let currK;
+  let currV;
+  for (let part of rawCookies.split(";")) {
+    let [name, value] = part.split("=").map((x) => x.trim());
+    value = decodeURIComponent(value);
+    switch (name.toLowerCase()) {
+      case "domain":
+        if (value !== "." && !domain.endsWith(value)) currK = null;
+        break;
+      case "expires":
+        if (Date.parse(value) < now) currK = null;
+        break;
+      case "path":
+        if (!path.startsWith(value)) currK = null;
+        break;
+      case "maxage":
+      case "httponly":
+      case "priority":
+      case "samesite":
+      case "secure":
+        break;
+      default:
+        if (currK && currV) {
+          res[currK] = currV;
+        }
+        currK = name;
+        currV = value;
+    }
+  }
+  if (currK && currV) {
+    res[currK] = currV;
+  }
+  return res;
+};
+export {
+  parseCoookies
+};

package/utils/formdata.d.ts

@@ -0,0 +1,6 @@
+import type { IncomingMessage } from "node:http";
+export declare const parseSearchParams: (params: URLSearchParams) => any;
+export declare const parseQuerystring: (url: string) => Record<string, any>;
+export declare const parseRequestFormData: (req: IncomingMessage) => Promise<Record<string, any>>;
+export declare const parseFormData: (body: string) => Record<string, any>;
+//# sourceMappingURL=formdata.d.ts.map

package/utils/formdata.js

@@ -0,0 +1,57 @@
+import { isArray, isProtoPath } from "@thi.ng/checks";
+import { illegalArgs } from "@thi.ng/errors";
+import { setInUnsafe, updateInUnsafe } from "@thi.ng/paths";
+const parseSearchParams = (params) => {
+  const acc = {};
+  for (let [k, v] of params) {
+    if (k.includes("[")) return parseObjectVal(acc, k, v);
+    if (!isProtoPath(k)) acc[k] = v;
+  }
+  return acc;
+};
+const parseQuerystring = (url) => {
+  const idx = url.indexOf("?");
+  return idx >= 0 ? parseFormData(url.substring(idx + 1)) : {};
+};
+const parseRequestFormData = async (req) => {
+  let body = "";
+  for await (let chunk of req) body += chunk.toString();
+  return parseFormData(body);
+};
+const parseFormData = (body) => body.split("&").reduce((acc, x) => {
+  x = decodeURIComponent(x.replace(/\+/g, " "));
+  const idx = x.indexOf("=");
+  if (idx < 1) return acc;
+  const k = x.substring(0, idx);
+  const v = x.substring(idx + 1);
+  if (k.includes("[")) return parseObjectVal(acc, k, v);
+  if (!isProtoPath(k)) acc[k] = v;
+  return acc;
+}, {});
+const parseObjectVal = (acc, key, val) => {
+  const parts = key.split("[");
+  if (!parts[0]) __illegal(key);
+  const path = [parts[0]];
+  for (let i = 1, n = parts.length - 1; i <= n; i++) {
+    const p = parts[i];
+    if (p === "]") {
+      if (i < n) __illegal(key);
+      return !isProtoPath(path) ? updateInUnsafe(
+        acc,
+        path,
+        (curr) => isArray(curr) ? [...curr, val] : [val]
+      ) : acc;
+    }
+    const idx = p.indexOf("]");
+    if (idx < 0 || idx < p.length - 1) __illegal(key);
+    path.push(p.substring(0, p.length - 1));
+  }
+  return !isProtoPath(path) ? setInUnsafe(acc, path, val) : acc;
+};
+const __illegal = (key) => illegalArgs("invalid form param: " + key);
+export {
+  parseFormData,
+  parseQuerystring,
+  parseRequestFormData,
+  parseSearchParams
+};

package/utils/multipart.d.ts

@@ -0,0 +1,11 @@
+import type { IncomingMessage } from "node:http";
+import type { Readable } from "node:stream";
+export interface MultipartPart {
+    headers: Record<string, string>;
+    body: string | Uint8Array;
+}
+export declare const parseRequestMultipartData: (req: IncomingMessage) => AsyncGenerator<MultipartPart, void, unknown>;
+export declare function parseMultipartData(req: Readable, boundary: string): AsyncGenerator<MultipartPart, void, unknown>;
+export declare const chunkParser: (boundary: string) => (chunk: Buffer) => Generator<MultipartPart, void, unknown>;
+export declare const parsePart: (buf: Uint8Array) => MultipartPart;
+//# sourceMappingURL=multipart.d.ts.map

package/utils/multipart.js

@@ -0,0 +1,63 @@
+import { findSequence } from "@thi.ng/arrays";
+import { illegalArgs } from "@thi.ng/errors";
+const DECODER = new TextDecoder();
+const parseRequestMultipartData = (req) => {
+  const ctype = req.headers["content-type"];
+  if (!ctype) illegalArgs("missing content-type");
+  const boundary = /boundary=([a-z0-9-]+)/i.exec(ctype);
+  if (!boundary) illegalArgs("missing boundary");
+  return parseMultipartData(req, boundary[1]);
+};
+async function* parseMultipartData(req, boundary) {
+  const parser = chunkParser(boundary);
+  for await (let chunk of req) yield* parser(chunk);
+}
+const chunkParser = (boundary) => {
+  const boundaryBytes = new TextEncoder().encode(boundary);
+  let buf = new Uint8Array(0);
+  let from = 0;
+  return function* (chunk) {
+    const $buf = new Uint8Array(buf.length + chunk.length);
+    $buf.set(buf);
+    $buf.set(chunk, buf.length);
+    buf = $buf;
+    while (buf.length) {
+      const idx = findSequence(buf, boundaryBytes, from);
+      if (idx < 0) {
+        from = Math.max(buf.length - boundaryBytes.length + 1, 0);
+        return;
+      }
+      if (idx >= 4) {
+        yield parsePart(buf.slice(2, idx - 4));
+      }
+      buf = buf.slice(idx + boundaryBytes.length);
+      from = 0;
+    }
+  };
+};
+const MPART_SEP = [13, 10, 13, 10];
+const parsePart = (buf) => {
+  const idx = findSequence(buf, MPART_SEP);
+  if (idx < 0) illegalArgs("invalid multipart data");
+  const headers = DECODER.decode(buf.slice(0, idx)).split("\r\n").reduce((acc, x) => {
+    const idx2 = x.indexOf(":");
+    let key = x.substring(0, idx2).toLowerCase();
+    let val = x.substring(idx2 + 1).trim();
+    if (key === "content-disposition") {
+      const name = /name="([a-z0-9_.-]{1,64})"/i.exec(val);
+      if (name) acc["name"] = name[1];
+      const filename = /filename="([a-z0-9_.+\-~@ ()\[\]]{1,128})"/i.exec(val);
+      if (filename) acc["filename"] = filename[1];
+    }
+    acc[key] = val;
+    return acc;
+  }, {});
+  const body = buf.slice(idx + 4);
+  return headers["content-type"] ? { headers, body } : { headers, body: DECODER.decode(body) };
+};
+export {
+  chunkParser,
+  parseMultipartData,
+  parsePart,
+  parseRequestMultipartData
+};