@jant/core 0.3.36 → 0.3.37

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

@@ -5,6 +5,9 @@ import {
   RedirectTypeSchema,
   CreatePostSchema,
   UpdatePostSchema,
+  SetupSchema,
+  SigninSchema,
+  normalizeEmail,
   parseFormData,
   parseFormDataOptional,
   validateMediaCount,
@@ -52,6 +55,46 @@ describe("RedirectTypeSchema", () => {
   });
 });
 
+describe("normalizeEmail", () => {
+  it("trims and lowercases email addresses", () => {
+    expect(normalizeEmail("  User.Name+tag@Example.COM ")).toBe(
+      "user.name+tag@example.com",
+    );
+  });
+});
+
+describe("SetupSchema", () => {
+  it("normalizes email before returning parsed data", () => {
+    const result = SetupSchema.parse({
+      siteName: "Jant",
+      email: "  Admin@Example.COM ",
+      password: "password123",
+    });
+
+    expect(result.email).toBe("admin@example.com");
+  });
+});
+
+describe("SigninSchema", () => {
+  it("normalizes email before returning parsed data", () => {
+    const result = SigninSchema.parse({
+      email: "  Admin@Example.COM ",
+      password: "password123",
+    });
+
+    expect(result.email).toBe("admin@example.com");
+  });
+
+  it("rejects invalid email after normalization", () => {
+    expect(() =>
+      SigninSchema.parse({
+        email: "  not-an-email  ",
+        password: "password123",
+      }),
+    ).toThrow();
+  });
+});
+
 describe("CreatePostSchema", () => {
   const validPost = {
     format: "note",
@@ -67,11 +110,23 @@ describe("CreatePostSchema", () => {
   });
 
   it("accepts all formats", () => {
-    for (const format of FORMATS) {
-      expect(() =>
-        CreatePostSchema.parse({ ...validPost, format }),
-      ).not.toThrow();
-    }
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, format: "note" }),
+    ).not.toThrow();
+    expect(() =>
+      CreatePostSchema.parse({
+        ...validPost,
+        format: "link",
+        url: "https://example.com",
+      }),
+    ).not.toThrow();
+    expect(() =>
+      CreatePostSchema.parse({
+        ...validPost,
+        format: "quote",
+        quoteText: "A wise person once said...",
+      }),
+    ).not.toThrow();
   });
 
   it("accepts optional title", () => {
@@ -82,88 +137,68 @@ describe("CreatePostSchema", () => {
     expect(result.title).toBe("My Post");
   });
 
-  it("accepts valid path format", () => {
+  it("accepts valid slug format", () => {
     const result = CreatePostSchema.parse({
       ...validPost,
-      path: "my-post-path",
+      slug: "my-post-slug",
     });
-    expect(result.path).toBe("my-post-path");
+    expect(result.slug).toBe("my-post-slug");
   });
 
-  it("accepts single-character path", () => {
+  it("accepts single-character slug", () => {
     const result = CreatePostSchema.parse({
       ...validPost,
-      path: "a",
+      slug: "a",
     });
-    expect(result.path).toBe("a");
+    expect(result.slug).toBe("a");
+  });
+
+  it("accepts empty slug (transforms to undefined)", () => {
+    const result = CreatePostSchema.parse({ ...validPost, slug: "" });
+    expect(result.slug).toBeUndefined();
   });
 
-  it("accepts empty path (transforms to undefined)", () => {
-    const result = CreatePostSchema.parse({ ...validPost, path: "" });
-    expect(result.path).toBeUndefined();
+  it("normalizes uppercase slug", () => {
+    const result = CreatePostSchema.parse({ ...validPost, slug: "MyPost" });
+    expect(result.slug).toBe("mypost");
   });
 
-  it("accepts multi-level path", () => {
+  it("normalizes special chars in slug", () => {
     const result = CreatePostSchema.parse({
       ...validPost,
-      path: "2024/my-post",
+      slug: "my post!",
     });
-    expect(result.path).toBe("2024/my-post");
+    expect(result.slug).toBe("my-post");
   });
 
-  it("accepts deeply nested path", () => {
+  it("normalizes leading hyphen in slug", () => {
     const result = CreatePostSchema.parse({
       ...validPost,
-      path: "2024/01/my-post",
+      slug: "-my-post",
     });
-    expect(result.path).toBe("2024/01/my-post");
-  });
-
-  it("rejects invalid path format (uppercase)", () => {
-    expect(() =>
-      CreatePostSchema.parse({ ...validPost, path: "MyPost" }),
-    ).toThrow();
-  });
-
-  it("rejects invalid path format (special chars)", () => {
-    expect(() =>
-      CreatePostSchema.parse({ ...validPost, path: "my post!" }),
-    ).toThrow();
+    expect(result.slug).toBe("my-post");
   });
 
-  it("rejects path starting with hyphen", () => {
-    expect(() =>
-      CreatePostSchema.parse({ ...validPost, path: "-my-post" }),
-    ).toThrow();
-  });
-
-  it("rejects path ending with hyphen", () => {
-    expect(() =>
-      CreatePostSchema.parse({ ...validPost, path: "my-post-" }),
-    ).toThrow();
-  });
-
-  it("rejects path with leading slash", () => {
-    expect(() =>
-      CreatePostSchema.parse({ ...validPost, path: "/my-post" }),
-    ).toThrow();
-  });
-
-  it("rejects path with trailing slash", () => {
-    expect(() =>
-      CreatePostSchema.parse({ ...validPost, path: "my-post/" }),
-    ).toThrow();
+  it("normalizes trailing hyphen in slug", () => {
+    const result = CreatePostSchema.parse({
+      ...validPost,
+      slug: "my-post-",
+    });
+    expect(result.slug).toBe("my-post");
   });
 
-  it("rejects path with consecutive slashes", () => {
-    expect(() =>
-      CreatePostSchema.parse({ ...validPost, path: "2024//my-post" }),
-    ).toThrow();
+  it("normalizes slashes in slug", () => {
+    const result = CreatePostSchema.parse({
+      ...validPost,
+      slug: "my/post",
+    });
+    expect(result.slug).toBe("my-post");
   });
 
   it("accepts valid url", () => {
     const result = CreatePostSchema.parse({
       ...validPost,
+      format: "link",
       url: "https://example.com",
     });
     expect(result.url).toBe("https://example.com");
@@ -232,12 +267,23 @@ describe("CreatePostSchema", () => {
   });
 
   it("accepts visibility values", () => {
-    for (const v of ["listed", "featured", "unlisted"]) {
+    for (const v of ["public", "unlisted", "private"]) {
       const result = CreatePostSchema.parse({ ...validPost, visibility: v });
       expect(result.visibility).toBe(v);
     }
   });
 
+  it("accepts featured as boolean", () => {
+    const result = CreatePostSchema.parse({ ...validPost, featured: true });
+    expect(result.featured).toBe(true);
+  });
+
+  it("rejects featured as non-boolean (other than 'on')", () => {
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, featured: "invalid" }),
+    ).toThrow();
+  });
+
   it("rejects invalid visibility", () => {
     expect(() =>
       CreatePostSchema.parse({ ...validPost, visibility: "hidden" }),
@@ -254,14 +300,62 @@ describe("CreatePostSchema", () => {
     expect(result.pinned).toBe(true);
   });
 
-  it("accepts optional quoteText", () => {
+  it("accepts optional quoteText for quote posts", () => {
     const result = CreatePostSchema.parse({
       ...validPost,
+      format: "quote",
       quoteText: "A wise person once said...",
     });
     expect(result.quoteText).toBe("A wise person once said...");
   });
 
+  it("rejects note posts with a URL", () => {
+    expect(() =>
+      CreatePostSchema.parse({
+        ...validPost,
+        url: "https://example.com",
+      }),
+    ).toThrow("Notes can't include a URL.");
+  });
+
+  it("rejects note posts with quoted text", () => {
+    expect(() =>
+      CreatePostSchema.parse({
+        ...validPost,
+        quoteText: "A wise person once said...",
+      }),
+    ).toThrow("Notes can't include quoted text.");
+  });
+
+  it("rejects link posts without a URL", () => {
+    expect(() =>
+      CreatePostSchema.parse({
+        ...validPost,
+        format: "link",
+      }),
+    ).toThrow("Link posts need a URL.");
+  });
+
+  it("rejects link posts with quoted text", () => {
+    expect(() =>
+      CreatePostSchema.parse({
+        ...validPost,
+        format: "link",
+        url: "https://example.com",
+        quoteText: "A wise person once said...",
+      }),
+    ).toThrow("Link posts can't include quoted text.");
+  });
+
+  it("rejects quote posts without quoted text", () => {
+    expect(() =>
+      CreatePostSchema.parse({
+        ...validPost,
+        format: "quote",
+      }),
+    ).toThrow("Quote posts need quoted text.");
+  });
+
   it("accepts optional rating (1-5)", () => {
     for (const rating of [1, 2, 3, 4, 5]) {
       const result = CreatePostSchema.parse({ ...validPost, rating });
@@ -286,12 +380,18 @@ describe("CreatePostSchema", () => {
     expect(result.rating).toBeUndefined();
   });
 
-  it("accepts optional collectionIds as array of positive integers", () => {
+  it("accepts optional collectionIds as array of non-empty strings", () => {
     const result = CreatePostSchema.parse({
       ...validPost,
-      collectionIds: [1, 2, 3],
+      collectionIds: ["col-1", "col-2", "col-3"],
     });
-    expect(result.collectionIds).toEqual([1, 2, 3]);
+    expect(result.collectionIds).toEqual(["col-1", "col-2", "col-3"]);
+  });
+
+  it("rejects collectionIds with empty strings", () => {
+    expect(() =>
+      CreatePostSchema.parse({ ...validPost, collectionIds: [""] }),
+    ).toThrow();
   });
 
   it("accepts empty string collectionIds (transforms to undefined)", () => {
@@ -319,6 +419,24 @@ describe("CreatePostSchema", () => {
     expect(() => CreatePostSchema.parse({})).toThrow();
     expect(() => CreatePostSchema.parse({ body: "hello" })).toThrow();
   });
+
+  it("accepts bodyMarkdown", () => {
+    const result = CreatePostSchema.parse({
+      format: "note",
+      bodyMarkdown: "Hello **world**",
+    });
+    expect(result.bodyMarkdown).toBe("Hello **world**");
+  });
+
+  it("rejects both body and bodyMarkdown", () => {
+    expect(() =>
+      CreatePostSchema.parse({
+        format: "note",
+        body: '{"type":"doc","content":[]}',
+        bodyMarkdown: "Hello",
+      }),
+    ).toThrow("Provide either body or bodyMarkdown, not both");
+  });
 });
 
 describe("UpdatePostSchema", () => {

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

@@ -0,0 +1,126 @@
+import { describe, it, expect } from "vitest";
+import { generatePostSlug } from "../slug.js";
+
+/** Helper: always-available check */
+const alwaysAvailable = async () => true;
+
+/** Helper: never-available check */
+const neverAvailable = async () => false;
+
+/** Helper: available after N calls */
+function availableAfter(n: number) {
+  let calls = 0;
+  return async () => {
+    calls++;
+    return calls > n;
+  };
+}
+
+describe("generatePostSlug", () => {
+  describe("user-provided slug", () => {
+    it("returns user slug when available", async () => {
+      const slug = await generatePostSlug({
+        slug: "my-post",
+        idLength: 5,
+        isAvailable: alwaysAvailable,
+      });
+      expect(slug).toBe("my-post");
+    });
+
+    it("throws ConflictError when slug is taken", async () => {
+      await expect(
+        generatePostSlug({
+          slug: "taken-slug",
+          idLength: 5,
+          isAvailable: neverAvailable,
+        }),
+      ).rejects.toThrow("already in use");
+    });
+
+    it("throws ValidationError for reserved slug", async () => {
+      await expect(
+        generatePostSlug({
+          slug: "dash",
+          idLength: 5,
+          isAvailable: alwaysAvailable,
+        }),
+      ).rejects.toThrow("reserved");
+    });
+
+    it("prioritizes user slug over title", async () => {
+      const slug = await generatePostSlug({
+        slug: "custom-slug",
+        title: "My Title",
+        idLength: 5,
+        isAvailable: alwaysAvailable,
+      });
+      expect(slug).toBe("custom-slug");
+    });
+  });
+
+  describe("title-based slug", () => {
+    it("generates slug from title", async () => {
+      const slug = await generatePostSlug({
+        title: "Hello World",
+        idLength: 5,
+        isAvailable: alwaysAvailable,
+      });
+      expect(slug).toBe("hello-world");
+    });
+
+    it("appends random suffix on conflict", async () => {
+      const slug = await generatePostSlug({
+        title: "Hello World",
+        idLength: 5,
+        isAvailable: availableAfter(1), // first call (base) fails, second succeeds
+      });
+      expect(slug).toMatch(/^hello-world-[a-z0-9]{5}$/);
+    });
+
+    it("retries with different random suffixes", async () => {
+      const slug = await generatePostSlug({
+        title: "Test Post",
+        idLength: 5,
+        isAvailable: availableAfter(3),
+      });
+      expect(slug).toMatch(/^test-post-[a-z0-9]{5}$/);
+    });
+
+    it("throws after exceeding max retries", async () => {
+      await expect(
+        generatePostSlug({
+          title: "Test Post",
+          idLength: 5,
+          isAvailable: neverAvailable,
+        }),
+      ).rejects.toThrow("Could not generate a unique slug");
+    });
+  });
+
+  describe("random slug (no title, no slug)", () => {
+    it("generates random ID of specified length", async () => {
+      const slug = await generatePostSlug({
+        idLength: 5,
+        isAvailable: alwaysAvailable,
+      });
+      expect(slug).toMatch(/^[a-z0-9]{5}$/);
+    });
+
+    it("retries on conflict", async () => {
+      const slug = await generatePostSlug({
+        idLength: 8,
+        isAvailable: availableAfter(2),
+      });
+      expect(slug).toMatch(/^[a-z0-9]{8}$/);
+    });
+
+    it("throws after exceeding max retries", async () => {
+      await expect(
+        generatePostSlug({
+          idLength: 5,
+          isAvailable: neverAvailable,
+        }),
+      ).rejects.toThrow("Could not generate a unique slug");
+    });
+  });
+});

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

@@ -3,20 +3,20 @@ import { dsRedirect, dsToast, dsSignals } from "../sse.js";
 
 describe("dsRedirect", () => {
   it("returns a Response with text/html content-type", () => {
-    const res = dsRedirect("/dash");
+    const res = dsRedirect("/settings");
     expect(res.headers.get("Content-Type")).toBe("text/html");
   });
 
   it("includes Datastar headers for append mode", () => {
-    const res = dsRedirect("/dash");
+    const res = dsRedirect("/settings");
     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 res = dsRedirect("/settings/general");
     const body = await res.text();
-    expect(body).toContain("window.location.href='/dash/posts'");
+    expect(body).toContain("window.location.href='/settings/general'");
   });
 
   it("escapes single quotes in URL", async () => {
@@ -26,7 +26,7 @@ describe("dsRedirect", () => {
   });
 
   it("merges additional headers from plain object", () => {
-    const res = dsRedirect("/dash", {
+    const res = dsRedirect("/settings", {
       headers: { "Set-Cookie": "session=abc" },
     });
     expect(res.headers.get("Set-Cookie")).toBe("session=abc");
@@ -37,7 +37,7 @@ describe("dsRedirect", () => {
     const headers = new Headers();
     headers.append("set-cookie", "session=abc; Path=/; HttpOnly");
     headers.append("set-cookie", "data=xyz; Path=/; Max-Age=300");
-    const res = dsRedirect("/dash", { headers });
+    const res = dsRedirect("/settings", { headers });
     const cookies = res.headers.getSetCookie();
     expect(cookies).toHaveLength(2);
     expect(cookies[0]).toBe("session=abc; Path=/; HttpOnly");