@johnhenry/letterpress 0.0.0

package/types.d.ts

@@ -0,0 +1,85 @@
+// Represents a route handler function
+export type Route = (
+  request: Request,
+  context?: Record<string, any>
+) => Response | Promise<Response>;
+
+// Extension for the Router to add endpoints
+export type RouterExtension = {
+  endpoint: (
+    template: TemplateStringsArray,
+    ...substitutions: any[]
+  ) => Router;
+};
+
+// Combines Route and RouterExtension
+export type Router = Route & RouterExtension;
+
+// Configuration options for a Route
+export type RouteInit = {
+  headers?: HeadersInit | Headers;
+  status?: number;
+  statusText?: string;
+  streaming?: boolean;
+};
+
+// Middleware for Route
+export type RouteMiddleware =
+  | RouteInit
+  | ((request: Request) => RouteInit);
+
+// Function to create a Route
+export type CreateRoute = (
+  init?: RouteMiddleware
+) => (template: TemplateStringsArray, ...substitutions: any[]) => Route;
+
+// Configuration options for a Router
+export type RouterInit = {
+  baseUrl?: string;
+  defaultHandler?: Route;
+  errorHandler?: (
+    error: Error,
+    request: Request
+  ) => Response | Promise<Response>;
+  cache?: CacheOptions;
+};
+
+// Middleware for Router
+export type RouterMiddleware =
+  | RouterInit
+  | ((request: Request) => RouterInit);
+
+// Function to create a Router
+export type CreateRouter = (init?: RouterMiddleware) => Router;
+
+// Cache options
+export type CacheOptions = {
+  // Add cache-related options here
+};
+
+// InlineParam options
+export type InlineParamOptions = {
+  name: string;
+  optional?: boolean;
+  type?: "string" | "number" | "boolean";
+  default?: any;
+  cast?: (value: string) => any;
+  max?: number;
+  min?: number;
+  array?: boolean;
+  delimiter?: string;
+};
+
+// HeaderMatch options
+export type HeaderMatchOptions = {
+  name: string;
+  value?: string;
+  operator?: "=" | "^=" | "$=" | "~=" | "*=" | ">" | "<" | ">=" | "<=";
+  negate?: boolean;
+  set?: string[];
+  range?: [number, number];
+  rangeInclusive?: [boolean, boolean];
+};
+
+export type InlineParam = (options: InlineParamOptions) => string;
+export type HeaderMatch = (options: HeaderMatchOptions) => string;

package/utility/cook.mjs

@@ -0,0 +1,5 @@
+// https://2ality.com/2016/11/computing-tag-functions.html
+export const cook = (strs, ...substs) => {
+  return substs.reduce((prev, cur, i) => prev + cur + strs[i + 1], strs[0]);
+};
+export default cook;

package/utility/deconstruct.mjs

@@ -0,0 +1,5 @@
+export const deconstruct = (strings, ...substitutions) => {
+  const { raw } = strings;
+  return { strings: [...strings], substitutions, raw };
+};
+export default deconstruct;

package/utility/dynamic-run.mjs

@@ -0,0 +1,30 @@
+import { promises as fs } from "fs";
+import path from "path";
+import { randomUUID } from "crypto";
+import theresWaldo from "theres-waldo";
+
+export const dynamicRun = async (code, directory) => {
+  const tempFileName = `temp-${randomUUID()}.mjs`;
+  const tempFilePath = path.join(directory, tempFileName);
+
+  let written = false;
+  try {
+    await fs.writeFile(tempFilePath, code);
+    written = true;
+    const importedModule = await import(tempFilePath);
+    // Best-effort cleanup: a failure to unlink here must not mask a
+    // successful import, nor leave the caller without its result.
+    await fs.unlink(tempFilePath).catch(() => {});
+    return importedModule;
+  } catch (error) {
+    // Only attempt cleanup if the file was actually written - otherwise
+    // (e.g. writeFile itself failed because the directory isn't writable)
+    // this unlink would throw its own ENOENT and mask the real error.
+    if (written) {
+      await fs.unlink(tempFilePath).catch(() => {});
+    }
+    throw error;
+  }
+};
+
+export default dynamicRun;

package/utility/http-expression.mjs

