create-feedbax 0.2.1 → 0.2.2

package/template/src/feedbax/config/index.ts

@@ -63,11 +63,21 @@ export type ConnectedConfiguration = {
   readonly issuer: string;
   readonly loginUrl: string;
 };
-export type FeedbaxConfig = {
+export type GitHubConfiguration = {
+  readonly installationId: string;
+  readonly serviceUrl: string;
+  readonly repository: {
+    readonly id: number;
+    readonly owner: string;
+    readonly name: string;
+  };
+  readonly botUserId: number;
+};
+type CommonConfiguration = {
+  readonly history?: boolean;
   readonly connected?: ConnectedConfiguration;
   readonly product: ProductConfiguration;
   readonly theme: { readonly preset: string };
-  readonly notion: NotionConfiguration;
   readonly changelog?: ChangelogConfiguration;
   readonly features: PortalFeatures;
   readonly submissions: {
@@ -78,7 +88,24 @@ export type FeedbaxConfig = {
   readonly turnstile: { readonly enabled: boolean; readonly siteKey?: string };
 };
 
+export type FeedbaxConfig = CommonConfiguration &
+  (
+    | {
+        readonly provider?: "notion";
+        readonly notion: NotionConfiguration;
+        readonly github?: never;
+      }
+    | {
+        readonly provider: "github";
+        readonly github: GitHubConfiguration;
+        readonly notion?: never;
+      }
+  );
+
 const rootKeys = [
+  "history",
+  "provider",
+  "github",
   "connected",
   "product",
   "theme",
@@ -124,6 +151,8 @@ export function defineFeedbax(config: FeedbaxConfig): FeedbaxConfig;
 export function defineFeedbax(config: unknown): FeedbaxConfig {
   const value = object(config, "Feedbax configuration");
   rejectUnknown(value, rootKeys, "Feedbax configuration");
+  if (value.history !== undefined && typeof value.history !== "boolean")
+    throw new Error("history must be true or false.");
   const product = object(value.product, "product");
   rejectUnknown(
     product,
@@ -218,11 +247,28 @@ export function defineFeedbax(config: unknown): FeedbaxConfig {
   }
   const theme = object(value.theme, "theme");
   rejectUnknown(theme, ["preset"], "theme");
-  const notion = storage(
-    value.notion,
-    feedbackPropertyKeys,
-    "notion",
-  ) as NotionConfiguration;
+  if (
+    value.provider !== undefined &&
+    !["notion", "github"].includes(String(value.provider))
+  )
+    throw new Error("provider must be notion or github.");
+  const githubMode = value.provider === "github";
+  if (
+    (githubMode && value.notion !== undefined) ||
+    (!githubMode && value.github !== undefined)
+  )
+    throw new Error("Select exactly one Content Provider: notion or github.");
+  const content: Pick<FeedbaxConfig, "provider" | "notion" | "github"> =
+    githubMode
+      ? { provider: "github", github: githubConfiguration(value.github) }
+      : {
+          ...(value.provider ? { provider: "notion" as const } : {}),
+          notion: storage(
+            value.notion,
+            feedbackPropertyKeys,
+            "notion",
+          ) as NotionConfiguration,
+        };
   const features = object(value.features, "features");
   rejectUnknown(features, featureKeys, "features");
   const validatedFeatures = Object.fromEntries(
@@ -232,6 +278,13 @@ export function defineFeedbax(config: unknown): FeedbaxConfig {
       return [key, features[key]];
     }),
   ) as PortalFeatures;
+  if (
+    githubMode &&
+    (validatedFeatures.changelog || value.changelog !== undefined)
+  )
+    throw new Error(
+      "GitHub Installations must disable Changelog (features.changelog: false) and remove Notion Changelog configuration.",
+    );
   const changelog =
     value.changelog === undefined
       ? undefined
@@ -264,9 +317,10 @@ export function defineFeedbax(config: unknown): FeedbaxConfig {
     throw new Error("Turnstile is enabled but turnstile.siteKey is missing.");
   return {
     product: validatedProduct,
+    ...(value.history !== undefined ? { history: value.history } : {}),
     ...(connected ? { connected } : {}),
     theme: { preset: text(theme.preset, "theme.preset") },
-    notion,
+    ...content,
     ...(changelog ? { changelog } : {}),
     features: validatedFeatures,
     submissions: {
@@ -281,7 +335,7 @@ export function defineFeedbax(config: unknown): FeedbaxConfig {
       ),
     },
     turnstile: { enabled: turnstile.enabled, ...(siteKey ? { siteKey } : {}) },
-  };
+  } as FeedbaxConfig;
 }
 
 export function assertProductionConfiguration(
@@ -362,3 +416,52 @@ function publicUrl(
     `${label} must be ${allowRelative ? "root-relative or " : ""}an HTTPS URL.`,
   );
 }
+
+function githubConfiguration(value: unknown): GitHubConfiguration {
+  const input = object(value, "github");
+  rejectUnknown(
+    input,
+    ["installationId", "serviceUrl", "repository", "botUserId"],
+    "github",
+  );
+  const installationId = text(input.installationId, "github.installationId");
+  if (!/^[a-zA-Z0-9_-]{1,128}$/.test(installationId))
+    throw new Error(
+      "github.installationId must be a stable Installation identifier.",
+    );
+  const serviceUrl = publicUrl(input.serviceUrl, "github.serviceUrl", false);
+  const url = new URL(serviceUrl);
+  if (url.origin !== serviceUrl || url.username || url.password)
+    throw new Error(
+      "github.serviceUrl must be an HTTPS origin without a path or credentials.",
+    );
+  const repository = object(input.repository, "github.repository");
+  rejectUnknown(repository, ["id", "owner", "name"], "github.repository");
+  const owner = text(repository.owner, "github.repository.owner");
+  const name = text(repository.name, "github.repository.name");
+  if (!/^[A-Za-z0-9-]+$/.test(owner) || !/^[A-Za-z0-9_.-]+$/.test(name))
+    throw new Error("Use a valid GitHub repository owner and name.");
+  return {
+    installationId,
+    serviceUrl,
+    repository: {
+      id: positiveInteger(repository.id, "github.repository.id"),
+      owner,
+      name,
+    },
+    botUserId: positiveInteger(input.botUserId, "github.botUserId"),
+  };
+}
+
+export function assertRuntimeBindings(
+  config: FeedbaxConfig,
+  bindings: { FEEDBAX_DB?: unknown },
+) {
+  if (
+    (config.provider === "github" || config.connected || config.history) &&
+    !bindings.FEEDBAX_DB
+  )
+    throw new Error(
+      "This Installation requires the FEEDBAX_DB D1 binding. Provision D1 and apply the included migrations; D1 does not enable verified identity.",
+    );
+}

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

@@ -0,0 +1,38 @@
+import type { CommentAuthor } from "./index";
+
+export interface StoredComment {
+  recoverable?: boolean;
+  id: string;
+  postId: string;
+  discussionId: string;
+  body: string;
+  author: CommentAuthor;
+  createdAt: Date;
+  resolved: boolean;
+  scope?: "page" | "block";
+}
+
+export interface CommentStorage {
+  supportsIntentRecovery?: boolean;
+  createPageComment(input: {
+    submissionKey?: string;
+    recoveryCommentId?: string;
+    postId: string;
+    body: string;
+    displayName: string;
+  }): Promise<StoredComment>;
+  createDiscussionReply(input: {
+    submissionKey?: string;
+    recoveryCommentId?: string;
+    postId: string;
+    discussionId: string;
+    body: string;
+    displayName: string;
+  }): Promise<StoredComment>;
+  listPageComments(
+    postId: string,
+    cursor?: string,
+  ): Promise<{ items: StoredComment[]; nextCursor?: string }>;
+  updateComment(commentId: string, body: string): Promise<StoredComment>;
+  deleteComment(commentId: string): Promise<void>;
+}

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

@@ -1,8 +1,11 @@
+import { createHash } from "node:crypto";
 import {
   type FeedbackModule,
   type PublicPost,
   PublicPostCursorError,
   VoteEligibilityError,
+  recoverableComment,
+  CommentValidationError,
   roadmapStatuses,
   type PublicPostRoadmap,
 } from "./index";
@@ -48,30 +51,56 @@ export function createConnectedFeedbackModule(
     },
   ) => {
     const identity = requireParticipant();
-    const command = { ...input, displayName: identity.displayName };
+    if (
+      input.submissionKey !== undefined &&
+      !/^[A-Za-z0-9_-]{43}$/.test(input.submissionKey)
+    )
+      throw new CommentValidationError("Comment intent is invalid.");
+    const command = {
+      ...input,
+      displayName: identity.displayName,
+      ...(input.submissionKey
+        ? {
+            submissionKey: createHash("sha256")
+              .update(
+                JSON.stringify([
+                  "feedbax-verified-comment-v1",
+                  identity.subject,
+                  input.submissionKey,
+                ]),
+              )
+              .digest("base64url"),
+          }
+        : {}),
+    };
     const comment = input.discussionId
       ? await base.replyToCommentThread({
           ...command,
           discussionId: input.discussionId,
         })
       : await base.createComment(command);
-    // If attribution cannot be stored, remove the just-created Comment. Never claim verification without durable evidence.
+    // Stable provider intents retain their record for attribution recovery. Older adapters compensate best-effort; verification is returned only after the private write.
     try {
       await store.attributeComment(comment.id, identity);
     } catch (error) {
-      await base
-        .deleteComment({ commentId: comment.id })
-        .catch(() => undefined);
+      if (!comment[recoverableComment])
+        await base
+          .deleteComment({ commentId: comment.id })
+          .catch(() => undefined);
       throw error;
     }
-    return {
-      ...comment,
-      author: {
-        kind: "participant" as const,
-        displayName: identity.displayName,
-        verified: true,
+    return Object.defineProperty(
+      {
+        ...comment,
+        author: {
+          kind: "participant" as const,
+          displayName: identity.displayName,
+          verified: true,
+        },
       },
-    };
+      recoverableComment,
+      { value: comment[recoverableComment] },
+    );
   };
   const listPublicRoadmapPosts: FeedbackModule["listPublicRoadmapPosts"] =
     async (query) => {

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

@@ -169,11 +169,21 @@ export function createConnectedStore(binding: D1Database) {
       commentId: string,
       participant: VerifiedParticipant,
     ) {
-      await db.insert(attribution).values({
-        commentId,
-        subject: participant.subject,
-        displayName: participant.displayName,
-      });
+      await db
+        .insert(attribution)
+        .values({
+          commentId,
+          subject: participant.subject,
+          displayName: participant.displayName,
+        })
+        .onConflictDoNothing();
+      const owner = await db
+        .select({ subject: attribution.subject })
+        .from(attribution)
+        .where(eq(attribution.commentId, commentId))
+        .get();
+      if (owner?.subject !== participant.subject)
+        throw new Error("Comment attribution is unavailable.");
     },
     async commentAuthors(ids: string[]) {
       const result = new Map<

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

@@ -7,6 +7,7 @@ export type StoredPost = Post &
     browserCapabilityHash: string;
     source: PostSource;
     externalId: string;
+    draftEditable: boolean;
   }> &
   Record<string, unknown>;