@davidsouther/jiffies 1.0.0-beta.1

package/src/server/http/index.ts

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+import {
+  createServer,
+  IncomingMessage,
+  RequestListener,
+  ServerResponse,
+} from "http";
+import { AddressInfo } from "net";
+import * as path from "path";
+import { info } from "../../log.js";
+import { findIndex } from "./apps.js";
+import { fileResponse } from "./response.js";
+import { sitemap } from "./sitemap.js";
+import { staticFileServer } from "./static.js";
+import { tsFileServer } from "./typescript.js";
+
+export interface StaticResponse {
+  status: 200 | 404 | 500;
+  content: Buffer;
+  contentType: string;
+  contentLength?: number;
+}
+
+export interface ServerConfig {
+  root: string;
+  scopes?: Record<`@${string}`, string>;
+}
+
+export interface MiddlewareFactory {
+  (config: ServerConfig): Promise<StaticMiddleware>;
+}
+
+export interface StaticMiddleware {
+  (req: IncomingMessage): Promise<undefined | (() => Promise<StaticResponse>)>;
+}
+
+const notFound: MiddlewareFactory =
+  async ({ root }) =>
+  async () =>
+    fileResponse(
+      // path.join(path.dirname(FLAGS.argv0), "404.html"),
+      path.join(root, "404.html"),
+      undefined,
+      404
+    );
+
+const BASE_MIDDLEWARES: MiddlewareFactory[] = [
+  sitemap,
+  tsFileServer,
+  staticFileServer,
+  findIndex,
+  notFound,
+];
+
+const error = (res: ServerResponse, message: string) => {
+  console.error(message);
+  res.statusCode = 500;
+  res.write(message);
+  res.end();
+  return true;
+};
+
+const sendContent = async (
+  res: ServerResponse,
+  { content, contentType, contentLength }: StaticResponse
+) => {
+  res.setHeader("content-length", `${contentLength}`);
+  res.setHeader("content-type", contentType);
+  await res.write(content);
+  res.end();
+  return true;
+};
+
+const log = (req: IncomingMessage) => {
+  const when = new Date().toISOString();
+  const who = req.socket.remoteAddress;
+  const what = req.url;
+  const how = `${req.method} ${what}`;
+  info("Request", { when, who, how });
+};
+
+export const makeServer = async (
+  config: ServerConfig,
+  middlewares: MiddlewareFactory[] = []
+) => {
+  const handlers = await Promise.all(
+    [...middlewares, ...BASE_MIDDLEWARES].map(async (m) => m(config))
+  );
+  const middlewareHandler: RequestListener = async (req, res) => {
+    log(req);
+    let handler: undefined | (() => Promise<StaticResponse>);
+    try {
+      for (const middleware of handlers) {
+        handler = await middleware(req);
+        if (handler !== undefined) {
+          break;
+        }
+      }
+      if (handler) {
+        sendContent(res, await handler());
+      } else {
+        res.end();
+      }
+    } catch (e) {
+      error(res, (e as Error).message + "\n" + (e as Error).stack);
+    }
+  };
+
+  // TODO(https)
+  const server = createServer(middlewareHandler);
+
+  server.on("listening", () => {
+    const { address, port } = server.address() as AddressInfo;
+    info("Server listening", { address: `http://${address}:${port}` });
+  });
+
+  return server;
+};

package/src/server/http/response.ts

