create-feedbax 0.1.0 → 0.2.1

package/template/src/feedbax/feedback/connected.test.ts

@@ -0,0 +1,272 @@
+import { afterEach, expect, it } from "vitest";
+import { Miniflare } from "miniflare";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { createConnectedStore } from "./connected";
+
+let runtime: Miniflare | undefined;
+afterEach(async () => {
+  await runtime?.dispose();
+});
+async function migratedDatabase() {
+  runtime = new Miniflare({
+    modules: true,
+    script: "export default {fetch(){return new Response('ok')}}",
+    compatibilityDate: "2026-07-30",
+    d1Databases: ["DB"],
+  });
+  const binding = await runtime.getD1Database("DB");
+  await binding.exec(
+    (await readFile(
+      existsSync("apps/portal/migrations/0001_connected.sql")
+        ? "apps/portal/migrations/0001_connected.sql"
+        : "migrations/0001_connected.sql",
+      "utf8",
+    )) +
+      "\n" +
+      (await readFile(
+        existsSync("apps/portal/migrations/0002_participation.sql")
+          ? "apps/portal/migrations/0002_participation.sql"
+          : "migrations/0002_participation.sql",
+        "utf8",
+      )),
+  );
+  return binding;
+}
+
+it("persists one Vote per verified Participant across concurrent retries and browsers", async () => {
+  const binding = await migratedDatabase();
+  const store = createConnectedStore(binding);
+  await store.acceptIdentity({
+    subject: "alice",
+    displayName: "Alice",
+    nonce: "once",
+    sessionHash: "session",
+    expiresAt: Date.now() + 60000,
+  });
+  await Promise.all(
+    Array.from({ length: 8 }, () => store.setVote("post-1", "alice", true)),
+  );
+  expect(await store.voteState("post-1", "alice")).toEqual({
+    voteCount: 1,
+    voted: true,
+  });
+  const secondBrowser = createConnectedStore(binding);
+  expect(await secondBrowser.voteState("post-1", "alice")).toEqual({
+    voteCount: 1,
+    voted: true,
+  });
+  await secondBrowser.setVote("post-1", "alice", false);
+  await secondBrowser.setVote("post-1", "alice", false);
+  expect(await store.voteState("post-1", "alice")).toEqual({
+    voteCount: 0,
+    voted: false,
+  });
+});
+it("rejects replayed handoffs without replacing an existing Participant or creating a session", async () => {
+  const binding = await migratedDatabase();
+  const store = createConnectedStore(binding);
+  const input = {
+    subject: "alice",
+    displayName: "Alice",
+    nonce: "once",
+    sessionHash: "session",
+    expiresAt: 2000,
+  };
+  await store.acceptIdentity(input);
+  await expect(
+    store.acceptIdentity({
+      ...input,
+      displayName: "Changed",
+      sessionHash: "replay",
+    }),
+  ).rejects.toThrow();
+  expect(await store.session("session", 1500)).toEqual({
+    subject: "alice",
+    displayName: "Alice",
+  });
+  expect(await store.session("replay", 1500)).toBeUndefined();
+  expect(await store.session("session", 2000)).toBeUndefined();
+  await store.logout("session");
+  expect(await store.session("session", 1500)).toBeUndefined();
+});
+
+it("ranks by verified Votes and attributes only Comments with identity evidence", async () => {
+  const binding = await migratedDatabase();
+  const store = createConnectedStore(binding);
+  const alice = { subject: "alice", displayName: "Alice" };
+  await store.acceptIdentity({
+    ...alice,
+    nonce: "a",
+    sessionHash: "a",
+    expiresAt: Date.now() + 60000,
+  });
+  const { createFeedbackModule, createConnectedFeedbackModule } =
+    await import("./index");
+  const base = createFeedbackModule({
+    initialItems: [
+      {
+        id: "p1",
+        slug: "old-popular",
+        title: "Old",
+        description: "Old",
+        type: "Feature Request",
+        status: "Planned",
+        published: true,
+        createdAt: new Date(1000),
+        updatedAt: new Date(1000),
+        voteCount: 500,
+      },
+      {
+        id: "p2",
+        slug: "new",
+        title: "New",
+        description: "New",
+        type: "Feature Request",
+        status: "Planned",
+        published: true,
+        createdAt: new Date(2000),
+        updatedAt: new Date(2000),
+        voteCount: 0,
+      },
+      {
+        id: "private",
+        slug: "private",
+        title: "Private",
+        description: "Private",
+        type: "Feature Request",
+        status: "New",
+        published: false,
+        createdAt: new Date(2000),
+        updatedAt: new Date(2000),
+        voteCount: 0,
+      },
+    ],
+    initialComments: [
+      {
+        id: "old",
+        postId: "p1",
+        discussionId: "thread",
+        body: "Old",
+        author: { kind: "participant", displayName: "Unverified Alice" },
+        createdAt: new Date(1000),
+        resolved: false,
+      },
+      {
+        id: "team",
+        postId: "p1",
+        discussionId: "thread",
+        body: "Team",
+        author: { kind: "product-team", displayName: "Product Team" },
+        createdAt: new Date(2000),
+        resolved: false,
+      },
+      {
+        id: "resolved",
+        postId: "p1",
+        discussionId: "resolved",
+        body: "Hidden",
+        author: { kind: "product-team", displayName: "Product Team" },
+        createdAt: new Date(2000),
+        resolved: true,
+      },
+    ],
+  });
+  const signedIn = createConnectedFeedbackModule(base, store, alice);
+  const publicRead = createConnectedFeedbackModule(base, store);
+  expect((await publicRead.getPublicPost("old-popular"))?.voteCount).toBe(0);
+  await signedIn.changeVote({ slug: "old-popular", intention: "add" });
+  expect(
+    (await publicRead.listPublicPosts({ sort: "top" })).items.map(
+      (p) => p.slug,
+    ),
+  ).toEqual(["old-popular", "new"]);
+  expect(
+    (await publicRead.listPublicPosts({ sort: "new" })).items.map(
+      (p) => p.slug,
+    ),
+  ).toEqual(["new", "old-popular"]);
+  await expect(
+    signedIn.changeVote({ slug: "private", intention: "add" }),
+  ).rejects.toThrow();
+  await expect(
+    publicRead.changeVote({ slug: "new", intention: "add" }),
+  ).rejects.toThrow("Sign in");
+  const comment = await signedIn.createComment({
+    slug: "old-popular",
+    body: "Hello",
+    displayName: "Spoofed Admin",
+  });
+  expect(comment.author).toEqual({
+    kind: "participant",
+    displayName: "Alice",
+    verified: true,
+  });
+  const comments = (
+    await publicRead.listCommentThreads({ slug: "old-popular" })
+  ).items.flatMap((t) => t.comments);
+  expect(comments.find((c) => c.id === "old")?.author).toEqual({
+    kind: "participant",
+    displayName: "Unverified Alice",
+  });
+  expect(comments.find((c) => c.id === "team")?.author).toEqual({
+    kind: "product-team",
+    displayName: "Product Team",
+  });
+  expect(comments.some((c) => c.id === "resolved")).toBe(false);
+  expect(comments.find((c) => c.id === comment.id)?.author).toEqual(
+    comment.author,
+  );
+  expect(JSON.stringify(comments)).not.toContain('"subject"');
+  expect(
+    (await signedIn.editComment({ commentId: comment.id, body: "Edited" }))
+      .author,
+  ).toEqual(comment.author);
+  const other = createConnectedFeedbackModule(base, store, {
+    subject: "bob",
+    displayName: "Bob",
+  });
+  await expect(
+    other.editComment({ commentId: comment.id, body: "Impersonated" }),
+  ).rejects.toThrow();
+});
+
+it("keeps Top pagination at 25 Posts and binds cursors to their filters", async () => {
+  const store = createConnectedStore(await migratedDatabase());
+  const { createFeedbackModule, createConnectedFeedbackModule } =
+    await import("./index");
+  const base = createFeedbackModule({
+    initialItems: Array.from({ length: 26 }, (_, i) => ({
+      id: `id-${i}`,
+      slug: `post-${i}`,
+      title: `Post ${i}`,
+      description: "Description",
+      type: "Feature Request",
+      status: "Planned",
+      published: true,
+      createdAt: new Date(i * 1000),
+      updatedAt: new Date(i * 1000),
+      voteCount: 0,
+    })),
+  });
+  const feedback = createConnectedFeedbackModule(base, store);
+  const first = await feedback.listPublicPosts({ sort: "top" });
+  expect(first.items).toHaveLength(25);
+  expect(first.nextCursor).toBeTruthy();
+  const second = await feedback.listPublicPosts({
+    sort: "top",
+    cursor: first.nextCursor,
+  });
+  expect(second.items).toHaveLength(1);
+  expect(second.nextCursor).toBeUndefined();
+  expect(
+    new Set([...first.items, ...second.items].map((post) => post.slug)).size,
+  ).toBe(26);
+  await expect(
+    feedback.listPublicPosts({
+      sort: "top",
+      type: "Bug Report",
+      cursor: first.nextCursor,
+    }),
+  ).rejects.toThrow();
+});

