@johnhenry/letterpress 0.0.0

package/test/req-res.mjs

@@ -0,0 +1,289 @@
+import { test } from "node:test";
+import { strict as assert } from "node:assert";
+import { createRequest, createResponse } from "../index.mjs";
+
+// Utility function to create a simple readable stream
+const createReadableStream = (data) => {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(new TextEncoder().encode(data));
+      controller.close();
+    },
+  });
+};
+
+await test("createRequest function tests", async (t) => {
+  await t.test("Basic GET request", async () => {
+    const request = await createRequest({ baseUrl: "http://example.com" })`
+      GET /api/data HTTP/1.1
+      User-Agent: TestAgent/1.0
+      Accept: application/json
+    `;
+    assert.equal(request.method, "GET");
+    assert.equal(request.url, "http://example.com/api/data");
+    assert.equal(request.headers.get("User-Agent"), "TestAgent/1.0");
+    assert.equal(request.headers.get("Accept"), "application/json");
+  });
+
+  await t.test("POST request with various body types", async (t) => {
+    const testCases = [
+      {
+        name: "JSON body",
+        body: JSON.stringify({ name: "John Doe", email: "john@example.com" }),
+        contentType: "application/json",
+        assert: async (req) => {
+          const body = await req.json();
+          assert.deepEqual(body, {
+            name: "John Doe",
+            email: "john@example.com",
+          });
+        },
+      },
+      {
+        name: "URLSearchParams body",
+        body: new URLSearchParams({ key1: "value1", key2: "value2" }),
+        contentType: "application/x-www-form-urlencoded",
+        assert: async (req) => {
+          const body = await req.text();
+          assert.equal(body, "key1=value1&key2=value2");
+        },
+      },
+      {
+        name: "FormData body",
+        body: (() => {
+          const formData = new FormData();
+          formData.append("username", "testuser");
+          formData.append("password", "testpass");
+          return formData;
+        })(),
+        contentType: "multipart/form-data",
+        assert: async (req) => {
+          assert.ok(
+            req.headers.get("Content-Type").startsWith("multipart/form-data")
+          );
+        },
+      },
+      {
+        name: "Uint8Array body",
+        body: new Uint8Array([1, 2, 3, 4, 5]),
+        contentType: "application/octet-stream",
+        assert: async (req) => {
+          const bodyBuffer = await req.arrayBuffer();
+          assert.deepEqual(
+            new Uint8Array(bodyBuffer),
+            new Uint8Array([1, 2, 3, 4, 5])
+          );
+        },
+      },
+      {
+        name: "ReadableStream body",
+        body: createReadableStream("This is streaming data"),
+        contentType: "application/octet-stream",
+        assert: async (req) => {
+          const bodyText = await req.text();
+          assert.equal(bodyText, "This is streaming data");
+        },
+      },
+    ];
+
+    for (const testCase of testCases) {
+      await t.test(`POST request with ${testCase.name}`, async () => {
+        const request = await createRequest({
+          baseUrl: "https://api.example.com",
+        })`
+          POST /data HTTP/1.1
+          User-Agent: TestAgent/1.0
+
+          ${testCase.body}
+        `;
+        assert.equal(request.method, "POST");
+        assert.equal(request.url, "https://api.example.com/data");
+        assert.ok(
+          request.headers.get("Content-Type").startsWith(testCase.contentType)
+        );
+        await testCase.assert(request);
+      });
+    }
+  });
+
+  await t.test("PUT request", async () => {
+    const request = await createRequest()`
+      PUT https://api.example.com/update HTTP/1.1
+      User-Agent: TestAgent/1.0
+      
+      ${new URLSearchParams({ key1: "value1", key2: "value2" })}
+    `;
+    assert.equal(request.method, "PUT");
+    assert.equal(request.url, "https://api.example.com/update");
+    assert.equal(
+      request.headers.get("Content-Type"),
+      "application/x-www-form-urlencoded"
+    );
+    const bodyText = await request.text();
+    assert.equal(bodyText, "key1=value1&key2=value2");
+  });
+
+  await t.test("DELETE request", async () => {
+    const request = await createRequest()`
+      DELETE https://api.example.com/users/123 HTTP/1.1
+      Authorization: Bearer token123
+    `;
+    assert.equal(request.method, "DELETE");
+    assert.equal(request.url, "https://api.example.com/users/123");
+    assert.equal(request.headers.get("Authorization"), "Bearer token123");
+    assert.equal(await request.text(), "");
+  });
+
+  await t.test("GET request with query parameters", async () => {
+    const request = await createRequest()`
+      GET https://api.example.com/search?q=test&page=1 HTTP/1.1
+      Accept: application/json
+    `;
+    assert.equal(request.method, "GET");
+    assert.equal(request.url, "https://api.example.com/search?q=test&page=1");
+    assert.equal(request.headers.get("Accept"), "application/json");
+  });
+});
+
+await test("createResponse function tests", async (t) => {
+  await t.test("Response with various status codes and bodies", async (t) => {
+    const testCases = [
+      {
+        name: "HTML response",
+        status: 200,
+        headers: { "Content-Type": "text/html" },
+        body: "<html><body>Hello, World!</body></html>",
+        assert: async (res) => {
+          assert.equal(
+            await res.text(),
+            "<html><body>Hello, World!</body></html>"
+          );
+        },
+      },
+      {
+        name: "JSON response",
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ message: "Hello, World!" }),
+        assert: async (res) => {
+          const body = await res.json();
+          assert.deepEqual(body, { message: "Hello, World!" });
+        },
+      },
+      {
+        name: "No Content response",
+        status: 204,
+        headers: {},
+        body: "",
+        assert: async (res) => {
+          assert.equal(await res.text(), "");
+          assert.equal(res.headers.get("Content-Length"), "0");
+        },
+      },
+      {
+        name: "Not Found response",
+        status: 404,
+        headers: { "Content-Type": "text/html" },
+        body: "Resource not found",
+        assert: async (res) => {
+          assert.equal(await res.text(), "Resource not found");
+        },
+      },
+    ];
+
+    for (const testCase of testCases) {
+      await t.test(`${testCase.name}`, async () => {
+        const response = await createResponse`HTTP/1.1 ${testCase.status} ${
+          testCase.status === 204 ? "No Content" : "OK"
+        }
+          Date: Mon, 27 Jul 2009 12:28:53 GMT
+          ${Object.entries(testCase.headers)
+            .map(([key, value]) => `${key}: ${value}`)
+            .join("\n")}
+
+          ${testCase.body}
+        `;
+        assert.equal(response.status, testCase.status);
+        for (const [key, value] of Object.entries(testCase.headers)) {
+          assert.equal(response.headers.get(key), value);
+        }
+        await testCase.assert(response);
+      });
+    }
+  });
+
+  await t.test("Response with various body types", async (t) => {
+    const testCases = [
+      {
+        name: "ArrayBuffer body",
+        body: new TextEncoder().encode("Hello, World!").buffer,
+        contentType: "application/octet-stream",
+        assert: async (res) => {
+          assert.equal(await res.text(), "Hello, World!");
+        },
+      },
+      {
+        name: "Blob body",
+        body: new Blob(["Hello, World!"], { type: "text/plain" }),
+        contentType: "text/plain",
+        assert: async (res) => {
+          assert.equal(await res.text(), "Hello, World!");
+        },
+      },
+      {
+        name: "ReadableStream body",
+        body: createReadableStream("This is streaming response data"),
+        contentType: "application/octet-stream",
+        assert: async (res) => {
+          assert.equal(await res.text(), "This is streaming response data");
+        },
+      },
+    ];
+
+    for (const testCase of testCases) {
+      await t.test(`Response with ${testCase.name}`, async () => {
+        const response = await createResponse`HTTP/1.1 200 OK
+          Date: Mon, 27 Jul 2009 12:28:53 GMT
+          Content-Type: ${testCase.contentType}
+
+          ${testCase.body}
+        `;
+        assert.equal(response.status, 200);
+        assert.equal(
+          response.headers.get("Content-Type"),
+          testCase.contentType
+        );
+        await testCase.assert(response);
+      });
+    }
+  });
+
+  await t.test("Response with custom headers", async () => {
+    const customHeaders = new Headers({
+      "X-Custom-Header": "CustomValue",
+      "Cache-Control": "no-cache",
+    });
+    const response = await createResponse`HTTP/1.1 200 OK
+      Date: Mon, 27 Jul 2009 12:28:53 GMT
+      ${customHeaders}
+
+      Custom response body
+    `;
+    assert.equal(response.status, 200);
+    assert.equal(response.headers.get("X-Custom-Header"), "CustomValue");
+    assert.equal(response.headers.get("Cache-Control"), "no-cache");
+    assert.equal(await response.text(), "Custom response body");
+  });
+
+  await t.test("Response with retroactive headers", async () => {
+    const response = await createResponse`HTTP/1.1 200 OK
+      Date: Mon, 27 Jul 2009 12:28:53 GMT
+
+      Hello, World!
+    `;
+    assert.equal(response.status, 200);
+    assert.equal(response.headers.get("Content-Type"), "text/html");
+    assert.equal(response.headers.get("Content-Length"), "13");
+    assert.equal(await response.text(), "Hello, World!");
+  });
+});

