Profile page UI and functionality implemented

tests/unit/createFlowValidation.test.ts

@@ -79,6 +79,13 @@ describe("createFlowStateSchema", () => {
     expect(r.success).toBe(false);
   });
 
+  it("rejects communityContext longer than 200 chars", () => {
+    const r = createFlowStateSchema.safeParse({
+      communityContext: "x".repeat(201),
+    });
+    expect(r.success).toBe(false);
+  });
+
   it("accepts communityStructureChipSnapshots with custom chip rows", () => {
     const r = createFlowStateSchema.safeParse({
       communityStructureChipSnapshots: {

tests/unit/rulesByIdDeleteRoute.test.ts

@@ -0,0 +1,94 @@
+import { NextRequest } from "next/server";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const isDatabaseConfiguredMock = vi.fn();
+const findUniqueMock = vi.fn();
+const deleteMock = vi.fn();
+const getSessionUserMock = vi.fn();
+
+vi.mock("../../lib/server/env", () => ({
+  isDatabaseConfigured: () => isDatabaseConfiguredMock(),
+}));
+
+vi.mock("../../lib/server/db", () => ({
+  prisma: {
+    publishedRule: {
+      findUnique: (...args: unknown[]) => findUniqueMock(...args),
+      delete: (...args: unknown[]) => deleteMock(...args),
+    },
+  },
+}));
+
+vi.mock("../../lib/server/session", () => ({
+  getSessionUser: () => getSessionUserMock(),
+}));
+
+import { DELETE } from "../../app/api/rules/[id]/route";
+
+function makeContext(id: string) {
+  return { params: Promise.resolve({ id }) };
+}
+
+beforeEach(() => {
+  isDatabaseConfiguredMock.mockReset();
+  findUniqueMock.mockReset();
+  deleteMock.mockReset();
+  getSessionUserMock.mockReset();
+});
+
+describe("DELETE /api/rules/[id]", () => {
+  it("returns 401 when not signed in", async () => {
+    isDatabaseConfiguredMock.mockReturnValue(true);
+    getSessionUserMock.mockResolvedValue(null);
+    const res = await DELETE(
+      new NextRequest("https://x.test/api/rules/r1"),
+      makeContext("r1"),
+    );
+    expect(res.status).toBe(401);
+    expect(findUniqueMock).not.toHaveBeenCalled();
+  });
+
+  it("returns 404 when the rule does not exist", async () => {
+    isDatabaseConfiguredMock.mockReturnValue(true);
+    getSessionUserMock.mockResolvedValue({ id: "u1", email: "a@b.c" });
+    findUniqueMock.mockResolvedValueOnce(null);
+    const res = await DELETE(
+      new NextRequest("https://x.test/api/rules/missing"),
+      makeContext("missing"),
+    );
+    expect(res.status).toBe(404);
+  });
+
+  it("returns 403 when the rule is owned by another user", async () => {
+    isDatabaseConfiguredMock.mockReturnValue(true);
+    getSessionUserMock.mockResolvedValue({ id: "u1", email: "a@b.c" });
+    findUniqueMock.mockResolvedValueOnce({
+      id: "r1",
+      userId: "other",
+    });
+    const res = await DELETE(
+      new NextRequest("https://x.test/api/rules/r1"),
+      makeContext("r1"),
+    );
+    expect(res.status).toBe(403);
+    expect(deleteMock).not.toHaveBeenCalled();
+  });
+
+  it("deletes and returns 200 when the user owns the rule", async () => {
+    isDatabaseConfiguredMock.mockReturnValue(true);
+    getSessionUserMock.mockResolvedValue({ id: "u1", email: "a@b.c" });
+    findUniqueMock.mockResolvedValueOnce({
+      id: "r1",
+      userId: "u1",
+    });
+    deleteMock.mockResolvedValueOnce(undefined);
+    const res = await DELETE(
+      new NextRequest("https://x.test/api/rules/r1"),
+      makeContext("r1"),
+    );
+    expect(res.status).toBe(200);
+    expect(deleteMock).toHaveBeenCalledWith({ where: { id: "r1" } });
+    const body = (await res.json()) as { ok: boolean };
+    expect(body.ok).toBe(true);
+  });
+});

tests/unit/rulesByIdRoute.test.ts

@@ -3,6 +3,7 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
 
 const isDatabaseConfiguredMock = vi.fn();
 const findUniqueMock = vi.fn();
+const getSessionUserMock = vi.fn();
 
 vi.mock("../../lib/server/env", () => ({
   isDatabaseConfigured: () => isDatabaseConfiguredMock(),
@@ -16,6 +17,10 @@ vi.mock("../../lib/server/db", () => ({
   },
 }));
 
+vi.mock("../../lib/server/session", () => ({
+  getSessionUser: () => getSessionUserMock(),
+}));
+
 import { GET } from "../../app/api/rules/[id]/route";
 
 function makeContext(id: string) {
@@ -25,6 +30,8 @@ function makeContext(id: string) {
 beforeEach(() => {
   isDatabaseConfiguredMock.mockReset();
   findUniqueMock.mockReset();
+  getSessionUserMock.mockReset();
+  getSessionUserMock.mockResolvedValue(null);
 });
 
 describe("GET /api/rules/[id]", () => {
@@ -79,7 +86,7 @@ describe("GET /api/rules/[id]", () => {
     expect(res.status).toBe(404);
   });
 
-  it("returns 200 with { rule } when a published rule exists", async () => {
+  it("returns 200 with { rule, viewerIsOwner: false } when a published rule exists and the viewer is anonymous", async () => {
     isDatabaseConfiguredMock.mockReturnValue(true);
     const row = {
       id: "rule-1",
@@ -97,9 +104,59 @@ describe("GET /api/rules/[id]", () => {
     expect(res.status).toBe(200);
     const body = (await res.json()) as {
       rule: { id: string; title: string; summary: string | null };
+      viewerIsOwner: boolean;
     };
     expect(body.rule.id).toBe("rule-1");
     expect(body.rule.title).toBe("Mutual Aid Mondays");
     expect(body.rule.summary).toBe("A grassroots community in Denver.");
+    expect(body.viewerIsOwner).toBe(false);
+    expect(findUniqueMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("returns viewerIsOwner true when the signed-in user owns the rule", async () => {
+    isDatabaseConfiguredMock.mockReturnValue(true);
+    getSessionUserMock.mockResolvedValue({ id: "user-1", email: "a@b.c" });
+    const row = {
+      id: "rule-1",
+      title: "Mutual Aid Mondays",
+      summary: "A grassroots community in Denver.",
+      document: { sections: [] },
+      createdAt: new Date("2026-01-01T00:00:00Z"),
+      updatedAt: new Date("2026-01-02T00:00:00Z"),
+    };
+    findUniqueMock
+      .mockResolvedValueOnce(row)
+      .mockResolvedValueOnce({ userId: "user-1" });
+    const res = await GET(
+      new NextRequest("https://x.test/api/rules/rule-1"),
+      makeContext("rule-1"),
+    );
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { viewerIsOwner: boolean };
+    expect(body.viewerIsOwner).toBe(true);
+    expect(findUniqueMock).toHaveBeenCalledTimes(2);
+  });
+
+  it("returns viewerIsOwner false when the signed-in user does not own the rule", async () => {
+    isDatabaseConfiguredMock.mockReturnValue(true);
+    getSessionUserMock.mockResolvedValue({ id: "user-1", email: "a@b.c" });
+    const row = {
+      id: "rule-1",
+      title: "Mutual Aid Mondays",
+      summary: "A grassroots community in Denver.",
+      document: { sections: [] },
+      createdAt: new Date("2026-01-01T00:00:00Z"),
+      updatedAt: new Date("2026-01-02T00:00:00Z"),
+    };
+    findUniqueMock
+      .mockResolvedValueOnce(row)
+      .mockResolvedValueOnce({ userId: "other" });
+    const res = await GET(
+      new NextRequest("https://x.test/api/rules/rule-1"),
+      makeContext("rule-1"),
+    );
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { viewerIsOwner: boolean };
+    expect(body.viewerIsOwner).toBe(false);
   });
 });

tests/unit/rulesDuplicateRoute.test.ts

@@ -0,0 +1,105 @@
+import { NextRequest } from "next/server";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const isDatabaseConfiguredMock = vi.fn();
+const findUniqueMock = vi.fn();
+const createMock = vi.fn();
+const getSessionUserMock = vi.fn();
+
+vi.mock("../../lib/server/env", () => ({
+  isDatabaseConfigured: () => isDatabaseConfiguredMock(),
+}));
+
+vi.mock("../../lib/server/db", () => ({
+  prisma: {
+    publishedRule: {
+      findUnique: (...args: unknown[]) => findUniqueMock(...args),
+      create: (...args: unknown[]) => createMock(...args),
+    },
+  },
+}));
+
+vi.mock("../../lib/server/session", () => ({
+  getSessionUser: () => getSessionUserMock(),
+}));
+
+import { POST } from "../../app/api/rules/[id]/duplicate/route";
+
+function makeContext(id: string) {
+  return { params: Promise.resolve({ id }) };
+}
+
+beforeEach(() => {
+  isDatabaseConfiguredMock.mockReset();
+  findUniqueMock.mockReset();
+  createMock.mockReset();
+  getSessionUserMock.mockReset();
+});
+
+describe("POST /api/rules/[id]/duplicate", () => {
+  it("returns 401 when not signed in", async () => {
+    isDatabaseConfiguredMock.mockReturnValue(true);
+    getSessionUserMock.mockResolvedValue(null);
+    const res = await POST(
+      new NextRequest("https://x.test/api/rules/r1/duplicate"),
+      makeContext("r1"),
+    );
+    expect(res.status).toBe(401);
+  });
+
+  it("returns 404 when the source rule does not exist", async () => {
+    isDatabaseConfiguredMock.mockReturnValue(true);
+    getSessionUserMock.mockResolvedValue({ id: "u1", email: "a@b.c" });
+    findUniqueMock.mockResolvedValueOnce(null);
+    const res = await POST(
+      new NextRequest("https://x.test/api/rules/missing/duplicate"),
+      makeContext("missing"),
+    );
+    expect(res.status).toBe(404);
+  });
+
+  it("returns 403 when the user does not own the source rule", async () => {
+    isDatabaseConfiguredMock.mockReturnValue(true);
+    getSessionUserMock.mockResolvedValue({ id: "u1", email: "a@b.c" });
+    findUniqueMock.mockResolvedValueOnce({
+      id: "r1",
+      userId: "other",
+      title: "T",
+      summary: null,
+      document: {},
+    });
+    const res = await POST(
+      new NextRequest("https://x.test/api/rules/r1/duplicate"),
+      makeContext("r1"),
+    );
+    expect(res.status).toBe(403);
+    expect(createMock).not.toHaveBeenCalled();
+  });
+
+  it("returns 201-style 200 with the new rule when duplicate succeeds", async () => {
+    isDatabaseConfiguredMock.mockReturnValue(true);
+    getSessionUserMock.mockResolvedValue({ id: "u1", email: "a@b.c" });
+    findUniqueMock.mockResolvedValueOnce({
+      id: "r1",
+      userId: "u1",
+      title: "Original",
+      summary: "S",
+      document: { x: 1 },
+    });
+    createMock.mockResolvedValueOnce({
+      id: "r2",
+      title: "Original (Copy)",
+      summary: "S",
+      createdAt: new Date("2026-01-01T00:00:00Z"),
+      updatedAt: new Date("2026-01-01T00:00:00Z"),
+    });
+    const res = await POST(
+      new NextRequest("https://x.test/api/rules/r1/duplicate"),
+      makeContext("r1"),
+    );
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { rule: { id: string; title: string } };
+    expect(body.rule.id).toBe("r2");
+    expect(body.rule.title).toBe("Original (Copy)");
+  });
+});

tests/unit/rulesMeRoute.test.ts

@@ -0,0 +1,75 @@
+import { NextRequest } from "next/server";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const isDatabaseConfiguredMock = vi.fn();
+const listForUserMock = vi.fn();
+const getSessionUserMock = vi.fn();
+
+vi.mock("../../lib/server/env", () => ({
+  isDatabaseConfigured: () => isDatabaseConfiguredMock(),
+}));
+
+vi.mock("../../lib/server/publishedRules", () => ({
+  listPublishedRulesForUser: (...args: unknown[]) => listForUserMock(...args),
+}));
+
+vi.mock("../../lib/server/session", () => ({
+  getSessionUser: () => getSessionUserMock(),
+}));
+
+import { GET } from "../../app/api/rules/me/route";
+
+beforeEach(() => {
+  isDatabaseConfiguredMock.mockReset();
+  listForUserMock.mockReset();
+  getSessionUserMock.mockReset();
+});
+
+describe("GET /api/rules/me", () => {
+  it("returns 503 when the database is not configured", async () => {
+    isDatabaseConfiguredMock.mockReturnValue(false);
+    const res = await GET(
+      new NextRequest("https://x.test/api/rules/me"),
+      undefined,
+    );
+    expect(res.status).toBe(503);
+    expect(getSessionUserMock).not.toHaveBeenCalled();
+  });
+
+  it("returns 401 when not signed in", async () => {
+    isDatabaseConfiguredMock.mockReturnValue(true);
+    getSessionUserMock.mockResolvedValue(null);
+    const res = await GET(
+      new NextRequest("https://x.test/api/rules/me"),
+      undefined,
+    );
+    expect(res.status).toBe(401);
+    expect(listForUserMock).not.toHaveBeenCalled();
+  });
+
+  it("returns 200 with { rules } for the session user", async () => {
+    isDatabaseConfiguredMock.mockReturnValue(true);
+    getSessionUserMock.mockResolvedValue({ id: "user-1", email: "a@b.c" });
+    const rows = [
+      {
+        id: "r1",
+        title: "Rule A",
+        summary: "S",
+        createdAt: new Date("2026-01-01T00:00:00Z"),
+        updatedAt: new Date("2026-01-02T00:00:00Z"),
+      },
+    ];
+    listForUserMock.mockResolvedValueOnce(rows);
+    const res = await GET(
+      new NextRequest("https://x.test/api/rules/me?limit=10"),
+      undefined,
+    );
+    expect(res.status).toBe(200);
+    expect(listForUserMock).toHaveBeenCalledWith("user-1", 10);
+    const body = (await res.json()) as {
+      rules: Array<{ id: string; title: string }>;
+    };
+    expect(body.rules).toHaveLength(1);
+    expect(body.rules[0].id).toBe("r1");
+  });
+});

tests/unit/userMeDeleteRoute.test.ts

@@ -0,0 +1,65 @@
+import { NextRequest } from "next/server";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const isDatabaseConfiguredMock = vi.fn();
+const userDeleteMock = vi.fn();
+const getSessionUserMock = vi.fn();
+
+vi.mock("../../lib/server/env", () => ({
+  isDatabaseConfigured: () => isDatabaseConfiguredMock(),
+}));
+
+vi.mock("../../lib/server/db", () => ({
+  prisma: {
+    user: {
+      delete: (...args: unknown[]) => userDeleteMock(...args),
+    },
+  },
+}));
+
+vi.mock("../../lib/server/session", () => ({
+  getSessionUser: () => getSessionUserMock(),
+  clearSessionCookie: vi.fn(),
+}));
+
+import { DELETE } from "../../app/api/user/me/route";
+
+beforeEach(() => {
+  isDatabaseConfiguredMock.mockReset();
+  userDeleteMock.mockReset();
+  getSessionUserMock.mockReset();
+});
+
+describe("DELETE /api/user/me", () => {
+  it("returns 503 when the database is not configured", async () => {
+    isDatabaseConfiguredMock.mockReturnValue(false);
+    const res = await DELETE(
+      new NextRequest("https://x.test/api/user/me"),
+      undefined,
+    );
+    expect(res.status).toBe(503);
+  });
+
+  it("returns 401 when not signed in", async () => {
+    isDatabaseConfiguredMock.mockReturnValue(true);
+    getSessionUserMock.mockResolvedValue(null);
+    const res = await DELETE(
+      new NextRequest("https://x.test/api/user/me"),
+      undefined,
+    );
+    expect(res.status).toBe(401);
+    expect(userDeleteMock).not.toHaveBeenCalled();
+  });
+
+  it("deletes the user and returns 200 when signed in", async () => {
+    isDatabaseConfiguredMock.mockReturnValue(true);
+    getSessionUserMock.mockResolvedValue({ id: "u1", email: "a@b.c" });
+    userDeleteMock.mockResolvedValueOnce(undefined);
+    const res = await DELETE(
+      new NextRequest("https://x.test/api/user/me"),
+      undefined,
+    );
+    expect(res.status).toBe(200);
+    expect(userDeleteMock).toHaveBeenCalledWith({ where: { id: "u1" } });
+  });
+});