package/template/src/feedbax/feedback/connected.ts

@@ -0,0 +1,215 @@
+import type { D1Database } from "@cloudflare/workers-types";
+import { and, count, eq, gt, inArray } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/d1";
+import {
+  integer,
+  primaryKey,
+  sqliteTable,
+  text,
+} from "drizzle-orm/sqlite-core";
+
+export type ConnectedDatabase = D1Database;
+export interface VerifiedParticipant {
+  subject: string;
+  displayName: string;
+}
+const participants = sqliteTable("participants", {
+  subject: text("subject").primaryKey(),
+  displayName: text("display_name").notNull(),
+});
+const contacts = sqliteTable("participant_contacts", {
+  subject: text("subject").primaryKey(),
+  email: text("email"),
+  emailEnabled: integer("email_enabled").notNull().default(0),
+});
+const nonces = sqliteTable("identity_nonces", {
+  nonce: text("nonce").primaryKey(),
+  expiresAt: integer("expires_at").notNull(),
+});
+const sessions = sqliteTable("participant_sessions", {
+  tokenHash: text("token_hash").primaryKey(),
+  subject: text("subject")
+    .notNull()
+    .references(() => participants.subject),
+  expiresAt: integer("expires_at").notNull(),
+});
+const votes = sqliteTable(
+  "participant_votes",
+  {
+    postSlug: text("post_slug").notNull(),
+    subject: text("subject")
+      .notNull()
+      .references(() => participants.subject),
+  },
+  (t) => [primaryKey({ columns: [t.postSlug, t.subject] })],
+);
+const attribution = sqliteTable("comment_attribution", {
+  commentId: text("comment_id").primaryKey(),
+  subject: text("subject")
+    .notNull()
+    .references(() => participants.subject),
+  displayName: text("display_name").notNull(),
+});
+
+export function createConnectedStore(binding: D1Database) {
+  // Without read-replication sessions, D1 routes these queries to its primary.
+  const db = drizzle(binding);
+  return {
+    async acceptIdentity(
+      input: VerifiedParticipant & {
+        email?: string;
+        nonce: string;
+        challenge?: string;
+        sessionHash: string;
+        expiresAt: number;
+      },
+    ) {
+      // A nonce collision rolls the entire D1 batch back, including session creation.
+      await db.batch([
+        db.insert(nonces).values([
+          { nonce: `token:${input.nonce}`, expiresAt: input.expiresAt },
+          ...(input.challenge
+            ? [
+                {
+                  nonce: `browser:${input.challenge}`,
+                  expiresAt: input.expiresAt,
+                },
+              ]
+            : []),
+        ]),
+        db
+          .insert(participants)
+          .values({ subject: input.subject, displayName: input.displayName })
+          .onConflictDoUpdate({
+            target: participants.subject,
+            set: { displayName: input.displayName },
+          }),
+        db
+          .insert(contacts)
+          .values({ subject: input.subject, email: input.email ?? null })
+          .onConflictDoUpdate({
+            target: contacts.subject,
+            set: { email: input.email ?? null },
+          }),
+        db.insert(sessions).values({
+          tokenHash: input.sessionHash,
+          subject: input.subject,
+          expiresAt: input.expiresAt,
+        }),
+      ]);
+    },
+    async session(
+      tokenHash: string,
+      now = Date.now(),
+    ): Promise<VerifiedParticipant | undefined> {
+      return db
+        .select({
+          subject: participants.subject,
+          displayName: participants.displayName,
+        })
+        .from(sessions)
+        .innerJoin(participants, eq(participants.subject, sessions.subject))
+        .where(
+          and(eq(sessions.tokenHash, tokenHash), gt(sessions.expiresAt, now)),
+        )
+        .get();
+    },
+    async logout(tokenHash: string) {
+      await db.delete(sessions).where(eq(sessions.tokenHash, tokenHash));
+    },
+    async setVote(postSlug: string, subject: string, voted: boolean) {
+      if (voted)
+        await db
+          .insert(votes)
+          .values({ postSlug, subject })
+          .onConflictDoNothing();
+      else
+        await db
+          .delete(votes)
+          .where(and(eq(votes.postSlug, postSlug), eq(votes.subject, subject)));
+    },
+    async voteState(postSlug: string, subject?: string) {
+      const [total, own] = await db.batch([
+        db
+          .select({ value: count() })
+          .from(votes)
+          .where(eq(votes.postSlug, postSlug)),
+        db
+          .select({ subject: votes.subject })
+          .from(votes)
+          .where(
+            and(eq(votes.postSlug, postSlug), eq(votes.subject, subject ?? "")),
+          )
+          .limit(1),
+      ]);
+      return { voteCount: total[0]?.value ?? 0, voted: own.length > 0 };
+    },
+    async voteCounts(slugs: string[]) {
+      const result = new Map<string, number>();
+      for (let offset = 0; offset < slugs.length; offset += 80) {
+        const rows = await db
+          .select({ slug: votes.postSlug, total: count() })
+          .from(votes)
+          .where(inArray(votes.postSlug, slugs.slice(offset, offset + 80)))
+          .groupBy(votes.postSlug);
+        for (const row of rows) result.set(row.slug, row.total);
+      }
+      return result;
+    },
+    async commentSubject(commentId: string) {
+      return (
+        await db
+          .select({ subject: attribution.subject })
+          .from(attribution)
+          .where(eq(attribution.commentId, commentId))
+          .get()
+      )?.subject;
+    },
+    async attributeComment(
+      commentId: string,
+      participant: VerifiedParticipant,
+    ) {
+      await db.insert(attribution).values({
+        commentId,
+        subject: participant.subject,
+        displayName: participant.displayName,
+      });
+    },
+    async commentAuthors(ids: string[]) {
+      const result = new Map<
+        string,
+        { kind: "participant"; displayName: string; verified: true }
+      >();
+      for (let offset = 0; offset < ids.length; offset += 80) {
+        const rows = await db
+          .select()
+          .from(attribution)
+          .where(
+            inArray(attribution.commentId, ids.slice(offset, offset + 80)),
+          );
+        for (const row of rows)
+          result.set(row.commentId, {
+            kind: "participant",
+            displayName: row.displayName,
+            verified: true,
+          });
+      }
+      return result;
+    },
+    async commentAuthor(commentId: string) {
+      const row = await db
+        .select({ displayName: attribution.displayName })
+        .from(attribution)
+        .where(eq(attribution.commentId, commentId))
+        .get();
+      return row
+        ? {
+            kind: "participant" as const,
+            displayName: row.displayName,
+            verified: true as const,
+          }
+        : undefined;
+    },
+  };
+}
+export type ConnectedStore = ReturnType<typeof createConnectedStore>;