@@ -0,0 +1,47 @@
+import { Stats } from "fs";
+import * as fs from "fs/promises";
+import { StaticMiddleware, StaticResponse } from ".";
+
+const MIME_TYPES: Record<string, string> = {
+  js: "text/javascript",
+  json: "text/javascript",
+  css: "text/css",
+  html: "text/html",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  svg: "image/svg+xml",
+  eot: "application/vnd.ms-fontobject",
+  ttf: "application/font-ttf",
+  woff: "application/font-woff",
+  woff2: "application/font-woff2",
+};
+
+const mime = (basename: string) => {
+  const extension = basename.substr(basename.lastIndexOf(".") + 1);
+  return MIME_TYPES[extension] ?? "application/octet-stream";
+};
+
+export const fileResponse =
+  (filename: string, stat?: Stats, status: 200 | 404 | 500 = 200) =>
+  async (): Promise<StaticResponse> => {
+    if (!stat) {
+      stat = await fs.stat(filename);
+    }
+    const content = await fs.readFile(filename);
+    const contentType = mime(filename);
+    const contentLength = stat.size;
+    return { status, contentType, contentLength, content };
+  };
+
+export const contentResponse =
+  (content: string, contentType: string, status: 200 | 404 | 500 = 200) =>
+  async (): Promise<StaticResponse> => {
+    const contentBuffer = Buffer.from(content, "utf-8");
+    return {
+      content: contentBuffer,
+      contentType,
+      status,
+      contentLength: contentBuffer.length,
+    };
+  };

package/src/server/http/sitemap.ts

@@ -0,0 +1,48 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import { info } from "../../log.js";
+import { MiddlewareFactory, StaticMiddleware } from "./index.js";
+import { contentResponse } from "./response.js";
+
+const findSiteMap = async (root: string, prefix = root) => {
+  if (root.startsWith("node_modules")) {
+    return [];
+  }
+  const children = (await fs.readdir(root, { withFileTypes: true })).map(
+    async (entry): Promise<string[]> => {
+      const next = path
+        .join(root, entry.name)
+        // Normalize separators for web
+        .replaceAll(path.sep, "/");
+      if (entry.isFile()) {
+        if (entry.name === "index.html") {
+          let index = next.replace(prefix, "");
+          info(`Adding to sitemap`, { index });
+          return [index];
+        }
+      } else if (entry.isDirectory()) {
+        if (entry.name.startsWith(".")) {
+          return [];
+        }
+        const flattened = (
+          await Promise.all(await findSiteMap(next, prefix))
+        ).flat();
+        return flattened;
+      }
+      return [];
+    }
+  );
+  return children;
+};
+
+export const sitemap: MiddlewareFactory = async ({ root }) => {
+  const apps = await (await Promise.all(await findSiteMap(root)))
+    .flat()
+    .filter((a) => a !== undefined);
+  return async (req) => {
+    if ((req.url ?? "").endsWith("sitemap.json")) {
+      return contentResponse(JSON.stringify(apps), "application/json");
+    }
+    return undefined;
+  };
+};

package/src/server/http/static.ts

@@ -0,0 +1,27 @@
+import * as path from "path";
+import * as fs from "fs/promises";
+import { fileResponse } from "./response.js";
+import type { MiddlewareFactory } from "./index.js";
+
+export const staticFileServer: MiddlewareFactory =
+  async ({ root, scopes = {} }) =>
+  async (req) => {
+    const scope = Object.entries(scopes).find(([s]) =>
+      req.url?.startsWith(`/${s}`)
+    );
+    const url = new URL(req.url ?? "", `http://localhost`);
+    const pathname = scope
+      ? url.pathname.replace(scope[0], scope[1])
+      : url.pathname;
+    const filename = path.join(root, pathname);
+    // Expand url with found scope
+    console.log(scope, req.url, filename);
+
+    try {
+      const stat = await fs.stat(filename);
+      return stat.isDirectory() ? undefined : fileResponse(filename, stat);
+    } catch (e) {
+      console.error(e);
+      return undefined;
+    }
+  };

package/src/server/http/typescript.ts

