Re-land event comments/followers/remix-contests with safe migration

Re-applies #765 (reverted in #766). The original PR's
ddl/migrations/0195_subscriptions_generic_entity.sql wrapped an
ALTER TABLE plus a non-CONCURRENT CREATE INDEX in BEGIN/COMMIT,
holding ACCESS EXCLUSIVE on subscriptions for the full index
build and causing an API outage.

Migration changes:
- Replaced 0195 with 0196_subscriptions_generic_entity.sql.
- Dropped the BEGIN/COMMIT wrapper so CREATE INDEX CONCURRENTLY
  is legal.
- Switched to CREATE INDEX CONCURRENTLY IF NOT EXISTS so writes
  are not blocked during the build.
- Removed the no-op UPDATE that scanned the table while holding
  the exclusive lock.
- All statements use IF NOT EXISTS so prod (where 0195 already
  committed) treats this as a no-op and fresh envs still
  bootstrap correctly.

Trigger change in handle_track.sql:
- Replaced the per-row LOOP that issued one INSERT per follower
  / saver with a single set-based INSERT ... SELECT ... ON
  CONFLICT DO NOTHING. Avoids slow trigger execution for tracks
  whose contest creator has many followers.

Also added subscriptions_entity_type_entity_id_idx to
sql/01_schema.sql so the cumulative dump matches the live schema.

Author: claude

api/dbv1/full_comments.go

@@ -105,7 +105,7 @@ func (q *Queries) FullCommentsKeyed(ctx context.Context, arg GetCommentsParams)
 			SELECT 1
 			FROM comment_reactions
 			WHERE comment_id = comments.comment_id
-			AND user_id = COALESCE(tracks.owner_id, comments.entity_id)
+			AND user_id = COALESCE(tracks.owner_id, events.user_id, comments.entity_id)
 			AND is_delete = false
 		) AS is_artist_reacted,
 
@@ -128,11 +128,13 @@ func (q *Queries) FullCommentsKeyed(ctx context.Context, arg GetCommentsParams)
 
 	FROM comments
 	LEFT JOIN tracks ON comments.entity_type = 'Track' AND comments.entity_id = tracks.track_id