package/template/src/feedbax/feedback/email-delivery.test.ts

@@ -0,0 +1,65 @@
+import { readFile } from "node:fs/promises";
+import { expect, it } from "vitest";
+import { createFetchMock, Miniflare } from "miniflare";
+import ts from "typescript";
+
+it.each([200, 302])(
+  "sends email inside the actual Workers fetch runtime and rejects provider redirects (%s)",
+  async (status) => {
+    const source = await readFile(
+      new URL("./email-delivery.ts", import.meta.url),
+      "utf8",
+    );
+    const sender = ts.transpileModule(source, {
+      compilerOptions: {
+        target: ts.ScriptTarget.ES2022,
+        module: ts.ModuleKind.ESNext,
+      },
+    }).outputText;
+    const network = createFetchMock();
+    network.disableNetConnect();
+    network
+      .get("https://api.resend.com")
+      .intercept({ path: "/emails", method: "POST" })
+      .reply(status, "{}", {
+        headers:
+          status === 302 ? { location: "https://unexpected.example/leak" } : {},
+      });
+    let redirected = 0;
+    network
+      .get("https://unexpected.example")
+      .intercept({ path: "/leak", method: "GET" })
+      .reply(() => {
+        redirected++;
+        return { statusCode: 200, data: "{}" };
+      });
+    const runtime = new Miniflare({
+      compatibilityDate: "2026-07-30",
+      modulesRoot: "/email-worker",
+      fetchMock: network,
+      modules: [
+        {
+          type: "ESModule",
+          path: "/email-worker/entry.mjs",
+          contents: `import {createEmailSender} from './sender.mjs'; export default {async fetch(){ try {await createEmailSender({provider:'resend',token:'test-provider-key'})({from:'updates@example.com',to:['recipient@example.com'],subject:'Update',text:'A Post changed.',headers:{}},'test-stable-key');return new Response('accepted');}catch(error){return new Response(error.message,{status:502});}}};`,
+        },
+        {
+          type: "ESModule",
+          path: "/email-worker/sender.mjs",
+          contents: sender,
+        },
+      ],
+    });
+    try {
+      const response = await runtime.dispatchFetch(
+        "https://worker.example/send",
+      );
+      expect(await response.text()).not.toContain("test-provider-key");
+      expect(response.status).toBe(status === 200 ? 200 : 502);
+      expect(redirected).toBe(0);
+    } finally {
+      await runtime.dispose();
+      await network.close();
+    }
+  },
+);