package/test/route.mjs

@@ -0,0 +1,116 @@
+import { createRoute } from "../create-route.mjs";
+
+import { describe, it } from "node:test";
+import assert from "node:assert";
+
+describe("createRoute", () => {
+  it("should create a basic route", async () => {
+    const route = createRoute()`Hello, World!`;
+    const response = await route(new Request("https://example.com"));
+    assert.strictEqual(await response.text(), "Hello, World!");
+    assert.strictEqual(response.status, 200);
+    assert.strictEqual(response.headers.get("Content-Type"), "text/html");
+  });
+
+  it("should handle function substitutions", async () => {
+    const route = createRoute()`The number is: ${() => 42}`;
+    const response = await route(new Request("https://example.com"));
+    assert.strictEqual(await response.text(), "The number is: 42");
+  });
+
+  it("should handle async function substitutions", async () => {
+    const route = createRoute()`The result is: ${async () => {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      return "async";
+    }}`;
+    const response = await route(new Request("https://example.com"));
+    assert.strictEqual(await response.text(), "The result is: async");
+  });
+
+  it("should allow setting custom headers", async () => {
+    const route = createRoute({
+      headers: { "X-Custom-Header": "Test" },
+    })`Custom header test`;
+    const response = await route(new Request("https://example.com"));
+    assert.strictEqual(response.headers.get("X-Custom-Header"), "Test");
+  });
+
+  it("should allow setting custom status", async () => {
+    const route = createRoute({
+      status: 404,
+      statusText: "Not Found",
+    })`404 Not Found`;
+    const response = await route(new Request("https://example.com"));
+    assert.strictEqual(response.status, 404);
+    assert.strictEqual(response.statusText, "Not Found");
+  });
+
+  it("should treat a null/undefined substitution as empty rather than throwing", async () => {
+    // Regression test: `sub.toString()` was called unconditionally on
+    // directly-substituted values, so `${null}` or `${undefined}` in a
+    // template threw "Cannot read properties of null/undefined (reading
+    // 'toString')" instead of behaving like ordinary JS template literals.
+    const nullRoute = createRoute()`Before ${null} After`;
+    const nullResponse = await nullRoute(new Request("https://example.com"));
+    assert.strictEqual(await nullResponse.text(), "Before  After");
+
+    const undefinedRoute = createRoute()`Before ${undefined} After`;
+    const undefinedResponse = await undefinedRoute(
+      new Request("https://example.com")
+    );
+    assert.strictEqual(await undefinedResponse.text(), "Before  After");
+  });
+
+  it("should treat a substitution function returning null the same as returning undefined", async () => {
+    // Regression test: a function substitution's `undefined` result is
+    // explicitly skipped, but a `null` result hit the same `.toString()`
+    // call and threw.
+    const route = createRoute()`Before ${() => null} After`;
+    const response = await route(new Request("https://example.com"));
+    assert.strictEqual(await response.text(), "Before  After");
+  });
+
+  it("should pass through a stream/binary value returned by a substitution function", async () => {
+    // Regression test: a directly-substituted ReadableStream/Blob/
+    // ArrayBuffer/Uint8Array is returned as the raw response body, but a
+    // substitution *function* that returned one of those values was
+    // coerced with `.toString()`, producing the literal text
+    // "[object ReadableStream]" instead of the stream's actual content.
+    const route = createRoute()`${() =>
+      new ReadableStream({
+        start(controller) {
+          controller.enqueue(new TextEncoder().encode("STREAMED"));
+          controller.close();
+        },
+      })}`;
+    const response = await route(new Request("https://example.com"));
+    assert.strictEqual(await response.text(), "STREAMED");
+  });
+
+  it("should handle streaming responses", async () => {
+    const route = createRoute({ streaming: true })`
+      ${async (_, { response }) => {
+        response.headers.set("X-Streaming", "True");
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        return "Part 1";
+      }}
+      ${async () => {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        return "Part 2";
+      }}
+    `;
+    const response = await route(new Request("https://example.com"));
+    assert.strictEqual(response.headers.get("X-Streaming"), "True");
+    assert.strictEqual(response.headers.get("Content-Length"), "13");
+
+    const reader = response.body.getReader();
+    let result = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      result += new TextDecoder().decode(value);
+    }
+    assert.match(result, /Part 1/);
+    assert.match(result, /Part 2/);
+  });
+});

