tenseleyflow/shithub / 14ae067

+	html, mentions := renderBody(ctx, deps, p.Body)

+	// Emit the domain event in the same tx as the issue row so a

+	// rollback drops both. Mention resolution happens *after* commit

+	// to avoid holding the row lock through user-id lookups; the

+	// fan-out worker reads payload.mentions to drive @-ping

+	// recipients.

+	mentionIDs := mentionUserIDs(ctx, deps.Pool, mentions)

+	repoVis, _ := repoVisibilityPublic(ctx, tx, p.RepoID)

+	eventKind := "issue_created"

+	if kind == "pr" {

+		eventKind = "pr_opened"

+	}

+	if err := emitIssueEventTx(ctx, tx, eventKind, row, p.AuthorUserID, repoVis, mentionIDs); err != nil {

+		return issuesdb.Issue{}, fmt.Errorf("emit event: %w", err)

+	}

+

+	html, mentions := renderBody(ctx, deps, body)

+	mentionIDs := mentionUserIDs(ctx, deps.Pool, mentions)

+	repoVis, _ := repoVisibilityPublic(ctx, tx, issue.RepoID)

+	commentKind := "issue_comment_created"

+	if issue.Kind == issuesdb.IssueKindPr {

+		commentKind = "pr_comment_created"

+	}

+	if err := emitCommentEventTx(ctx, tx, commentKind, issue, c.ID, p.AuthorUserID, repoVis, mentionIDs); err != nil {

+		return issuesdb.IssueComment{}, fmt.Errorf("emit event: %w", err)

+	}

+

+	// Lifecycle domain event so the notif fan-out + S33 webhook

+	// pipeline pick up state changes the same way they pick up

+	// comments.

+	issue, _ := q.GetIssueByID(ctx, tx, issueID)

+	repoVis, _ := repoVisibilityPublic(ctx, tx, issue.RepoID)

+	stateKind := "issue_" + kind // issue_closed | issue_reopened

+	if issue.Kind == issuesdb.IssueKindPr {

+		stateKind = "pr_" + kind

+	}

+	if err := emitIssueEventTx(ctx, tx, stateKind, issue, actorUserID, repoVis, nil); err != nil {

+		return fmt.Errorf("emit event: %w", err)

+	}

+	html, _ := renderBody(ctx, deps, body)

+	return html

+}

+

+// renderBody is the mention-aware variant. Returns the cleaned HTML

+// plus the resolved mentions list — callers that emit notification

+// events use the mentions to fan out @-pings. The `_` shimming under

+// renderBodyHTML keeps existing call sites that don't care about

+// mentions untouched.

