@jant/core 0.3.2 → 0.3.4

package/src/lib/__tests__/sse.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect } from "vitest";
+import { dsRedirect, dsToast, dsSignals } from "../sse.js";
+
+describe("dsRedirect", () => {
+  it("returns a Response with text/html content-type", () => {
+    const res = dsRedirect("/dash");
+    expect(res.headers.get("Content-Type")).toBe("text/html");
+  });
+
+  it("includes Datastar headers for append mode", () => {
+    const res = dsRedirect("/dash");
+    expect(res.headers.get("Datastar-Mode")).toBe("append");
+    expect(res.headers.get("Datastar-Selector")).toBe("body");
+  });
+
+  it("body contains redirect script with correct URL", async () => {
+    const res = dsRedirect("/dash/posts");
+    const body = await res.text();
+    expect(body).toContain("window.location.href='/dash/posts'");
+  });
+
+  it("escapes single quotes in URL", async () => {
+    const res = dsRedirect("/path/with'quote");
+    const body = await res.text();
+    expect(body).toContain("\\'");
+  });
+
+  it("merges additional headers", () => {
+    const res = dsRedirect("/dash", {
+      headers: { "Set-Cookie": "session=abc" },
+    });
+    expect(res.headers.get("Set-Cookie")).toBe("session=abc");
+    expect(res.headers.get("Content-Type")).toBe("text/html");
+  });
+});
+
+describe("dsToast", () => {
+  it("returns text/html content-type", () => {
+    const res = dsToast("Saved!");
+    expect(res.headers.get("Content-Type")).toBe("text/html");
+  });
+
+  it("targets #toast-container", () => {
+    const res = dsToast("Saved!");
+    expect(res.headers.get("Datastar-Selector")).toBe("#toast-container");
+    expect(res.headers.get("Datastar-Mode")).toBe("append");
+  });
+
+  it("defaults to success type", async () => {
+    const res = dsToast("Saved!");
+    const body = await res.text();
+    expect(body).toContain("toast-success");
+  });
+
+  it("supports error type", async () => {
+    const res = dsToast("Failed!", "error");
+    const body = await res.text();
+    expect(body).toContain("toast-error");
+  });
+
+  it("escapes HTML in message", async () => {
+    const res = dsToast("<script>alert('xss')</script>");
+    const body = await res.text();
+    expect(body).not.toContain("<script>alert");
+    expect(body).toContain("&lt;script&gt;");
+  });
+});
+
+describe("dsSignals", () => {
+  it("returns application/json content-type", () => {
+    const res = dsSignals({ count: 1 });
+    expect(res.headers.get("Content-Type")).toBe("application/json");
+  });
+
+  it("body contains JSON-serialized signals", async () => {
+    const res = dsSignals({ _error: "File too large", count: 42 });
+    const body = await res.json();
+    expect(body).toEqual({ _error: "File too large", count: 42 });
+  });
+
+  it("handles empty signals", async () => {
+    const res = dsSignals({});
+    const body = await res.json();
+    expect(body).toEqual({});
+  });
+});

package/src/lib/__tests__/time.test.ts

