elm-ssr 0.2.0 → 0.3.0

package/test/island-runtime.test.ts

@@ -1,214 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { Window } from "happy-dom";
-import { islandsCoreSource } from "elm-ssr/islands-runtime";
-
-// Exercises the real island client runtime (boot + persistence + navigation)
-// against a happy-dom DOM, with the actual compiled island bundle injected.
-// This covers the paths the browser-island suite can't: mounting into the
-// <elm-ssr-island> marker, persistence transfer, head sync, and bus cleanup.
-
-type IslandRuntime = {
-  bootIslands: () => Promise<void>;
-  navigate: (url: URL, push?: boolean) => Promise<void>;
-  handleLinkClick: (event: unknown) => void;
-  persistentIslands: Map<string, Element>;
-};
-
-const createRuntime = new Function(`${islandsCoreSource}\nreturn createIslandsRuntime;`)() as (
-  deps: unknown
-) => IslandRuntime;
-
-const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
-
-// happy-dom's querySelector throws on this version, so navigate the DOM by hand.
-const firstMarker = (): Element | undefined =>
-  window.document.getElementsByTagName("elm-ssr-island")[0] as unknown as Element | undefined;
-
-const findByClass = (root: Element, className: string): Element | null => {
-  if ((root.getAttribute("class") || "").split(/\s+/).includes(className)) {
-    return root;
-  }
-  for (const child of Array.from(root.children)) {
-    const match = findByClass(child as Element, className);
-    if (match) {
-      return match;
-    }
-  }
-  return null;
-};
-
-const hasMeta = (name: string): boolean =>
-  Array.from(window.document.head.getElementsByTagName("meta")).some(
-    (meta) => (meta as unknown as Element).getAttribute("name") === name
-  );
-
-let window: Window;
-let previousGlobals: Map<string, unknown>;
-
-const GLOBAL_KEYS = [
-  "window",
-  "document",
-  "navigator",
-  "Node",
-  "Element",
-  "HTMLElement",
-  "Event",
-  "MouseEvent",
-  "CustomEvent",
-  "requestAnimationFrame",
-  "cancelAnimationFrame"
-] as const;
-
-const installGlobals = (next: Window) => {
-  const get = (key: string): unknown => {
-    const value = (next as unknown as Record<string, unknown>)[key];
-    return typeof value === "function" ? (value as (...args: unknown[]) => unknown).bind(next) : value;
-  };
-
-  previousGlobals = new Map(GLOBAL_KEYS.map((key) => [key, Reflect.get(globalThis, key)]));
-  for (const key of GLOBAL_KEYS) {
-    Reflect.set(globalThis, key, get(key));
-  }
-};
-
-const restoreGlobals = () => {
-  for (const [key, value] of previousGlobals.entries()) {
-    Reflect.set(globalThis, key, value);
-  }
-};
-
-const loadCounterBundle = async () => {
-  Reflect.deleteProperty(globalThis, "Elm");
-  const moduleRef = await import(`../generated/examples/basic/islands.mjs?cache=${Date.now()}-${Math.random()}`);
-  return moduleRef.default;
-};
-
-const manifest = { Counter: { module: "Example.Basic.Islands.Counter" } };
-
-const marker = (props: Record<string, unknown>, id?: string): string => {
-  const attrs = [
-    'data-elmssr-island="Counter"',
-    `data-elmssr-props='${JSON.stringify(props)}'`,
-    id ? `data-elmssr-id="${id}"` : ""
-  ]
-    .filter(Boolean)
-    .join(" ");
-  return `<div id="elm-ssr-root"><elm-ssr-island ${attrs}>fallback text</elm-ssr-island></div>`;
-};
-
-const newRuntime = async (loadBundle?: () => Promise<unknown>): Promise<IslandRuntime> =>
-  createRuntime({
-    document: window.document,
-    window,
-    manifest,
-    loadBundle: loadBundle ?? loadCounterBundle
-  });
-
-beforeEach(() => {
-  window = new Window({ url: "https://example.com/" });
-  installGlobals(window);
-});
-
-afterEach(() => {
-  restoreGlobals();
-});
-
-describe("island client runtime", () => {
-  it("mounts into a child so the marker (and its id) survives Browser.element", async () => {
-    window.document.body.innerHTML = marker({ start: 5 }, "counter-1");
-    const runtime = await newRuntime();
-
-    await runtime.bootIslands();
-    await tick();
-
-    const el = firstMarker();
-    // With a naive mount into the marker, Browser.element would replace it and
-    // this would be undefined. Child-mount keeps the marker as the persistent unit.
-    expect(el).toBeDefined();
-    expect(el?.getAttribute("data-elmssr-booted")).toBe("true");
-    expect(el?.textContent).toContain("5");
-    expect(el?.textContent).not.toContain("fallback text");
-    expect(runtime.persistentIslands.get("counter-1")).toBe(el as Element);
-  });
-
-  it("transfers a persistent island across navigation, preserving state, and syncs head", async () => {
-    window.document.body.innerHTML = marker({ start: 5 }, "counter-1");
-    const html =
-      "<!doctype html><html><head><title>Next Page</title>" +
-      '<meta name="x" content="y"></head><body>' +
-      marker({ start: 999 }, "counter-1") +
-      "</body></html>";
-
-    window.fetch = (async () => ({ json: async () => ({ html }) })) as unknown as typeof window.fetch;
-
-    const runtime = await newRuntime();
-    await runtime.bootIslands();
-    await tick();
-
-    const live = firstMarker() as Element;
-    findByClass(live, "primary")?.dispatchEvent(new window.Event("click", { bubbles: true }) as unknown as Event);
-    await tick();
-    expect(live.textContent).toContain("6");
-
-    await runtime.navigate(new URL("https://example.com/next"));
-    await tick();
-
-    const afterNav = firstMarker() as Element;
-    expect(afterNav).toBe(live); // same node transferred
-    expect(afterNav.textContent).toContain("6"); // state preserved, not reset to 999
-    expect(window.document.title).toBe("Next Page");
-    expect(hasMeta("x")).toBe(true);
-  });
-
-  it("does not register a duplicate bus listener when a persistent island transfers", async () => {
-    window.document.body.innerHTML = marker({ start: 0 }, "counter-1");
-    let busListeners = 0;
-    const realAdd = window.addEventListener.bind(window);
-    window.addEventListener = ((type: string, ...rest: unknown[]) => {
-      if (type === "elm-ssr-broadcast") {
-        busListeners += 1;
-      }
-      return (realAdd as (...a: unknown[]) => unknown)(type, ...rest);
-    }) as typeof window.addEventListener;
-
-    const html = "<!doctype html><html><head><title>N</title></head><body>" + marker({ start: 0 }, "counter-1") + "</body></html>";
-    window.fetch = (async () => ({ json: async () => ({ html }) })) as unknown as typeof window.fetch;
-
-    const runtime = await newRuntime();
-    await runtime.bootIslands();
-    await tick();
-    await runtime.navigate(new URL("https://example.com/a"));
-    await tick();
-    await runtime.navigate(new URL("https://example.com/b"));
-    await tick();
-
-    // Counter wires broadcastOut (not broadcastIn), so it registers no bus
-    // listener at all; the key assertion is that transfers never re-wire.
-    expect(busListeners).toBeLessThanOrEqual(1);
-  });
-
-  it("ignores hash-only / same-page links (no SPA fetch)", async () => {
-    window.document.body.innerHTML = marker({ start: 0 });
-    let fetched = false;
-    window.fetch = (async () => {
-      fetched = true;
-      return { json: async () => ({}) };
-    }) as unknown as typeof window.fetch;
-
-    const runtime = await newRuntime();
-
-    let prevented = false;
-    const link = window.document.createElement("a");
-    link.setAttribute("href", "https://example.com/#section");
-    runtime.handleLinkClick({
-      target: link,
-      preventDefault: () => {
-        prevented = true;
-      }
-    });
-    await tick();
-
-    expect(prevented).toBe(false);
-    expect(fetched).toBe(false);
-  });
-});