package/template/src/feedbax/feedback/email-delivery.ts

@@ -0,0 +1,66 @@
+export interface NotificationEmail {
+  from: string;
+  to: string[];
+  subject: string;
+  text: string;
+  headers: Record<string, string>;
+}
+export type EmailSender = (
+  message: NotificationEmail,
+  deliveryKey: string,
+) => Promise<void>;
+export type CloudflareEmailBinding = {
+  send(message: NotificationEmail): Promise<unknown>;
+};
+
+/** The custom endpoint accepts the same JSON message as Resend and must honor Idempotency-Key. */
+export function createEmailSender(
+  options:
+    | { provider: "cloudflare"; binding: CloudflareEmailBinding }
+    | { provider: "resend"; token: string; request?: typeof fetch }
+    | {
+        provider: "custom";
+        url: string;
+        token: string;
+        request?: typeof fetch;
+      },
+): EmailSender {
+  if (options.provider === "cloudflare")
+    return async (message) => {
+      await options.binding.send(message);
+    };
+  const url =
+    options.provider === "resend"
+      ? "https://api.resend.com/emails"
+      : options.url;
+  const parsed = new URL(url);
+  if (
+    parsed.protocol !== "https:" ||
+    parsed.username ||
+    parsed.password ||
+    parsed.hash
+  )
+    throw new Error(
+      "Email sender requires an HTTPS endpoint without credentials or fragments.",
+    );
+  if (!options.token.trim()) throw new Error("Email sender secret is missing.");
+  return async (message, deliveryKey) => {
+    const response = await (options.request ?? fetch)(url, {
+      method: "POST",
+      // Workers supports manual/follow; manual also prevents forwarding credentials.
+      redirect: "manual",
+      signal: AbortSignal.timeout(10000),
+      headers: {
+        Authorization: `Bearer ${options.token}`,
+        "Content-Type": "application/json",
+        "Idempotency-Key": deliveryKey,
+      },
+      body: JSON.stringify(message),
+    });
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new Error("Email provider did not accept this delivery.");
+    }
+    await response.body?.cancel();
+  };
+}