@@ -0,0 +1,112 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import {
+  now,
+  isWithinMonth,
+  toISOString,
+  formatDate,
+  formatYearMonth,
+} from "../time.js";
+
+describe("now", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns current time in seconds", () => {
+    const before = Math.floor(Date.now() / 1000);
+    const result = now();
+    const after = Math.floor(Date.now() / 1000);
+    expect(result).toBeGreaterThanOrEqual(before);
+    expect(result).toBeLessThanOrEqual(after);
+  });
+
+  it("returns an integer (not milliseconds)", () => {
+    const result = now();
+    expect(Number.isInteger(result)).toBe(true);
+    // Should be in seconds, not milliseconds (less than 10 billion)
+    expect(result).toBeLessThan(10_000_000_000);
+  });
+});
+
+describe("isWithinMonth", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns true for a timestamp within the last 30 days", () => {
+    const recent = now() - 60 * 60; // 1 hour ago
+    expect(isWithinMonth(recent)).toBe(true);
+  });
+
+  it("returns true for current timestamp", () => {
+    expect(isWithinMonth(now())).toBe(true);
+  });
+
+  it("returns false for a timestamp older than 30 days", () => {
+    const old = now() - 31 * 24 * 60 * 60; // 31 days ago
+    expect(isWithinMonth(old)).toBe(false);
+  });
+
+  it("returns false for timestamp exactly at 30-day boundary", () => {
+    // 30 days = 2592000 seconds
+    const boundary = now() - 30 * 24 * 60 * 60;
+    expect(isWithinMonth(boundary)).toBe(false);
+  });
+
+  it("returns true for timestamp just under 30 days", () => {
+    const justUnder = now() - (30 * 24 * 60 * 60 - 1);
+    expect(isWithinMonth(justUnder)).toBe(true);
+  });
+});
+
+describe("toISOString", () => {
+  it("converts Unix timestamp to ISO string", () => {
+    // Feb 1, 2024 00:00:00 UTC
+    expect(toISOString(1706745600)).toBe("2024-02-01T00:00:00.000Z");
+  });
+
+  it("converts epoch 0", () => {
+    expect(toISOString(0)).toBe("1970-01-01T00:00:00.000Z");
+  });
+
+  it("handles timestamps with time components", () => {
+    // 2024-01-15T12:30:00Z = 1705321800
+    expect(toISOString(1705321800)).toBe("2024-01-15T12:30:00.000Z");
+  });
+});
+
+describe("formatDate", () => {
+  it("formats as MMM DD, YYYY", () => {
+    expect(formatDate(1706745600)).toBe("Feb 1, 2024");
+  });
+
+  it("formats epoch start", () => {
+    expect(formatDate(0)).toBe("Jan 1, 1970");
+  });
+
+  it("uses UTC timezone consistently", () => {
+    // Dec 31, 2023 23:59:59 UTC
+    const timestamp = 1704067199;
+    expect(formatDate(timestamp)).toBe("Dec 31, 2023");
+  });
+});
+
+describe("formatYearMonth", () => {
+  it("formats as YYYY-MM", () => {
+    expect(formatYearMonth(1706745600)).toBe("2024-02");
+  });
+
+  it("zero-pads single-digit months", () => {
+    // Jan 15, 2024
+    expect(formatYearMonth(1705276800)).toBe("2024-01");
+  });
+
+  it("handles December correctly", () => {
+    // Dec 15, 2023
+    expect(formatYearMonth(1702598400)).toBe("2023-12");
+  });
+
+  it("formats epoch start", () => {
+    expect(formatYearMonth(0)).toBe("1970-01");
+  });
+});

package/src/lib/__tests__/url.test.ts