package/test/middleware.test.ts

@@ -1,134 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import type { AppContext, AppHandler, Middleware } from "elm-ssr/http";
-import {
-  composeMiddleware,
-  errorMiddleware,
-  headMiddleware,
-  loggingMiddleware,
-  requestIdMiddleware,
-  timingMiddleware
-} from "elm-ssr/middleware";
-
-const contextFor = (request: Request): AppContext => ({
-  request,
-  url: new URL(request.url),
-  requestId: "",
-  startedAt: performance.now()
-});
-
-const ok = (): AppHandler => async () => new Response("ok", { status: 200, headers: { "content-type": "text/plain" } });
-
-describe("composeMiddleware", () => {
-  it("runs middlewares outermost-first on the way in and innermost-first on the way out", async () => {
-    const order: string[] = [];
-    const a: Middleware = async (ctx, next) => {
-      order.push("a-in");
-      const res = await next(ctx);
-      order.push("a-out");
-      return res;
-    };
-    const b: Middleware = async (ctx, next) => {
-      order.push("b-in");
-      const res = await next(ctx);
-      order.push("b-out");
-      return res;
-    };
-
-    const handler = composeMiddleware(async () => {
-      order.push("handler");
-      return new Response("");
-    }, [a, b]);
-
-    await handler(contextFor(new Request("https://example.com/")));
-    expect(order).toEqual(["a-in", "b-in", "handler", "b-out", "a-out"]);
-  });
-});
-
-describe("requestIdMiddleware", () => {
-  it("reuses an incoming x-request-id and echoes it back", async () => {
-    const handler = composeMiddleware(ok(), [requestIdMiddleware]);
-    const response = await handler(
-      contextFor(new Request("https://example.com/", { headers: { "x-request-id": "abc-123" } }))
-    );
-    expect(response.headers.get("x-request-id")).toBe("abc-123");
-  });
-
-  it("generates an id when the header is missing", async () => {
-    const handler = composeMiddleware(ok(), [requestIdMiddleware]);
-    const response = await handler(contextFor(new Request("https://example.com/")));
-    expect(response.headers.get("x-request-id")).toMatch(/^[0-9a-f-]{36}$/);
-  });
-});
-
-describe("timingMiddleware", () => {
-  it("adds server-timing and x-response-time headers", async () => {
-    const handler = composeMiddleware(ok(), [timingMiddleware]);
-    const response = await handler(contextFor(new Request("https://example.com/")));
-    expect(response.headers.get("server-timing")).toMatch(/^app;dur=\d+(\.\d+)?$/);
-    expect(response.headers.get("x-response-time")).toMatch(/^\d+(\.\d+)?ms$/);
-  });
-});
-
-describe("headMiddleware", () => {
-  it("strips the body for HEAD while preserving status + headers", async () => {
-    const inner: AppHandler = async () =>
-      new Response("payload", { status: 200, headers: { "x-custom": "yes", "content-type": "text/plain" } });
-    const handler = composeMiddleware(inner, [headMiddleware]);
-    const response = await handler(contextFor(new Request("https://example.com/", { method: "HEAD" })));
-    expect(response.status).toBe(200);
-    expect(response.headers.get("x-custom")).toBe("yes");
-    expect(await response.text()).toBe("");
-  });
-
-  it("leaves non-HEAD responses untouched", async () => {
-    const handler = composeMiddleware(ok(), [headMiddleware]);
-    const response = await handler(contextFor(new Request("https://example.com/")));
-    expect(await response.text()).toBe("ok");
-  });
-});
-
-describe("errorMiddleware", () => {
-  const failingHandler: AppHandler = async () => {
-    throw new Error("boom");
-  };
-
-  it("returns plain-text 500 for non-/api/ routes when the handler throws", async () => {
-    const handler = composeMiddleware(failingHandler, [errorMiddleware]);
-    const response = await handler(contextFor(new Request("https://example.com/page")));
-    expect(response.status).toBe(500);
-    expect(response.headers.get("content-type") || "").toContain("text/plain");
-    expect(await response.text()).toBe("Internal Server Error");
-  });
-
-  it("returns JSON 500 with requestId for /api/ routes when the handler throws", async () => {
-    const context = contextFor(new Request("https://example.com/api/things"));
-    context.requestId = "req-7";
-    const handler = composeMiddleware(failingHandler, [errorMiddleware]);
-    const response = await handler(context);
-    expect(response.status).toBe(500);
-    const body = await response.json();
-    expect(body).toEqual({ error: "internal_error", requestId: "req-7" });
-  });
-});
-
-describe("loggingMiddleware", () => {
-  it("emits one JSON log line per completed request", async () => {
-    const lines: string[] = [];
-    const logger = (entry: string) => lines.push(entry);
-    const handler = composeMiddleware(ok(), [loggingMiddleware(logger)]);
-
-    await handler(contextFor(new Request("https://example.com/things?x=1", { method: "GET" })));
-    // The logger is dispatched detached; let microtasks settle.
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    expect(lines).toHaveLength(1);
-    const entry = JSON.parse(lines[0] as string);
-    expect(entry).toMatchObject({
-      event: "request_completed",
-      method: "GET",
-      path: "/things",
-      status: 200
-    });
-    expect(typeof entry.durationMs).toBe("number");
-  });
-});