package/template/src/feedbax/feedback/feedback-storage.ts

@@ -0,0 +1,43 @@
+import type { Post, PublicPostQuery, RoadmapStatus } from "./index";
+
+export type PostSource = "Portal" | "API";
+
+export type StoredPost = Post &
+  Partial<{
+    browserCapabilityHash: string;
+    source: PostSource;
+    externalId: string;
+  }> &
+  Record<string, unknown>;
+
+export type NewStoredPost = Omit<Post, "id"> &
+  Partial<{
+    browserCapabilityHash: string;
+    source: PostSource;
+    externalId: string;
+  }> &
+  Record<string, unknown>;
+
+export interface FeedbackStorage {
+  create(item: NewStoredPost): Promise<StoredPost>;
+  save(item: StoredPost): Promise<StoredPost>;
+  updateVoteCount(item: StoredPost, voteCount: number): Promise<StoredPost>;
+  find(id: string): Promise<StoredPost | undefined>;
+  findBySlug(slug: string): Promise<StoredPost | undefined>;
+  findPublicBySlug(slug: string): Promise<StoredPost | undefined>;
+  findByExternalId(externalId: string): Promise<StoredPost | undefined>;
+  list(): Promise<StoredPost[]>;
+  listPublic(query: PublicPostQuery): Promise<{
+    items: StoredPost[];
+    nextCursor?: string;
+  }>;
+  listPublicRoadmap(query: {
+    status: RoadmapStatus;
+    cursor?: string;
+  }): Promise<{
+    items: StoredPost[];
+    nextCursor?: string;
+    totalCount: number;
+  }>;
+  remove(id: string): Promise<void>;
+}