create-feedbax 0.2.1 → 0.2.2

package/template/src/feedbax/feedback/observed-history.test.ts

@@ -0,0 +1,150 @@
+import { afterEach, expect, it } from "vitest";
+import { Miniflare } from "miniflare";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { createFeedbackModule, type Post } from "./index";
+import { createObservedHistoryModule } from "./observed-history";
+
+let runtime: Miniflare | undefined;
+afterEach(async () => {
+  await runtime?.dispose();
+  runtime = undefined;
+});
+
+it("records only observed public progress, deduplicates retries and revokes history while unpublished", async () => {
+  runtime = new Miniflare({
+    modules: true,
+    script: "export default {}",
+    d1Databases: ["DB"],
+    compatibilityDate: "2026-07-30",
+  });
+  const database = await runtime.getD1Database("DB");
+  const path = "0009_observed_history.sql";
+  await database.exec(
+    await readFile(
+      existsSync(`apps/portal/migrations/${path}`)
+        ? `apps/portal/migrations/${path}`
+        : `migrations/${path}`,
+      "utf8",
+    ),
+  );
+  let time = 10000;
+  const post: Post = {
+    id: "private-provider-id",
+    slug: "export-reports",
+    title: "Export reports",
+    description: "Public description",
+    type: "Feature Request",
+    status: "New",
+    published: false,
+    createdAt: new Date(1000),
+    updatedAt: new Date(2000),
+    submitter: { name: "Private name", email: "private@example.com" },
+    teamResponse: "Private draft response",
+  };
+  const view = () =>
+    createObservedHistoryModule({
+      database,
+      feedback: createFeedbackModule({ initialItems: [{ ...post }] }),
+      now: () => time,
+    });
+  expect((await view().list({ slug: post.slug })).items).toEqual([]);
+  post.status = "Planned";
+  post.published = true;
+  post.teamResponse = "Approved current response";
+  expect((await view().list({ slug: post.slug })).items).toEqual([]);
+  post.status = "In Progress";
+  post.teamResponse = "Work has started";
+  time = 20000;
+  const first = await view().list({ slug: post.slug });
+  expect(first.items).toMatchObject([
+    { kind: "status", status: "In Progress", observedAt: new Date(20000) },
+    { kind: "update", body: "Work has started", observedAt: new Date(20000) },
+  ]);
+  expect((await view().list({ slug: post.slug })).items).toEqual(first.items);
+  expect(JSON.stringify(first)).not.toMatch(
+    /Private|private-provider-id|private@example|actor|subject/,
+  );
+  post.published = false;
+  post.teamResponse = "Private later discussion";
+  time = 30000;
+  expect((await view().list({ slug: post.slug })).items).toEqual([]);
+  post.status = "Shipped";
+  post.published = true;
+  time = 40000;
+  expect((await view().list({ slug: post.slug })).items).toEqual(first.items);
+  post.status = "Planned";
+  post.teamResponse = "Another approved update";
+  time = 50000;
+  await Promise.all([view().observe(post.slug), view().observe(post.slug)]);
+  expect((await view().list({ slug: post.slug })).items).toHaveLength(4);
+  post.status = "Shipped";
+  time = 60000;
+  await database.exec(
+    "CREATE TRIGGER fail_history BEFORE INSERT ON public_post_history BEGIN SELECT RAISE(FAIL,'History unavailable'); END;",
+  );
+  await expect(view().observe(post.slug)).rejects.toThrow();
+  await database.exec("DROP TRIGGER fail_history;");
+  expect((await view().list({ slug: post.slug })).items).toHaveLength(5);
+});
+
+it("paginates a longer observed timeline without duplicates and rejects another Post's cursor", async () => {
+  runtime = new Miniflare({
+    modules: true,
+    script: "export default {}",
+    d1Databases: ["DB"],
+    compatibilityDate: "2026-07-30",
+  });
+  const database = await runtime.getD1Database("DB");
+  await database.exec(
+    await readFile(
+      existsSync("apps/portal/migrations/0009_observed_history.sql")
+        ? "apps/portal/migrations/0009_observed_history.sql"
+        : "migrations/0009_observed_history.sql",
+      "utf8",
+    ),
+  );
+  const post: Post = {
+    id: "source-id",
+    slug: "long-history",
+    title: "Long history",
+    description: "Public",
+    type: "General Feedback",
+    status: "Planned",
+    published: true,
+    createdAt: new Date(1000),
+    updatedAt: new Date(1000),
+  };
+  let time = 1000;
+  const view = () =>
+    createObservedHistoryModule({
+      database,
+      feedback: createFeedbackModule({ initialItems: [{ ...post }] }),
+      now: () => time,
+    });
+  await view().observe(post.slug);
+  for (let i = 0; i < 27; i++) {
+    time++;
+    post.status = i % 2 ? "Planned" : "In Progress";
+    await view().observe(post.slug);
+  }
+  const first = await view().list({ slug: post.slug });
+  expect(first.items).toHaveLength(25);
+  expect(first.items[0]).toMatchObject({
+    kind: "status",
+    status: "In Progress",
+    observedAt: new Date(1001),
+  });
+  const second = await view().list({
+    slug: post.slug,
+    cursor: first.nextCursor,
+  });
+  expect(second.items).toHaveLength(2);
+  expect(
+    new Set([...first.items, ...second.items].map((event) => event.id)).size,
+  ).toBe(27);
+  post.slug = "another-post";
+  await expect(
+    view().list({ slug: post.slug, cursor: first.nextCursor }),
+  ).rejects.toThrow("cursor");
+});