+func renderBody(ctx context.Context, deps Deps, body string) (string, []mdrender.Mention) {

+	if body == "" {

+		return "", nil

+	}

+	html, _, mentions, err := mdrender.Render(ctx, []byte(body), mdrender.Options{

+		SoftBreakAsBR: true,

+	})

+		return "", nil

+	return string(html), mentions

+	// S29: domain event so the fan-out worker can route an

+	// `assignment` notification to the assignee.

+	issue, _ := q.GetIssueByID(ctx, tx, issueID)

+	repoVis, _ := repoVisibilityPublic(ctx, tx, issue.RepoID)

+	if err := emitAssignmentEventTx(ctx, tx, issue, actorUserID, userID, repoVis); err != nil {

+		return err

+	}

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+package issues

+

+import (

+	"context"

+	"errors"

+	"strconv"

+

+	"github.com/jackc/pgx/v5"

+	"github.com/jackc/pgx/v5/pgxpool"

+

+	issuesdb "github.com/tenseleyFlow/shithub/internal/issues/sqlc"

+	"github.com/tenseleyFlow/shithub/internal/markdown"

+	"github.com/tenseleyFlow/shithub/internal/notif"

+)

+

+// emitIssueEventTx emits a domain event for an issue/PR mutation

+// inside the orchestrator's tx. Centralized so every call site

+// records the same shape (kind, source, repo, mentions).

+func emitIssueEventTx(

+	ctx context.Context,

+	tx pgx.Tx,

+	kind string,

+	issue issuesdb.Issue,

+	actorUserID int64,

+	repoIsPublic bool,

+	mentions []int64,

+) error {

+	return notif.EmitTx(ctx, tx, notif.Event{

+		ActorUserID: actorUserID,

+		Kind:        kind,

+		RepoID:      issue.RepoID,

+		SourceKind:  "issue",

+		SourceID:    issue.ID,

+		Public:      repoIsPublic,

+		Mentions:    mentions,

+		Extra: map[string]any{

+			"issue_number": issue.Number,

+			"issue_title":  issue.Title,

+		},

+	})

+}

+

+// emitCommentEventTx emits a comment-create event. Carries the

+// underlying issue number/title so the inbox can render a useful

+// summary without an extra join.

+func emitCommentEventTx(

+	ctx context.Context,

+	tx pgx.Tx,

+	kind string,

+	issue issuesdb.Issue,

+	commentID int64,

+	actorUserID int64,

+	repoIsPublic bool,

+	mentions []int64,

+) error {

+	return notif.EmitTx(ctx, tx, notif.Event{

+		ActorUserID: actorUserID,

+		Kind:        kind,

+		RepoID:      issue.RepoID,

+		SourceKind:  "issue",

+		SourceID:    issue.ID,

+		Public:      repoIsPublic,

+		Mentions:    mentions,

+		Extra: map[string]any{

+			"issue_number": issue.Number,

+			"issue_title":  issue.Title,

+			"comment_id":   strconv.FormatInt(commentID, 10),

+		},

+	})

+}

+

+// emitAssignmentEventTx fires when a user is added as an assignee.

+// One event per assignee — the fan-out worker treats each as a

+// separate "this user has been assigned" notification with reason

+// `assignment`.

+func emitAssignmentEventTx(

+	ctx context.Context,

+	tx pgx.Tx,

+	issue issuesdb.Issue,

+	actorUserID, assigneeUserID int64,

+	repoIsPublic bool,

+) error {

+	return notif.EmitTx(ctx, tx, notif.Event{

+		ActorUserID: actorUserID,

+		Kind:        "issue_assigned",

+		RepoID:      issue.RepoID,

+		SourceKind:  "issue",

+		SourceID:    issue.ID,

+		Public:      repoIsPublic,

+		// `assignee_user_id` lets the fan-out worker route the

+		// notification to the assignee even if they're not yet a

+		// thread subscriber.

+		Extra: map[string]any{

+			"issue_number":     issue.Number,

+			"issue_title":      issue.Title,

+			"assignee_user_id": assigneeUserID,

+		},

+	})

+}

+

+// repoVisibilityPublic resolves the repo's visibility (public/private)

+// using the pool. Best-effort: errors collapse to false (private),

+// which is the safe default for the public-feed flag on the event row.

+func repoVisibilityPublic(ctx context.Context, db pgxRow, repoID int64) (bool, error) {

+	var vis string

+	err := db.QueryRow(ctx,

+		`SELECT visibility::text FROM repos WHERE id = $1`,

+		repoID,

+	).Scan(&vis)

+	if err != nil {

+		if errors.Is(err, pgx.ErrNoRows) {

+			return false, nil

+		}

+		return false, err

+	}

+	return vis == "public", nil

+}

+

+// pgxRow is the minimum surface emit helpers need from a tx or pool.

+type pgxRow interface {

+	QueryRow(ctx context.Context, sql string, args ...any) pgx.Row

+}

+

+// mentionUserIDs is the call-site ergonomic wrapper around

+// notif.ResolveMentionUserIDs. Lives here so issues.go's call site

+// stays a one-liner.

+func mentionUserIDs(ctx context.Context, pool *pgxpool.Pool, ms []markdown.Mention) []int64 {

+	return notif.ResolveMentionUserIDs(ctx, pool, ms)

+}

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+package notif

+

+import (

+	"context"

+	"encoding/json"

+	"fmt"

+

+	"github.com/jackc/pgx/v5"

+	"github.com/jackc/pgx/v5/pgtype"

+	"github.com/jackc/pgx/v5/pgxpool"

+

+	socialdb "github.com/tenseleyFlow/shithub/internal/social/sqlc"

+	"github.com/tenseleyFlow/shithub/internal/worker"

+)

+

+// Event is the call-site shape for an emitter. The notif package

+// owns the schema-side details (which columns are NULL, payload

+// shape, JSON marshal); callers fill in the semantic fields.

+//

+// Mentions, when present, are surfaced to the fan-out worker via the

+// `mentions` JSON key in payload — kept here so callers don't have

+// to remember the wire convention.

+type Event struct {

+	ActorUserID int64  // 0 → system event (NULL in DB).

+	Kind        string // e.g. "issue_comment_created", "pr_review_requested".

+	RepoID      int64  // 0 → user-scoped event (NULL).

+	SourceKind  string // "issue", "pull", "repo", "user", …

+	SourceID    int64

+	Public      bool     // matches repo visibility (caller decides).

+	Mentions    []int64  // resolved user-ids to fan out @-mentions to.

+	Extra       map[string]any

+}

+

+// Emit inserts one row into domain_events and wakes the worker pool.

+// Use within a tx via EmitTx when the emit must atomically commit

+// with the source change (the typical case — issue.Create + the

+// matching event row land together or not at all).

+//

+// The emit side is intentionally thin: the routing matrix and

+// recipient computation live entirely in the fan-out worker so

+// callers don't grow a per-kind switch.

+func Emit(ctx context.Context, pool *pgxpool.Pool, ev Event) error {

+	if err := emitInto(ctx, pool, ev); err != nil {

+		return err

+	}

+	// Wake the worker pool. Best-effort — the cron-driven schedule

+	// catches up if NOTIFY is dropped (LISTEN reconnects on its own).

+	_ = worker.Notify(ctx, pool)

+	return nil

+}

+

+// EmitTx is the in-tx variant. Use it when the source mutation and

+// the event row must commit together (almost always). The NOTIFY is

+// deferred to commit by Postgres semantics; this matches the rest of

+// the worker's enqueue patterns.

+func EmitTx(ctx context.Context, tx pgx.Tx, ev Event) error {

+	return emitInto(ctx, tx, ev)

+}

+

+func emitInto(ctx context.Context, db socialdb.DBTX, ev Event) error {

+	payload, err := buildPayload(ev)

+	if err != nil {

+		return fmt.Errorf("notif emit: payload: %w", err)

+	}

+	if _, err := socialdb.New().InsertDomainEvent(ctx, db, socialdb.InsertDomainEventParams{

+		ActorUserID: pgInt8(ev.ActorUserID),

+		Kind:        ev.Kind,

+		RepoID:      pgInt8(ev.RepoID),

+		SourceKind:  ev.SourceKind,

+		SourceID:    ev.SourceID,

+		Public:      ev.Public,

+		Payload:     payload,

+	}); err != nil {

+		return fmt.Errorf("notif emit: insert: %w", err)

+	}

+	return nil

+}

+

+func buildPayload(ev Event) ([]byte, error) {

+	out := map[string]any{}

+	for k, v := range ev.Extra {

+		out[k] = v

+	}

+	if len(ev.Mentions) > 0 {

+		out["mentions"] = ev.Mentions

+	}

+	if len(out) == 0 {

+		return []byte("{}"), nil

+	}

+	return json.Marshal(out)

+}

+

+func pgInt8(v int64) pgtype.Int8 {

+	return pgtype.Int8{Int64: v, Valid: v != 0}

+}

+// SPDX-License-Identifier: AGPL-3.0-or-later

+

+package notif

+

+import (

+	"context"

+

+	"github.com/jackc/pgx/v5/pgxpool"

+

+	"github.com/tenseleyFlow/shithub/internal/markdown"

+	usersdb "github.com/tenseleyFlow/shithub/internal/users/sqlc"

+)

+

+// ResolveMentionUserIDs maps a slice of (possibly duplicate)

+// `markdown.Mention` records to deduplicated user IDs. Unknown,

+// suspended, and soft-deleted accounts are silently dropped — the

+// fan-out worker should never produce notifications for accounts

+// that wouldn't have read access. Result is stable-ordered by

+// first-occurrence in the input.

+//

+// The lookup is one-by-one rather than batched: typical mention

+// counts are in the single digits and the per-username GetUserByUsername

+// is index-backed. Batching becomes worth it only above ~50 distinct

+// mentions per body.

+func ResolveMentionUserIDs(ctx context.Context, pool *pgxpool.Pool, ms []markdown.Mention) []int64 {

+	if len(ms) == 0 {

+		return nil

+	}

+	q := usersdb.New()

+	seen := map[int64]struct{}{}

+	out := make([]int64, 0, len(ms))

+	for _, m := range ms {

+		u, err := q.GetUserByUsername(ctx, pool, m.Username)

+		if err != nil {

+			continue

+		}

+		if u.SuspendedAt.Valid || u.DeletedAt.Valid {

+			continue

+		}

+		if _, dup := seen[u.ID]; dup {

+			continue

+		}

+		seen[u.ID] = struct{}{}

+		out = append(out, u.ID)

+	}

+	if len(out) == 0 {

+		return nil

+	}

+	return out

+}

+	issuesdb "github.com/tenseleyFlow/shithub/internal/issues/sqlc"

+	"github.com/tenseleyFlow/shithub/internal/notif"

+	row, err := q.CreatePRReviewRequest(ctx, deps.Pool, pullsdb.CreatePRReviewRequestParams{

+	if err != nil {

+		return row, err

+	}

+	// S29: emit a domain event so the fan-out worker can route a

+	// `review_requested` notification to the requested reviewer.

+	// Best-effort — review-request side already succeeded; an emit

+	// failure is logged but doesn't fail the request (the fan-out

+	// worker isn't strict about ordering for this kind).

+	issue, ierr := issuesdb.New().GetIssueByID(ctx, deps.Pool, p.PRIssueID)

+	if ierr == nil {

+		var public bool

+		_ = deps.Pool.QueryRow(ctx,

+			`SELECT visibility = 'public' FROM repos WHERE id = $1`,

+			issue.RepoID,

+		).Scan(&public)

+		_ = notif.Emit(ctx, deps.Pool, notif.Event{

+			ActorUserID: p.RequestedByUserID,

+			Kind:        "review_requested",

+			RepoID:      issue.RepoID,

+			SourceKind:  "issue",

+			SourceID:    issue.ID,

+			Public:      public,

+			Extra: map[string]any{

+				"reviewer_user_id": p.RequestedUserID,

+				"issue_number":     issue.Number,

+				"issue_title":      issue.Title,

+			},

+		})

+	}

+	return row, nil