package/test/migrations.test.ts

@@ -1,244 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { Database } from "bun:sqlite";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { resolve } from "node:path";
-import {
-  listMigrations,
-  revertMigrations,
-  runMigrations,
-  type MigrationsAdapter
-} from "elm-ssr/migrations";
-
-// The migration runner is backend-neutral; here we drive it against an
-// in-memory SQLite database via bun:sqlite. The same `MigrationsAdapter`
-// shape works for Postgres (Bun.sql / node-postgres) and D1 — the integration
-// test in test/integration/ covers Postgres against a real server.
-
-const sqliteAdapter = (db: Database): MigrationsAdapter => ({
-  exec: async (sql) => {
-    db.exec(sql);
-  },
-  list: async (sql) => db.query(sql).all() as Array<Record<string, unknown>>
-});
-
-let dir: string;
-let db: Database;
-let adapter: MigrationsAdapter;
-
-const seed = async (files: Record<string, string>): Promise<void> => {
-  await Promise.all(Object.entries(files).map(([name, sql]) => writeFile(resolve(dir, name), sql)));
-};
-
-beforeEach(async () => {
-  dir = await mkdtemp(resolve(tmpdir(), "elm-ssr-mig-"));
-  db = new Database(":memory:");
-  adapter = sqliteAdapter(db);
-});
-
-afterEach(async () => {
-  db.close();
-  await rm(dir, { recursive: true, force: true });
-});
-
-describe("runMigrations", () => {
-  it("applies all pending migrations in alphabetical order and tracks them", async () => {
-    await seed({
-      "0001_users.sql": "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT);",
-      "0002_posts.sql": "CREATE TABLE posts (id INTEGER PRIMARY KEY, title TEXT);"
-    });
-
-    const result = await runMigrations(adapter, { dir, now: () => "2026-01-01T00:00:00Z" });
-
-    expect(result.applied).toEqual(["0001_users.sql", "0002_posts.sql"]);
-    expect(result.skipped).toEqual([]);
-
-    const tracked = db.query("SELECT name, applied_at FROM __elm_ssr_migrations ORDER BY name").all();
-    expect(tracked).toEqual([
-      { name: "0001_users.sql", applied_at: "2026-01-01T00:00:00Z" },
-      { name: "0002_posts.sql", applied_at: "2026-01-01T00:00:00Z" }
-    ]);
-    // The migrations actually ran.
-    expect(db.query("SELECT name FROM sqlite_master WHERE type='table' AND name IN ('users','posts') ORDER BY name").all())
-      .toEqual([{ name: "posts" }, { name: "users" }]);
-  });
-
-  it("is idempotent: re-running skips already-applied migrations", async () => {
-    await seed({
-      "0001_init.sql": "CREATE TABLE t (id INTEGER);"
-    });
-
-    await runMigrations(adapter, { dir });
-    const second = await runMigrations(adapter, { dir });
-
-    expect(second.applied).toEqual([]);
-    expect(second.skipped).toEqual(["0001_init.sql"]);
-  });
-
-  it("only applies pending migrations on subsequent runs", async () => {
-    await seed({ "0001_init.sql": "CREATE TABLE t1 (id INTEGER);" });
-    await runMigrations(adapter, { dir });
-
-    await seed({ "0002_more.sql": "CREATE TABLE t2 (id INTEGER);" });
-    const result = await runMigrations(adapter, { dir });
-
-    expect(result.applied).toEqual(["0002_more.sql"]);
-    expect(result.skipped).toEqual(["0001_init.sql"]);
-  });
-
-  it("rolls back a failing migration without leaving partial schema or tracking", async () => {
-    await seed({
-      "0001_good.sql": "CREATE TABLE good (id INTEGER);",
-      "0002_broken.sql": "CREATE TABLE broken (id INTEGER); INSERT INTO broken (no_such_column) VALUES (1);"
-    });
-
-    await expect(runMigrations(adapter, { dir })).rejects.toThrow(/0002_broken\.sql/);
-
-    // First migration was applied (it's in its own transaction).
-    expect(db.query("SELECT name FROM __elm_ssr_migrations").all()).toEqual([
-      { name: "0001_good.sql" }
-    ]);
-    // The broken migration's CREATE TABLE was rolled back.
-    expect(db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='broken'").all()).toEqual([]);
-    // The good one stuck.
-    expect(db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='good'").all())
-      .toEqual([{ name: "good" }]);
-
-    // After fixing the broken file, re-running applies only what's missing.
-    await writeFile(resolve(dir, "0002_broken.sql"), "CREATE TABLE broken (id INTEGER);");
-    const retry = await runMigrations(adapter, { dir });
-    expect(retry.applied).toEqual(["0002_broken.sql"]);
-  });
-
-  it("ignores non-.sql files in the directory", async () => {
-    await seed({
-      "0001_real.sql": "CREATE TABLE r (id INTEGER);",
-      "README.md": "# Migrations",
-      "draft.txt": "not yet"
-    });
-
-    const result = await runMigrations(adapter, { dir });
-    expect(result.applied).toEqual(["0001_real.sql"]);
-  });
-
-  it("supports a custom tracking table name", async () => {
-    await seed({ "0001_init.sql": "CREATE TABLE t (id INTEGER);" });
-    await runMigrations(adapter, { dir, tableName: "schema_history" });
-
-    expect(db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='schema_history'").all())
-      .toEqual([{ name: "schema_history" }]);
-  });
-
-  it("rejects unsafe tracking table names", async () => {
-    await seed({ "0001_init.sql": "CREATE TABLE t (id INTEGER);" });
-    await expect(runMigrations(adapter, { dir, tableName: "bad name; DROP TABLE x" })).rejects.toThrow(/Invalid/);
-  });
-
-  it("escapes single quotes in filenames safely", async () => {
-    await seed({ "0001_o'clock.sql": "CREATE TABLE clk (id INTEGER);" });
-    const result = await runMigrations(adapter, { dir });
-    expect(result.applied).toEqual(["0001_o'clock.sql"]);
-    expect(db.query("SELECT name FROM __elm_ssr_migrations").all())
-      .toEqual([{ name: "0001_o'clock.sql" }]);
-  });
-
-  it("ignores `.down.sql` files on the up pass", async () => {
-    await seed({
-      "0001_init.sql": "CREATE TABLE t (id INTEGER);",
-      "0001_init.down.sql": "DROP TABLE t;"
-    });
-    const result = await runMigrations(adapter, { dir });
-    expect(result.applied).toEqual(["0001_init.sql"]);
-  });
-});
-
-describe("revertMigrations", () => {
-  it("reverts the most-recently-applied migration via its paired down file", async () => {
-    await seed({
-      "0001_users.sql": "CREATE TABLE users (id INTEGER);",
-      "0001_users.down.sql": "DROP TABLE users;",
-      "0002_posts.sql": "CREATE TABLE posts (id INTEGER);",
-      "0002_posts.down.sql": "DROP TABLE posts;"
-    });
-    await runMigrations(adapter, { dir });
-
-    const result = await revertMigrations(adapter, { dir });
-
-    expect(result.reverted).toEqual(["0002_posts.sql"]);
-    expect(db.query("SELECT name FROM __elm_ssr_migrations").all()).toEqual([{ name: "0001_users.sql" }]);
-    expect(db.query("SELECT name FROM sqlite_master WHERE type='table' AND name IN ('users','posts')").all())
-      .toEqual([{ name: "users" }]);
-  });
-
-  it("reverts multiple migrations when count > 1, most-recent first", async () => {
-    await seed({
-      "0001_users.sql": "CREATE TABLE users (id INTEGER);",
-      "0001_users.down.sql": "DROP TABLE users;",
-      "0002_posts.sql": "CREATE TABLE posts (id INTEGER);",
-      "0002_posts.down.sql": "DROP TABLE posts;"
-    });
-    await runMigrations(adapter, { dir });
-
-    const result = await revertMigrations(adapter, { dir, count: 2 });
-
-    expect(result.reverted).toEqual(["0002_posts.sql", "0001_users.sql"]);
-    expect(db.query("SELECT name FROM __elm_ssr_migrations").all()).toEqual([]);
-  });
-
-  it("errors clearly when a down migration is missing", async () => {
-    await seed({ "0001_init.sql": "CREATE TABLE t (id INTEGER);" });
-    await runMigrations(adapter, { dir });
-
-    await expect(revertMigrations(adapter, { dir })).rejects.toThrow(/No down migration/);
-  });
-
-  it("rolls back a failing revert without removing the tracking row", async () => {
-    await seed({
-      "0001_init.sql": "CREATE TABLE t (id INTEGER);",
-      "0001_init.down.sql": "DROP TABLE no_such_table;"
-    });
-    await runMigrations(adapter, { dir });
-
-    await expect(revertMigrations(adapter, { dir })).rejects.toThrow(/0001_init\.sql/);
-
-    // Tracking row is still there; original table still there.
-    expect(db.query("SELECT name FROM __elm_ssr_migrations").all()).toEqual([{ name: "0001_init.sql" }]);
-    expect(db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='t'").all())
-      .toEqual([{ name: "t" }]);
-  });
-
-  it("is a no-op when there's nothing applied", async () => {
-    const result = await revertMigrations(adapter, { dir });
-    expect(result.reverted).toEqual([]);
-  });
-});
-
-describe("listMigrations", () => {
-  it("reports applied entries (with timestamps) and pending filenames", async () => {
-    await seed({
-      "0001_users.sql": "CREATE TABLE users (id INTEGER);",
-      "0002_posts.sql": "CREATE TABLE posts (id INTEGER);",
-      "0003_comments.sql": "CREATE TABLE comments (id INTEGER);"
-    });
-    await runMigrations(adapter, { dir, now: () => "2026-05-30T00:00:00Z" });
-
-    // Now add a pending one without applying.
-    await seed({ "0004_likes.sql": "CREATE TABLE likes (id INTEGER);" });
-
-    const status = await listMigrations(adapter, { dir });
-
-    expect(status.applied).toEqual([
-      { name: "0001_users.sql", appliedAt: "2026-05-30T00:00:00Z" },
-      { name: "0002_posts.sql", appliedAt: "2026-05-30T00:00:00Z" },
-      { name: "0003_comments.sql", appliedAt: "2026-05-30T00:00:00Z" }
-    ]);
-    expect(status.pending).toEqual(["0004_likes.sql"]);
-  });
-
-  it("creates the tracking table on first call (returns empty applied + all pending)", async () => {
-    await seed({ "0001_init.sql": "CREATE TABLE t (id INTEGER);" });
-    const status = await listMigrations(adapter, { dir });
-    expect(status.applied).toEqual([]);
-    expect(status.pending).toEqual(["0001_init.sql"]);
-  });
-});