package/template/src/feedbax/feedback/observed-history.ts

@@ -0,0 +1,219 @@
+import { randomUUID } from "node:crypto";
+import type { D1Database } from "@cloudflare/workers-types";
+import type { FeedbackModule, PostStatus } from "./index";
+
+export type ObservedHistoryEvent = {
+  id: string;
+  observedAt: Date;
+} & ({ kind: "status"; status: PostStatus } | { kind: "update"; body: string });
+export interface ObservedHistoryPage {
+  available: boolean;
+  items: ObservedHistoryEvent[];
+  nextCursor?: string;
+}
+type Snapshot = { status: PostStatus; response: string | null };
+type Observation = { revision: number; projection: string | null };
+type EventRow = {
+  id: string;
+  revision: number;
+  kind: "status" | "update";
+  status: PostStatus | null;
+  message: string | null;
+  observed_at: number;
+};
+
+// Callers supply the configured Feedback module, never provider payloads. The
+// initial visible snapshot is a baseline, not reconstructed historical activity.
+export function createObservedHistoryModule(options: {
+  database: D1Database;
+  feedback: FeedbackModule;
+  now?: () => number;
+}) {
+  const { database, feedback } = options;
+  const now = options.now ?? Date.now;
+  const observe = async (slug: string) => {
+    const time = now();
+    const known = await database
+      .prepare("SELECT 1 FROM public_post_observations WHERE post_slug=?")
+      .bind(slug)
+      .first();
+    if (!known) {
+      const post = await feedback.getPublicPost(slug);
+      if (!post) return;
+      await database
+        .prepare(
+          "INSERT OR IGNORE INTO public_post_observations(post_slug,projection,checked_at) VALUES(?,?,?)",
+        )
+        .bind(
+          slug,
+          JSON.stringify({
+            status: post.status,
+            response: post.teamResponse ?? null,
+          }),
+          time,
+        )
+        .run();
+      return post;
+    }
+    const token = randomUUID();
+    const previous = await database
+      .prepare(
+        "UPDATE public_post_observations SET lease_token=?,lease_until=?,checked_at=? WHERE post_slug=? AND lease_until<=? RETURNING revision,projection",
+      )
+      .bind(token, time + 60000, time, slug, time)
+      .first<Observation>();
+    if (!previous) return feedback.getPublicPost(slug);
+    let providerReadSucceeded = false;
+    try {
+      const post = await feedback.getPublicPost(slug);
+      providerReadSucceeded = true;
+      const snapshot: Snapshot | null = post
+        ? { status: post.status, response: post.teamResponse ?? null }
+        : null;
+      const encoded = snapshot ? JSON.stringify(snapshot) : null;
+      const before: Snapshot | null = previous.projection
+        ? JSON.parse(previous.projection)
+        : null;
+      const revision = previous.revision + 1;
+      const statements = [];
+      if (before && snapshot) {
+        if (before.status !== snapshot.status)
+          statements.push(
+            database
+              .prepare(
+                "INSERT OR IGNORE INTO public_post_history(id,post_slug,revision,kind,status,observed_at) SELECT ?,?,?,'status',?,? WHERE EXISTS(SELECT 1 FROM public_post_observations WHERE post_slug=? AND lease_token=?)",
+              )
+              .bind(
+                randomUUID(),
+                slug,
+                revision,
+                snapshot.status,
+                time,
+                slug,
+                token,
+              ),
+          );
+        if (snapshot.response && before.response !== snapshot.response)
+          statements.push(
+            database
+              .prepare(
+                "INSERT OR IGNORE INTO public_post_history(id,post_slug,revision,kind,message,observed_at) SELECT ?,?,?,'update',?,? WHERE EXISTS(SELECT 1 FROM public_post_observations WHERE post_slug=? AND lease_token=?)",
+              )
+              .bind(
+                randomUUID(),
+                slug,
+                revision,
+                snapshot.response,
+                time,
+                slug,
+                token,
+              ),
+          );
+      }
+      statements.push(
+        database
+          .prepare(
+            "UPDATE public_post_observations SET revision=?,projection=?,lease_token=NULL,lease_until=0 WHERE post_slug=? AND lease_token=?",
+          )
+          .bind(revision, encoded, slug, token),
+      );
+      const committed = await database.batch(statements);
+      // A later observer may have revoked visibility after this lease expired.
+      // Its checkpoint wins; a fenced completion cannot authorize a public read.
+      return committed.at(-1)?.meta.changes === 1 ? post : undefined;
+    } catch (error) {
+      // Provider access loss breaks the public baseline. A storage failure
+      // preserves it so retry can durably record the same observed transition.
+      await database
+        .prepare(
+          "UPDATE public_post_observations SET projection=CASE WHEN ? THEN projection ELSE NULL END,lease_token=NULL,lease_until=0 WHERE post_slug=? AND lease_token=?",
+        )
+        .bind(providerReadSucceeded ? 1 : 0, slug, token)
+        .run();
+      throw error;
+    }
+  };
+  return {
+    observe,
+    async list(input: {
+      slug: string;
+      cursor?: string;
+    }): Promise<ObservedHistoryPage> {
+      if (!(await observe(input.slug))) return { available: false, items: [] };
+      let revision = -1;
+      let kind = "";
+      if (input.cursor) {
+        try {
+          const parsed = JSON.parse(
+            Buffer.from(input.cursor, "base64url").toString("utf8"),
+          );
+          if (
+            parsed.slug !== input.slug ||
+            !Number.isSafeInteger(parsed.revision) ||
+            parsed.revision < 0 ||
+            !["status", "update"].includes(parsed.kind)
+          )
+            throw Error();
+          revision = parsed.revision;
+          kind = parsed.kind;
+        } catch {
+          throw Error("Invalid observed-history cursor.");
+        }
+      }
+      const rows = (
+        await database
+          .prepare(
+            "SELECT id,revision,kind,status,message,observed_at FROM public_post_history WHERE post_slug=? AND (revision>? OR (revision=? AND kind>?)) ORDER BY revision,kind LIMIT 26",
+          )
+          .bind(input.slug, revision, revision, kind)
+          .all<EventRow>()
+      ).results;
+      const selected = rows.slice(0, 25);
+      const last = selected.at(-1);
+      return {
+        available: true,
+        items: selected.map((row) => ({
+          id: row.id,
+          observedAt: new Date(row.observed_at),
+          ...(row.kind === "status"
+            ? { kind: "status" as const, status: row.status! }
+            : { kind: "update" as const, body: row.message! }),
+        })),
+        ...(rows.length > 25 && last
+          ? {
+              nextCursor: Buffer.from(
+                JSON.stringify({
+                  slug: input.slug,
+                  revision: last.revision,
+                  kind: last.kind,
+                }),
+              ).toString("base64url"),
+            }
+          : {}),
+      };
+    },
+    async synchronize(limit = 1) {
+      if (!Number.isInteger(limit) || limit < 1 || limit > 10)
+        throw Error("History work limit must be 1–10.");
+      const rows = (
+        await database
+          .prepare(
+            "SELECT post_slug FROM public_post_observations WHERE lease_until<=? ORDER BY checked_at,post_slug LIMIT ?",
+          )
+          .bind(now(), limit)
+          .all<{ post_slug: string }>()
+      ).results;
+      let checked = 0,
+        failed = 0;
+      for (const row of rows) {
+        try {
+          await observe(row.post_slug);
+          checked++;
+        } catch {
+          failed++;
+        }
+      }
+      return { checked, failed };
+    },
+  };
+}

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