@@ -0,0 +1,158 @@
+export const InlineParameter = ({
+  name,
+  type = "string",
+  optional = false,
+  transform = (x) => x,
+}) => {
+  return { type: "inlineParam", name, paramType: type, optional, transform };
+};
+
+export const HeaderMatch = ({
+  name,
+  operator = "exists",
+  value,
+  negate = false,
+}) => {
+  return { type: "headerMatch", name, operator, value, negate };
+};
+
+export const HTTPExpression = (strings, ...expressions) => {
+  let method,
+    pathPattern = "",
+    headerMatchers = [];
+  let currentPart = "METHOD";
+  let buffer = "";
+
+  const processBuffer = () => {
+    if (currentPart === "METHOD") {
+      method = buffer.trim();
+      currentPart = "PATH";
+    } else if (currentPart === "PATH") {
+      pathPattern += buffer;
+    }
+    buffer = "";
+  };
+
+  for (let i = 0; i < strings.length; i++) {
+    const str = strings[i];
+    for (let j = 0; j < str.length; j++) {
+      const char = str[j];
+      if (char === " " && currentPart === "METHOD") {
+        processBuffer();
+      } else if (char === "[" && currentPart !== "HEADER_VALUE") {
+        processBuffer();
+        currentPart = "HEADERS";
+        buffer = "[";
+      } else if (char === "]" && currentPart === "HEADERS") {
+        buffer += char;
+        headerMatchers.push(parseHeaderMatcher(buffer));
+        buffer = "";
+      } else {
+        buffer += char;
+      }
+    }
+
+    processBuffer();
+
+    if (i < expressions.length) {
+      const expr = expressions[i];
+      if (expr && expr.type === "inlineParam") {
+        pathPattern += `:${expr.name}`;
+      } else if (expr && expr.type === "headerMatch") {
+        headerMatchers.push(createHeaderMatcherFunction(expr));
+      }
+    }
+  }
+
+  pathPattern = pathPattern.trim();
+  const pathRegex = new RegExp(
+    "^" + pathPattern.replace(/:\w+/g, "([^/]+)") + "$"
+  );
+  const paramNames = (pathPattern.match(/:\w+/g) || []).map((p) => p.slice(1));
+
+  return {
+    test(request) {
+      if (request.method !== method) return false;
+      if (!pathRegex.test(new URL(request.url).pathname)) return false;
+      return headerMatchers.every((matcher) => matcher(request.headers));
+    },
+    exec(request) {
+      if (!this.test(request)) return null;
+      const match = new URL(request.url).pathname.match(pathRegex);
+      const params = Object.fromEntries(
+        paramNames.map((name, i) => [name, match[i + 1]])
+      );
+      return { ...params, method, headers: request.headers };
+    },
+  };
+};
+
+const parseHeaderMatcher = (headerString) => {
+  const match = headerString.match(/\[(!?)([^=~^$*<>]+)([=~^$*<>]+)?(.+)?\]/);
+  if (!match) {
+    throw new Error(`Invalid header matcher: ${headerString}`);
+  }
+  const [, negation, name, operator, value] = match;
+  return createHeaderMatcherFunction({
+    name: name.trim(),
+    operator: operator?.trim(),
+    value: value?.trim(),
+    negate: !!negation,
+  });
+};
+
+const createHeaderMatcherFunction = ({ name, operator, value, negate }) => {
+  return (headers) => {
+    const headerValue = headers.get(name);
+    const exists = headers.has(name);
+    let match = false;
+
+    if (!operator || operator === "exists") {
+      match = exists;
+    } else if (!exists) {
+      match = false;
+    } else {
+      switch (operator) {
+        case "=":
+          match = headerValue === value;
+          break;
+        case "~=": {
+          let regex = value || "";
+          let flags = "";
+          if (regex.startsWith("(?i)")) {
+            regex = regex.slice(4);
+            flags = "i";
+          }
+          match = new RegExp(regex, flags).test(headerValue);
+          break;
+        }
+        case "^=":
+          match = headerValue.startsWith(value || "");
+          break;
+        case "$=":
+          match = headerValue.endsWith(value || "");
+          break;
+        case "*=":
+          match = headerValue.includes(value || "");
+          break;
+        case ">":
+          match = parseFloat(headerValue) > parseFloat(value || "0");
+          break;
+        case "<":
+          match = parseFloat(headerValue) < parseFloat(value || "0");
+          break;
+        case ">=":
+          match = parseFloat(headerValue) >= parseFloat(value || "0");
+          break;
+        case "<=":
+          match = parseFloat(headerValue) <= parseFloat(value || "0");
+          break;
+        default:
+          match = false;
+      }
+    }
+    return negate ? !match : match;
+  };
+};
+
+export default HTTPExpression;

package/utility/index.mjs

@@ -0,0 +1,3 @@
+export { HTTPExpression } from "./http-expression.mjs";
+export { deconstruct } from "./deconstruct.mjs";
+export { cook } from "./cook.mjs";