@@ -0,0 +1,138 @@
+import { describe, it, expect } from "vitest";
+import { extractDomain, normalizePath, isFullUrl, slugify } from "../url.js";
+
+describe("extractDomain", () => {
+  it("extracts hostname from HTTPS URL", () => {
+    expect(extractDomain("https://example.com/path")).toBe("example.com");
+  });
+
+  it("extracts hostname from HTTP URL", () => {
+    expect(extractDomain("http://example.com")).toBe("example.com");
+  });
+
+  it("includes www subdomain", () => {
+    expect(extractDomain("https://www.example.com/path")).toBe(
+      "www.example.com",
+    );
+  });
+
+  it("handles URLs with ports", () => {
+    expect(extractDomain("http://localhost:3000/api")).toBe("localhost");
+  });
+
+  it("handles URLs with query params and hash", () => {
+    expect(extractDomain("https://example.com/path?q=1#section")).toBe(
+      "example.com",
+    );
+  });
+
+  it("returns null for invalid URLs", () => {
+    expect(extractDomain("not-a-url")).toBe(null);
+    expect(extractDomain("")).toBe(null);
+  });
+
+  it("handles complex subdomains", () => {
+    expect(extractDomain("https://blog.sub.example.com")).toBe(
+      "blog.sub.example.com",
+    );
+  });
+});
+
+describe("normalizePath", () => {
+  it("converts to lowercase", () => {
+    expect(normalizePath("About")).toBe("about");
+    expect(normalizePath("HELLO")).toBe("hello");
+  });
+
+  it("removes leading and trailing slashes", () => {
+    expect(normalizePath("/about/")).toBe("about");
+    expect(normalizePath("///about///")).toBe("about");
+  });
+
+  it("collapses multiple slashes", () => {
+    expect(normalizePath("about//contact")).toBe("about/contact");
+    expect(normalizePath("a///b////c")).toBe("a/b/c");
+  });
+
+  it("trims whitespace", () => {
+    expect(normalizePath("  about  ")).toBe("about");
+  });
+
+  it("handles combined transformations", () => {
+    expect(normalizePath("  /About/Contact//  ")).toBe("about/contact");
+  });
+
+  it("returns empty string for root path", () => {
+    expect(normalizePath("/")).toBe("");
+    expect(normalizePath("///")).toBe("");
+  });
+
+  it("handles empty input", () => {
+    expect(normalizePath("")).toBe("");
+    expect(normalizePath("  ")).toBe("");
+  });
+});
+
+describe("isFullUrl", () => {
+  it("returns true for https URLs", () => {
+    expect(isFullUrl("https://example.com")).toBe(true);
+  });
+
+  it("returns true for http URLs", () => {
+    expect(isFullUrl("http://example.com")).toBe(true);
+  });
+
+  it("returns false for relative paths", () => {
+    expect(isFullUrl("/about")).toBe(false);
+    expect(isFullUrl("about")).toBe(false);
+  });
+
+  it("returns false for domain-only strings", () => {
+    expect(isFullUrl("example.com")).toBe(false);
+  });
+
+  it("returns false for empty string", () => {
+    expect(isFullUrl("")).toBe(false);
+  });
+
+  it("returns false for other protocols", () => {
+    expect(isFullUrl("ftp://example.com")).toBe(false);
+    expect(isFullUrl("mailto:test@test.com")).toBe(false);
+  });
+});
+
+describe("slugify", () => {
+  it("converts text to lowercase hyphenated slug", () => {
+    expect(slugify("Hello World")).toBe("hello-world");
+  });
+
+  it("removes special characters", () => {
+    expect(slugify("Hello World! This is a Test.")).toBe(
+      "hello-world-this-is-a-test",
+    );
+  });
+
+  it("collapses multiple spaces", () => {
+    expect(slugify("Multiple   Spaces")).toBe("multiple-spaces");
+  });
+
+  it("trims leading/trailing whitespace and hyphens", () => {
+    expect(slugify("  Multiple   Spaces  ")).toBe("multiple-spaces");
+  });
+
+  it("replaces underscores with hyphens", () => {
+    expect(slugify("hello_world")).toBe("hello-world");
+  });
+
+  it("handles already-slugified text", () => {
+    expect(slugify("already-a-slug")).toBe("already-a-slug");
+  });
+
+  it("handles empty string", () => {
+    expect(slugify("")).toBe("");
+  });
+
+  it("removes non-word characters", () => {
+    expect(slugify("café & résumé")).toBe("caf-rsum");
+  });
+});