@@ -0,0 +1,170 @@
+import { createHash } from "node:crypto";
+import { BrowserCapabilityAuthorizationError } from "./index";
+import type { D1Database } from "@cloudflare/workers-types";
+import type {
+  FeedbackModule,
+  ParticipantPost,
+  Post,
+  PostType,
+  PublicPost,
+} from "./index";
+import type { VerifiedParticipant } from "./connected";
+
+export interface PostOwnership {
+  owns(id: string): Promise<boolean>;
+  register(post: Post): Promise<void>;
+  withdrawn(id: string): Promise<void>;
+}
+export function createPostOwnership(
+  database: D1Database,
+  participant: VerifiedParticipant,
+): PostOwnership {
+  return {
+    async owns(id) {
+      return Boolean(
+        await database
+          .prepare("SELECT 1 FROM post_ownership WHERE post_id=? AND subject=?")
+          .bind(id, participant.subject)
+          .first(),
+      );
+    },
+    async register(post) {
+      await database
+        .prepare(
+          "INSERT OR IGNORE INTO post_ownership(post_id,post_slug,subject,title,type,created_at) VALUES(?,?,?,?,?,?)",
+        )
+        .bind(
+          post.id,
+          post.slug,
+          participant.subject,
+          post.title,
+          post.type,
+          post.createdAt.getTime(),
+        )
+        .run();
+      if (!(await this.owns(post.id)))
+        throw new BrowserCapabilityAuthorizationError();
+    },
+    async withdrawn(id) {
+      await database
+        .prepare(
+          "UPDATE post_ownership SET withdrawn=1 WHERE post_id=? AND subject=?",
+        )
+        .bind(id, participant.subject)
+        .run();
+    },
+  };
+}
+export type MyFeedbackFilter = "submitted" | "supported" | "following";
+export type MyFeedbackItem = Partial<ParticipantPost> &
+  Pick<PublicPost, "slug" | "title"> & {
+    unavailable?: boolean;
+    withdrawn?: boolean;
+  };
+export interface MyFeedbackPage {
+  items: MyFeedbackItem[];
+  nextCursor?: string;
+}
+export function createMyFeedbackModule(options: {
+  database: D1Database;
+  feedback: FeedbackModule;
+  participant: VerifiedParticipant;
+}) {
+  const { database, feedback, participant } = options;
+  return {
+    async list(input: {
+      filter: MyFeedbackFilter;
+      cursor?: string;
+    }): Promise<MyFeedbackPage> {
+      if (!["submitted", "supported", "following"].includes(input.filter))
+        throw new Error("Invalid My feedback filter.");
+      const fingerprint = createHash("sha256")
+        .update(JSON.stringify([participant.subject, input.filter]))
+        .digest("hex");
+      let cursor = { at: Number.MAX_SAFE_INTEGER, key: "" };
+      if (input.cursor) {
+        try {
+          if (input.cursor.length > 2048) throw new Error();
+          const value = JSON.parse(
+            Buffer.from(input.cursor, "base64url").toString(),
+          );
+          if (
+            value.view !== fingerprint ||
+            !Number.isSafeInteger(value.at) ||
+            value.at < 0 ||
+            typeof value.key !== "string" ||
+            value.key.length > 512
+          )
+            throw new Error();
+          cursor = value;
+        } catch {
+          throw new Error("Invalid My feedback cursor.");
+        }
+      }
+      const selection =
+        input.filter === "submitted"
+          ? "SELECT post_id AS key,post_slug AS slug,created_at AS at,title,type,withdrawn FROM post_ownership WHERE subject=?"
+          : input.filter === "supported"
+            ? "SELECT post_slug AS key,post_slug AS slug,0 AS at FROM participant_votes WHERE subject=?"
+            : "SELECT post_slug AS key,post_slug AS slug,followed_at AS at FROM post_follows WHERE subject=?";
+      const rows = (
+        await database
+          .prepare(
+            `SELECT * FROM (${selection}) WHERE at<? OR (at=? AND key>?) ORDER BY at DESC,key LIMIT 11`,
+          )
+          .bind(participant.subject, cursor.at, cursor.at, cursor.key)
+          .all<{
+            key: string;
+            slug: string;
+            at: number;
+            title?: string;
+            type?: PostType;
+            withdrawn?: number;
+          }>()
+      ).results;
+      const items = await Promise.all(
+        rows.slice(0, 10).map(async (row): Promise<MyFeedbackItem> => {
+          if (input.filter === "submitted") {
+            if (!row.withdrawn) {
+              const post = await feedback.getParticipantPost(row.key);
+              if (post) return post;
+            }
+            return {
+              id: row.key,
+              slug: row.slug,
+              title: row.title ?? "Submission unavailable",
+              type: row.type,
+              editable: false,
+              unavailable: true,
+              ...(row.withdrawn ? { withdrawn: true } : {}),
+            };
+          }
+          const post = await feedback.getPublicPost(row.slug);
+          return post
+            ? { ...post, published: true, editable: false }
+            : {
+                slug: row.slug,
+                title: "Post unavailable",
+                unavailable: true,
+                editable: false,
+              };
+        }),
+      );
+      const last = rows[9];
+      return {
+        items,
+        ...(rows.length > 10 && last
+          ? {
+              nextCursor: Buffer.from(
+                JSON.stringify({
+                  at: last.at,
+                  key: last.key,
+                  view: fingerprint,
+                }),
+              ).toString("base64url"),
+            }
+          : {}),
+      };
+    },
+  };
+}