@@ -0,0 +1,46 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import { contentResponse } from "./response.js";
+import { transpile } from "../../transpile.mjs";
+import { MiddlewareFactory } from "./index.js";
+
+function render(source: string) {
+  // Replace `from "@scope` with `from "/@scope`, for browsers
+  source = source
+    .replaceAll(`from "@`, 'from "/@')
+    .replaceAll(`import("@`, 'import("/@');
+  return contentResponse(source, "application/javascript");
+}
+
+/**
+ * Serves .js files statically. Finds .ts files and transpiles them to JS.
+ */
+export const tsFileServer: MiddlewareFactory =
+  async ({ root, scopes = {} }) =>
+  async (req) => {
+    if (req.url?.endsWith(".js")) {
+      let scope = Object.entries(scopes).find(([s]) =>
+        req.url?.startsWith(`/${s}`)
+      );
+      // Expand url with found scope
+      let url = scope ? req.url.replace(scope[0], scope[1]) : req.url;
+      let filename = path.join(root, url);
+      try {
+        const stat = await fs.stat(filename);
+        if (stat.isFile()) {
+          const js = (await fs.readFile(filename)).toString("utf-8");
+          return render(js);
+        }
+      } catch {}
+
+      filename = filename.replace(/\.js$/, ".ts");
+      try {
+        const stat = await fs.stat(filename);
+        if (stat.isFile()) {
+          const js = await transpile(filename, () => fs.readFile(filename));
+          return render(js);
+        }
+      } catch {}
+    }
+    return undefined;
+  };

package/src/server/main.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node --experimental-loader ../loader.mjs
+
+import { info } from "../log.js";
+info("Starting server", { cwd: process.cwd() });
+
+import { parse } from "../flags.js";
+const FLAGS = parse(process.argv);
+
+import { makeServer } from "./http/index.js";
+import * as path from "node:path";
+
+const server = await makeServer({ root: path.join(process.cwd(), "src") });
+server.listen(FLAGS.asNumber("port", 8080), FLAGS.asString("host", "0.0.0.0"));

package/src/test.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+import { parse } from "./flags.js";
+import { execute } from "./scope/execute.js";
+import { asXML } from "./scope/display/junit.js";
+import { onConsole } from "./scope/display/console.js";
+
+await import("./test_all.js");
+
+(async function () {
+  const results = await execute();
+
+  const FLAGS = parse(process.argv);
+
+  switch (FLAGS.asString("mode", "console")) {
+    case "junit":
+      const xml = asXML(results);
+      console.log(xml);
+      break;
+    case "console":
+    default:
+      onConsole(results);
+      break;
+  }
+
+  if (results.failed > 0) {
+    process.exit(1);
+  }
+})();

package/src/test_all.ts

@@ -0,0 +1,22 @@
+// This file must be .js for imports to run. Unused imports in .ts files are
+// discarded during transpilation.
+import { describe, expect, it } from "./scope/index.js";
+
+await Promise.all([
+  import("./context.test.js"),
+  import("./equal.test.js"),
+  import("./flags.test.js"),
+  import("./generator.test.js"),
+  import("./lock.test.js"),
+  import("./result.test.js"),
+]);
+
+describe("Test executor", () => {
+  it("matches equality", () => {
+    expect(1).toBe(1);
+  });
+
+  it("fails on inequality", () => {
+    expect(() => expect(1).toBe(2)).toThrow();
+  });
+});

package/src/transpile.mjs

@@ -0,0 +1,29 @@
+// @ts-ignore
+import ts from "typescript";
+
+const compilerOptions = {
+  target: ts.ScriptTarget.ESNext,
+  module: ts.ModuleKind.ESNext,
+  inlineSourceMap: true,
+  inlineSources: true,
+};
+
+const tsmap = new Map();
+
+export async function transpile(
+  /** @type string */ url,
+  /** @type {() => Promise<{toString(): string}>} */ get
+) {
+  if (!tsmap.has(url) || true) {
+    const source = ts.transpile(
+      (await get()).toString(),
+      compilerOptions,
+      url,
+      undefined,
+      url
+    );
+    tsmap.set(url, source);
+  }
+
+  return tsmap.get(url);
+}