package/src/middleware/__tests__/auth.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect } from "vitest";
+import { Hono } from "hono";
+import { requireAuth, requireAuthApi } from "../auth.js";
+import type { Bindings } from "../../types.js";
+import type { AppVariables } from "../../app.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+function createMockAuth(authenticated: boolean) {
+  return {
+    api: {
+      getSession: async () =>
+        authenticated
+          ? {
+              user: { id: "user-1", email: "test@test.com", name: "Test" },
+              session: { id: "session-1" },
+            }
+          : null,
+    },
+  } as AppVariables["auth"];
+}
+
+describe("requireAuth", () => {
+  it("allows authenticated requests", async () => {
+    const app = new Hono<Env>();
+    app.use("*", async (c, next) => {
+      c.set("auth", createMockAuth(true));
+      await next();
+    });
+    app.get("/dash", requireAuth(), (c) => c.text("Dashboard"));
+
+    const res = await app.request("/dash");
+    expect(res.status).toBe(200);
+    expect(await res.text()).toBe("Dashboard");
+  });
+
+  it("redirects unauthenticated requests to /signin", async () => {
+    const app = new Hono<Env>();
+    app.use("*", async (c, next) => {
+      c.set("auth", createMockAuth(false));
+      await next();
+    });
+    app.get("/dash", requireAuth(), (c) => c.text("Dashboard"));
+
+    const res = await app.request("/dash", { redirect: "manual" });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe("/signin");
+  });
+
+  it("redirects to custom path", async () => {
+    const app = new Hono<Env>();
+    app.use("*", async (c, next) => {
+      c.set("auth", createMockAuth(false));
+      await next();
+    });
+    app.get("/dash", requireAuth("/login"), (c) => c.text("Dashboard"));
+
+    const res = await app.request("/dash", { redirect: "manual" });
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe("/login");
+  });
+
+  it("redirects when auth is not configured", async () => {
+    const app = new Hono<Env>();
+    app.use("*", async (c, next) => {
+      // auth not set (undefined)
+      await next();
+    });
+    app.get("/dash", requireAuth(), (c) => c.text("Dashboard"));
+
+    const res = await app.request("/dash", { redirect: "manual" });
+    expect(res.status).toBe(302);
+  });
+});
+
+describe("requireAuthApi", () => {
+  it("allows authenticated requests", async () => {
+    const app = new Hono<Env>();
+    app.use("*", async (c, next) => {
+      c.set("auth", createMockAuth(true));
+      await next();
+    });
+    app.get("/api/data", requireAuthApi(), (c) => c.json({ data: "secret" }));
+
+    const res = await app.request("/api/data");
+    expect(res.status).toBe(200);
+
+    const body = await res.json();
+    expect(body.data).toBe("secret");
+  });
+
+  it("returns 401 for unauthenticated requests", async () => {
+    const app = new Hono<Env>();
+    app.use("*", async (c, next) => {
+      c.set("auth", createMockAuth(false));
+      await next();
+    });
+    app.get("/api/data", requireAuthApi(), (c) => c.json({ data: "secret" }));
+
+    const res = await app.request("/api/data");
+    expect(res.status).toBe(401);
+
+    const body = await res.json();
+    expect(body.error).toBe("Unauthorized");
+  });
+
+  it("returns 500 when auth is not configured", async () => {
+    const app = new Hono<Env>();
+    app.use("*", async (c, next) => {
+      // auth not set (undefined)
+      await next();
+    });
+    app.get("/api/data", requireAuthApi(), (c) => c.json({ data: "secret" }));
+
+    const res = await app.request("/api/data");
+    expect(res.status).toBe(500);
+
+    const body = await res.json();
+    expect(body.error).toBe("Authentication not configured");
+  });
+
+  it("returns 401 when getSession throws", async () => {
+    const app = new Hono<Env>();
+    app.use("*", async (c, next) => {
+      c.set("auth", {
+        api: {
+          getSession: async () => {
+            throw new Error("Session error");
+          },
+        },
+      } as AppVariables["auth"]);
+      await next();
+    });
+    app.get("/api/data", requireAuthApi(), (c) => c.json({ data: "secret" }));
+
+    const res = await app.request("/api/data");
+    expect(res.status).toBe(401);
+  });
+});