package/template/src/history-runtime.test.ts

@@ -0,0 +1,80 @@
+import { afterEach, expect, it } from "vitest";
+import { Miniflare } from "miniflare";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import {
+  createFeedbackModule,
+  createObservedHistoryModule,
+} from "@feedbax/feedback";
+import { createPublicHistoryRequestHandler } from "./history-runtime";
+let runtime: Miniflare | undefined;
+afterEach(async () => {
+  await runtime?.dispose();
+  runtime = undefined;
+});
+it("returns only current public observed history with no-store and rejects invalid requests", async () => {
+  runtime = new Miniflare({
+    modules: true,
+    script: "export default {}",
+    d1Databases: ["DB"],
+    compatibilityDate: "2026-07-30",
+  });
+  const database = await runtime.getD1Database("DB");
+  await database.exec(
+    await readFile(
+      existsSync("apps/portal/migrations/0009_observed_history.sql")
+        ? "apps/portal/migrations/0009_observed_history.sql"
+        : "migrations/0009_observed_history.sql",
+      "utf8",
+    ),
+  );
+  const feedback = createFeedbackModule();
+  const history = createObservedHistoryModule({ database, feedback });
+  const handle = createPublicHistoryRequestHandler({
+    enabled: true,
+    history,
+    rateLimit: async () => true,
+  });
+  const response = await handle(
+    new Request(
+      "https://portal.example/internal/post-history?slug=unknown-post",
+    ),
+  );
+  expect(response?.headers.get("Cache-Control")).toBe("no-store");
+  expect(await response?.json()).toEqual({ available: false, items: [] });
+  expect(
+    (
+      await handle(
+        new Request(
+          "https://portal.example/internal/post-history?slug=%2Fprivate",
+        ),
+      )
+    )?.status,
+  ).toBe(400);
+  expect(
+    (
+      await handle(
+        new Request(
+          "https://portal.example/internal/post-history?slug=unknown-post",
+          { method: "POST" },
+        ),
+      )
+    )?.status,
+  ).toBe(405);
+  expect(
+    await handle(new Request("https://portal.example/other")),
+  ).toBeUndefined();
+  expect(
+    (
+      await createPublicHistoryRequestHandler({
+        enabled: false,
+        history,
+        rateLimit: async () => true,
+      })(
+        new Request(
+          "https://portal.example/internal/post-history?slug=unknown-post",
+        ),
+      )
+    )?.status,
+  ).toBe(404);
+});