+	LEFT JOIN events ON comments.entity_type = 'Event' AND comments.entity_id = events.event_id
 	LEFT JOIN comment_threads USING (comment_id)
 	WHERE comments.comment_id = ANY(@ids::int[])
 	AND (
 		(comments.entity_type = 'Track' AND (@include_unlisted = true OR COALESCE(tracks.is_unlisted, false) = false))
 		OR comments.entity_type = 'FanClub'
+		OR (comments.entity_type = 'Event' AND COALESCE(events.is_deleted, false) = false)
 	)
 	ORDER BY comments.created_at DESC
 	`

api/dbv1/models.go

@@ -511,6 +511,12 @@ func NewApiServer(config config.Config) *ApiServer {
 		g.Get("/fan_club/feed", app.v1FanClubFeed)
 		g.Get("/fan-club/feed", app.v1FanClubFeed)
 
+		g.Get("/events/:eventId/comments", app.v1EventComments)
+		g.Get("/events/:eventId/follow_state", app.v1EventFollowState)
+		g.Get("/events/:eventId/follow-state", app.v1EventFollowState)
+		g.Post("/events/:eventId/follow", app.requireAuthMiddleware, app.requireWriteScope, app.postV1EventFollow)
+		g.Delete("/events/:eventId/follow", app.requireAuthMiddleware, app.requireWriteScope, app.deleteV1EventFollow)
+
 		g.Get("/tracks/:trackId/comments", app.v1TrackComments)
 		g.Get("/tracks/:trackId/comment_count", app.v1TrackCommentCount)
 		g.Get("/tracks/:trackId/comment-count", app.v1TrackCommentCount)
@@ -608,6 +614,7 @@ func NewApiServer(config config.Config) *ApiServer {
 		// Events
 		g.Get("/events/unclaimed_id", app.v1EventsUnclaimedId)
 		g.Get("/events/unclaimed-id", app.v1EventsUnclaimedId)
+		g.Get("/events/remix-contests", app.v1EventsRemixContests)
 		g.Get("/events", app.v1Events)
 		g.Get("/events/all", app.v1Events)
 		g.Get("/events/entity", app.v1Events)

api/server.go

@@ -1194,6 +1194,57 @@ paths:
         "500":
           description: Server error
           content: {}
+  /events/remix-contests:
+    get:
+      tags:
+        - events
+      summary: Get all remix contests
+      description:
+        Get remix contest events ordered with currently-active contests first
+        (by soonest-ending), followed by ended contests (most-recently-ended
+        first). Active contests are those whose end_date is null or in the
+        future.
+      operationId: Get Remix Contests
+      security:
+        - {}
+        - OAuth2:
+            - read
+      parameters:
+        - name: offset
+          in: query
+          description:
+            The number of items to skip. Useful for pagination (page number
+            * limit)
+          schema:
+            type: integer
+        - name: limit
+          in: query
+          description: The number of items to fetch
+          schema:
+            type: integer
+        - name: status
+          in: query
+          description: Filter contests by status
+          schema:
+            type: string
+            default: all
+            enum:
+              - active
+              - ended
+              - all
+      responses:
+        "200":
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/events_response"
+        "400":
+          description: Bad request
+          content: {}
+        "500":
+          description: Server error
+          content: {}
   /events/unclaimed_id:
     get:
       tags:

api/swagger/swagger-v1.yaml

@@ -23,7 +23,7 @@ type GetCommentsParams struct {
 }
 
 type CreateCommentRequest struct {
-	EntityType      string `json:"entityType" validate:"required,oneof=Track"`
+	EntityType      string `json:"entityType" validate:"required,oneof=Track FanClub Event"`
 	EntityId        int    `json:"entityId" validate:"required,min=1"`
 	Body            string `json:"body" validate:"required,max=500"`
 	CommentId       *int   `json:"commentId,omitempty" validate:"omitempty,min=1"`
@@ -33,19 +33,19 @@ type CreateCommentRequest struct {
 }
 
 type UpdateCommentRequest struct {
-	EntityType string `json:"entityType" validate:"required,oneof=Track"`
+	EntityType string `json:"entityType" validate:"required,oneof=Track FanClub Event"`
 	EntityId   int    `json:"entityId" validate:"required,min=1"`
 	Body       string `json:"body" validate:"required,max=500"`
 	Mentions   []int  `json:"mentions,omitempty" validate:"omitempty,dive,min=1"`
 }
 
 type ReactCommentRequest struct {
-	EntityType string `json:"entityType" validate:"required,oneof=Track"`
+	EntityType string `json:"entityType" validate:"required,oneof=Track FanClub Event"`
 	EntityId   int    `json:"entityId" validate:"required,min=1"`
 }
 
 type PinCommentRequest struct {
-	EntityType string `json:"entityType" validate:"required,oneof=Track"`
+	EntityType string `json:"entityType" validate:"required,oneof=Track FanClub Event"`
 	EntityId   int    `json:"entityId" validate:"required,min=1"`
 }
 

api/v1_comments.go

@@ -0,0 +1,128 @@
+package api
+
+import (
+	"errors"
+
+	"api.audius.co/api/dbv1"
+	"api.audius.co/trashid"
+	"github.com/gofiber/fiber/v2"
+	"github.com/jackc/pgx/v5"
+)
+
+// v1EventComments returns the top-level comment stream for a remix-contest event.
+// Comments are authored by any signed-in user; a comment is considered a "post
+// update" when its user_id matches the event's owner user_id (resolved client-side).
+// Replies are not returned in this list — they come back nested inside the
+// FullComment result just like track comments.
+func (app *ApiServer) v1EventComments(c *fiber.Ctx) error {
+	encodedEventID := c.Params("eventId")
+	eventID, err := trashid.DecodeHashId(encodedEventID)
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "invalid event id")
+	}
+
+	var eventRow struct {
+		UserID    int32
+		IsDeleted bool
+	}
+	err = app.pool.QueryRow(c.Context(), `
+		SELECT user_id, COALESCE(is_deleted, false)
+		FROM events
+		WHERE event_id = $1
+		LIMIT 1
+	`, eventID).Scan(&eventRow.UserID, &eventRow.IsDeleted)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return fiber.NewError(fiber.StatusNotFound, "event not found")
+		}
+		return err
+	}
+	if eventRow.IsDeleted {
+		return fiber.NewError(fiber.StatusNotFound, "event not found")
+	}
+
+	var params GetCommentsParams
+	if err := app.ParseAndValidateQueryParams(c, &params); err != nil {
+		return err
+	}
+
+	myID := app.getMyId(c)
+
+	// Pull top-level comment ids for this event, sorted and paginated the same
+	// way track comments are. Threads are materialised below by FullComments.
+	orderBy := `comments.created_at DESC`
+	switch params.SortMethod {
+	case "timestamp":
+		orderBy = `comments.created_at ASC`
+	case "top":
+		orderBy = `(SELECT COUNT(*) FROM comment_reactions cr WHERE cr.comment_id = comments.comment_id) DESC, comments.created_at DESC`
+	}
+
+	sql := `
+		SELECT comments.comment_id
+		FROM comments
+		LEFT JOIN comment_threads ct ON ct.comment_id = comments.comment_id
+		WHERE comments.entity_type = 'Event'
+		  AND comments.entity_id = @eventId
+		  AND comments.is_delete = false
+		  AND ct.parent_comment_id IS NULL
+		ORDER BY ` + orderBy + `
+		LIMIT @limit
+		OFFSET @offset
+	`
+
+	args := pgx.NamedArgs{
+		"eventId": eventID,
+		"limit":   params.Limit,
+		"offset":  params.Offset,
+	}
+
+	rows, err := app.pool.Query(c.Context(), sql, args)
+	if err != nil {
+		return err
+	}
+	commentIDs, err := pgx.CollectRows(rows, pgx.RowTo[int32])
+	if err != nil {
+		return err
+	}
+
+	comments, err := app.queries.FullComments(c.Context(), dbv1.GetCommentsParams{
+		Ids:             commentIDs,
+		MyID:            myID,
+		IncludeUnlisted: true,
+	})
+	if err != nil {
+		return err
+	}
+
+	// Collect related user ids so the UI can render avatars/handles in one shot.
+	userIDs := []int32{eventRow.UserID}
+	for _, co := range comments {
+		userIDs = append(userIDs, int32(co.UserId))
+		for _, m := range co.Mentions {
+			userIDs = append(userIDs, int32(m.UserId))
+		}
+		for _, r := range co.Replies {
+			userIDs = append(userIDs, int32(r.UserId))
+		}
+	}
+
+	related, err := app.queries.Parallel(c.Context(), dbv1.ParallelParams{
+		UserIds:      userIDs,
+		TrackIds:     nil,
+		MyID:         myID,
+		AuthedWallet: app.tryGetAuthedWallet(c),
+	})
+	if err != nil {
+		return err
+	}
+
+	return c.JSON(fiber.Map{
+		"data": comments,
+		"related": fiber.Map{
+			"users":  related.UserList(),
+			"tracks": related.TrackList(),
+		},
+		"event_user_id": trashid.MustEncodeHashID(int(eventRow.UserID)),
+	})
+}