package/test/router.mjs

@@ -0,0 +1,213 @@
+import { createRouter } from "../create-router.mjs";
+import HTTPExpression, {
+  InlineParameter,
+  HeaderMatch,
+} from "../utility/http-expression.mjs";
+
+import { describe, it, test } from "node:test";
+import assert from "node:assert";
+
+test("Router - Basic routing", async () => {
+  const router = createRouter();
+  router.endpoint`GET /``Hello, World!`;
+  const request = new Request("http://example.com/");
+  const response = await router(request);
+  assert.equal(await response.text(), "Hello, World!");
+  assert.equal(response.status, 200);
+});
+
+test("Router - URL parameters", async () => {
+  const router = createRouter();
+  router.endpoint`GET /user/:id``User ID: ${(_, { params }) => params.id}`;
+
+  const request = new Request("http://example.com/user/123");
+  const response = await router(request);
+  assert.equal(await response.text(), "User ID: 123");
+});
+
+test("Router - 404 for unmatched routes", async () => {
+  const router = createRouter();
+  router.endpoint`GET /``Hello, World!`;
+
+  const request = new Request("http://example.com/not-found");
+  const response = await router(request);
+  assert.equal(response.status, 404);
+});
+
+test("Router - Custom error handler", async () => {
+  const router = createRouter({
+    errorHandler: (error, request) =>
+      new Response(`Custom Error: ${error.message}`, { status: 500 }),
+  });
+  router.endpoint`GET /error`(() => {
+    throw new Error("Test Error");
+  });
+
+  const request = new Request("http://example.com/error");
+  const response = await router(request);
+  assert.equal(response.status, 500);
+  assert.equal(await response.text(), "Custom Error: Test Error");
+});
+
+test("Router - Custom error handler catches rejections from async handlers", async () => {
+  // Regression test: an earlier version did `return handler(...)` inside the
+  // try block instead of `return await handler(...)`. Since calling an async
+  // function always returns a promise (even when it throws synchronously),
+  // that throw never surfaced inside the try/catch, so the rejection escaped
+  // past errorHandler entirely instead of producing a 500 response.
+  const router = createRouter({
+    errorHandler: (error, request) =>
+      new Response(`Custom Error: ${error.message}`, { status: 500 }),
+  });
+  router.endpoint`GET /async-error`(async () => {
+    throw new Error("Async Test Error");
+  });
+
+  const request = new Request("http://example.com/async-error");
+  const response = await router(request);
+  assert.equal(response.status, 500);
+  assert.equal(await response.text(), "Custom Error: Async Test Error");
+});
+
+test("Router - does not leak request headers into the response", async () => {
+  // Regression test: the handler wrapper created by `router.endpoint` used
+  // to pass the per-request context object (which includes `headers` set to
+  // the *request's* Headers, so substitution functions can read them) into
+  // createRoute() as its RouteInit. createRoute seeds the response
+  // Headers from `init.headers`, so every request header (Cookie,
+  // Authorization, arbitrary custom headers) was being echoed back as a
+  // response header.
+  const router = createRouter();
+  router.endpoint`GET /secure``Hello, World!`;
+
+  const request = new Request("http://example.com/secure", {
+    headers: {
+      Authorization: "Bearer topsecret",
+      Cookie: "sessionid=abc123",
+      "X-Secret-Session": "super-secret-token",
+    },
+  });
+  const response = await router(request);
+  assert.equal(response.headers.has("authorization"), false);
+  assert.equal(response.headers.has("cookie"), false);
+  assert.equal(response.headers.has("x-secret-session"), false);
+  assert.equal(await response.text(), "Hello, World!");
+});
+
+test("Router - substitution functions can still read request context after the header fix", async () => {
+  // Companion to the header-leak regression test above: fixing that bug must
+  // not remove handlers' ability to read params/method/headers via context.
+  const router = createRouter();
+  router.endpoint`GET /user/:id``ID:${(_, { params }) =>
+    params.id} Method:${(_, { method }) => method} Accept:${(
+    _,
+    { headers }
+  ) => headers.get("Accept")}`;
+
+  const request = new Request("http://example.com/user/42", {
+    headers: { Accept: "text/plain" },
+  });
+  const response = await router(request);
+  assert.equal(await response.text(), "ID:42 Method:GET Accept:text/plain");
+});
+
+test("Router - Multiple routes", async () => {
+  const router = createRouter();
+  router.endpoint`GET /``Home`;
+  router.endpoint`GET /about``About`;
+  router.endpoint`GET /contact``Contact`;
+
+  const routes = ["/", "/about", "/contact"];
+  for (const route of routes) {
+    const request = new Request(`http://example.com${route}`);
+    const response = await router(request);
+    assert.equal(
+      await response.text().then((s) => s.toLowerCase()),
+      route === "/" ? "home" : route.slice(1)
+    );
+  }
+});
+
+test("Router - Method matching", async () => {
+  const router = createRouter();
+  router.endpoint`GET /api``GET API`;
+  router.endpoint`POST /api``POST API`;
+
+  const getRequest = new Request("http://example.com/api", { method: "GET" });
+  const postRequest = new Request("http://example.com/api", { method: "POST" });
+
+  const getResponse = await router(getRequest);
+  const postResponse = await router(postRequest);
+
+  assert.equal(await getResponse.text(), "GET API");
+  assert.equal(await postResponse.text(), "POST API");
+});
+
+test("Router - Nested routes", async () => {
+  const router = createRouter();
+  router.endpoint`GET /api/v1/users``API v1 Users`;
+  router.endpoint`GET /api/v2/users``API v2 Users`;
+
+  const v1Request = new Request("http://example.com/api/v1/users");
+  const v2Request = new Request("http://example.com/api/v2/users");
+
+  const v1Response = await router(v1Request);
+  const v2Response = await router(v2Request);
+
+  assert.equal(await v1Response.text(), "API v1 Users");
+  assert.equal(await v2Response.text(), "API v2 Users");
+});
+
+test("Router - Function handler", async () => {
+  const router = createRouter();
+  router.endpoint`GET /function`((request) => {
+    return new Response("Function handler", { status: 200 });
+  });
+
+  const request = new Request("http://example.com/function");
+  const response = await router(request);
+
+  assert.equal(await response.text(), "Function handler");
+  assert.equal(response.status, 200);
+});
+
+// Commented out tests
+/*
+test("Router - InlineParam", async () => {
+  const router = createRouter();
+  const id = InlineParam({
+    name: "id",
+    type: "number",
+    min: 1,
+    max: 1000,
+  });
+  router.endpoint`GET /user/${id}``User ID: ${(_, { params }) => params.id}`;
+
+  const request = new Request("http://example.com/user/123");
+  const response = await router(request);
+  assert.equal(await response.text(), "User ID: 123");
+});
+
+test("Router - HeaderMatch", async () => {
+  const router = createRouter();
+  const jsonHeader = HeaderMatch({
+    name: "Content-Type",
+    value: "application/json",
+  });
+  router.endpoint`POST /api ${jsonHeader}`(async (request) => {
+    const data = await request.json();
+    return new Response(JSON.stringify({ received: data }), {
+      headers: { "Content-Type": "application/json" },
+    });
+  });
+
+  const request = new Request("http://example.com/api", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ test: "data" }),
+  });
+  const response = await router(request);
+  assert.equal(response.headers.get("Content-Type"), "application/json");
+  assert.equal(await response.json(), { received: { test: "data" } });
+});
+*/

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "lib": [
+            "ESNext"
+        ]
+    },
+    "include": [
+        ".cushy/*.d.ts",
+        "**/*.ts"
+    ]
+}