package/template/src/history-runtime.ts

@@ -0,0 +1,37 @@
+import type { createObservedHistoryModule } from "@feedbax/feedback";
+
+export function createPublicHistoryRequestHandler(options: {
+  enabled: boolean;
+  history?: ReturnType<typeof createObservedHistoryModule>;
+  rateLimit: (request: Request) => Promise<boolean>;
+}) {
+  return async (request: Request): Promise<Response | undefined> => {
+    const url = new URL(request.url);
+    if (url.pathname !== "/internal/post-history") return;
+    const json = (body: unknown, status = 200) =>
+      Response.json(body, { status, headers: { "Cache-Control": "no-store" } });
+    if (!options.enabled || !options.history)
+      return json({ error: "Not found." }, 404);
+    if (request.method !== "GET")
+      return json({ error: "Method not allowed." }, 405);
+    const slug = url.searchParams.get("slug");
+    const cursor = url.searchParams.get("cursor") ?? undefined;
+    if (
+      !slug ||
+      slug.length > 200 ||
+      !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug) ||
+      (cursor && (cursor.length > 1024 || !/^[A-Za-z0-9_-]+$/.test(cursor)))
+    )
+      return json({ error: "Invalid history request." }, 400);
+    if (!(await options.rateLimit(request)))
+      return json({ error: "Too many requests. Try again shortly." }, 429);
+    try {
+      return json(await options.history.list({ slug, cursor }));
+    } catch {
+      return json(
+        { error: "Progress history is temporarily unavailable." },
+        503,
+      );
+    }
+  };
+}

package/template/src/index.css

@@ -1304,6 +1304,12 @@ input[data-slot="command-input"]:focus-visible {
   border-top: 1px solid var(--portal-rule);
 }
 
+.post-detail-comments-tab {
+  margin-top: 0;
+  padding-top: 0;
+  border-top: 0;
+}
+
 .post-detail-comments > h2,
 .post-detail-sidebar > h2 {
   margin: 0;