@atproto/bsky 0.0.221 → 0.0.223

package/src/data-plane/server/indexing/processor.ts

@@ -1,9 +1,7 @@
 import { Insertable } from 'kysely'
-import { CID } from 'multiformats/cid'
 import { chunkArray } from '@atproto/common'
-import { jsonStringToLex, stringifyLex } from '@atproto/lexicon'
+import { Cid, l, lexParse, lexStringify, parseCid } from '@atproto/lex'
 import { AtUri } from '@atproto/syntax'
-import { lexicons } from '../../../lexicon/lexicons'
 import { BackgroundQueue } from '../background'
 import { Database } from '../db'
 import { DatabaseSchema } from '../db/database-schema'
@@ -11,59 +9,57 @@ import { Notification } from '../db/tables/notification'
 
 // @NOTE re: insertions and deletions. Due to how record updates are handled,
 // (insertFn) should have the same effect as (insertFn -> deleteFn -> insertFn).
-type RecordProcessorParams<T, S> = {
-  lexId: string
+type RecordProcessorOptions<TSchema extends l.RecordSchema, TRow> = {
+  schema: TSchema
   insertFn: (
     db: DatabaseSchema,
     uri: AtUri,
-    cid: CID,
-    obj: T,
+    cid: Cid,
+    obj: l.InferInput<TSchema>,
     timestamp: string,
-  ) => Promise<S | null>
+  ) => Promise<TRow | null>
   findDuplicate: (
     db: DatabaseSchema,
     uri: AtUri,
-    obj: T,
+    obj: l.InferInput<TSchema>,
   ) => Promise<AtUri | null>
-  deleteFn: (db: DatabaseSchema, uri: AtUri) => Promise<S | null>
-  notifsForInsert: (obj: S) => Notif[]
+  deleteFn: (db: DatabaseSchema, uri: AtUri) => Promise<TRow | null>
+  notifsForInsert: (obj: TRow) => Notif[]
   notifsForDelete: (
-    prev: S,
-    replacedBy: S | null,
+    prev: TRow,
+    replacedBy: TRow | null,
   ) => { notifs: Notif[]; toDelete: string[] }
-  updateAggregates?: (db: DatabaseSchema, obj: S) => Promise<void>
+  updateAggregates?: (db: DatabaseSchema, obj: TRow) => Promise<void>
 }
 
 type Notif = Insertable<Notification>
 
-export class RecordProcessor<T, S> {
-  collection: string
-  db: DatabaseSchema
+export class RecordProcessor<TSchema extends l.RecordSchema, TRow> {
   constructor(
     private appDb: Database,
     private background: BackgroundQueue,
-    private params: RecordProcessorParams<T, S>,
-  ) {
-    this.db = appDb.db
-    this.collection = this.params.lexId
+    private options: RecordProcessorOptions<TSchema, TRow>,
+  ) {}
+
+  get db() {
+    return this.appDb.db
   }
 
-  matchesSchema(obj: unknown): obj is T {
-    try {
-      this.assertValidRecord(obj)
-      return true
-    } catch {
-      return false
-    }
+  get collection(): TSchema['$type'] {
+    return this.options.schema.$type
+  }
+
+  matchesSchema<I>(obj: I): obj is I & l.InferInput<TSchema> {
+    return this.options.schema.matches(obj)
   }
 
-  assertValidRecord(obj: unknown): asserts obj is T {
-    lexicons.assertValidRecord(this.params.lexId, obj)
+  assertValidRecord(obj: unknown): asserts obj is l.InferInput<TSchema> {
+    this.options.schema.check(obj)
   }
 
   async insertRecord(
     uri: AtUri,
-    cid: CID,
+    cid: Cid,
     obj: unknown,
     timestamp: string,
     opts?: { disableNotifs?: boolean },
@@ -75,12 +71,12 @@ export class RecordProcessor<T, S> {
         uri: uri.toString(),
         cid: cid.toString(),
         did: uri.host,
-        json: stringifyLex(obj),
+        json: lexStringify(obj),
         indexedAt: timestamp,
       })
       .onConflict((oc) => oc.doNothing())
       .execute()
-    const inserted = await this.params.insertFn(
+    const inserted = await this.options.insertFn(
       this.db,
       uri,
       cid,
@@ -95,7 +91,7 @@ export class RecordProcessor<T, S> {
       return
     }
     // if duplicate, insert into duplicates table with no events
-    const found = await this.params.findDuplicate(this.db, uri, obj)
+    const found = await this.options.findDuplicate(this.db, uri, obj)
     if (found && found.toString() !== uri.toString()) {
       await this.db
         .insertInto('duplicate_record')
@@ -116,7 +112,7 @@ export class RecordProcessor<T, S> {
   // straightforward in the general case. We still get nice control over notifications.
   async updateRecord(
     uri: AtUri,
-    cid: CID,
+    cid: Cid,
     obj: unknown,
     timestamp: string,
     opts?: { disableNotifs?: boolean },
@@ -127,12 +123,12 @@ export class RecordProcessor<T, S> {
       .where('uri', '=', uri.toString())
       .set({
         cid: cid.toString(),
-        json: stringifyLex(obj),
+        json: lexStringify(obj),
         indexedAt: timestamp,
       })
       .execute()
     // If the updated record was a dupe, update dupe info for it
-    const dupe = await this.params.findDuplicate(this.db, uri, obj)
+    const dupe = await this.options.findDuplicate(this.db, uri, obj)
     if (dupe) {
       await this.db
         .updateTable('duplicate_record')
@@ -150,13 +146,13 @@ export class RecordProcessor<T, S> {
         .execute()
     }
 
-    const deleted = await this.params.deleteFn(this.db, uri)
+    const deleted = await this.options.deleteFn(this.db, uri)
     if (!deleted) {
       // If a record was updated but hadn't been indexed yet, treat it like a plain insert.
       return this.insertRecord(uri, cid, obj, timestamp)
     }
     this.aggregateOnCommit(deleted)
-    const inserted = await this.params.insertFn(
+    const inserted = await this.options.insertFn(
       this.db,
       uri,
       cid,
@@ -183,7 +179,7 @@ export class RecordProcessor<T, S> {
       .deleteFrom('duplicate_record')
       .where('uri', '=', uri.toString())
       .execute()
-    const deleted = await this.params.deleteFn(this.db, uri)
+    const deleted = await this.options.deleteFn(this.db, uri)
     if (!deleted) return
     this.aggregateOnCommit(deleted)
     if (cascading) {
@@ -205,14 +201,14 @@ export class RecordProcessor<T, S> {
       if (!found) {
         return this.handleNotifs({ deleted })
       }
-      const record = jsonStringToLex(found.json)
+      const record = lexParse(found.json)
       if (!this.matchesSchema(record)) {
         return this.handleNotifs({ deleted })
       }
-      const inserted = await this.params.insertFn(
+      const inserted = await this.options.insertFn(
         this.db,
         new AtUri(found.uri),
-        CID.parse(found.cid),
+        parseCid(found.cid),
         record,
         found.indexedAt,
       )
@@ -223,11 +219,11 @@ export class RecordProcessor<T, S> {
     }
   }
 
-  async handleNotifs(op: { deleted?: S; inserted?: S }) {
+  async handleNotifs(op: { deleted?: TRow; inserted?: TRow }) {
     let notifs: Notif[] = []
     const runOnCommit: ((db: Database) => Promise<void>)[] = []
     if (op.deleted) {
-      const forDelete = this.params.notifsForDelete(
+      const forDelete = this.options.notifsForDelete(
         op.deleted,
         op.inserted ?? null,
       )
@@ -243,7 +239,7 @@ export class RecordProcessor<T, S> {
       }
       notifs = forDelete.notifs
     } else if (op.inserted) {
-      notifs = this.params.notifsForInsert(op.inserted)
+      notifs = this.options.notifsForInsert(op.inserted)
     }
     for (const chunk of chunkArray(notifs, 500)) {
       runOnCommit.push(async (db) => {
@@ -284,8 +280,8 @@ export class RecordProcessor<T, S> {
     return !!threadMute
   }
 
-  aggregateOnCommit(indexed: S) {
-    const { updateAggregates } = this.params
+  aggregateOnCommit(indexed: TRow) {
+    const { updateAggregates } = this.options
     if (!updateAggregates) return
     this.appDb.onCommit(() => {
       this.background.add((db) => updateAggregates(db.db, indexed))

package/src/data-plane/server/routes/activity-subscription.ts

@@ -34,7 +34,8 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
           return {
             actorDid,
             namespace:
-              Namespaces.AppBskyNotificationDefsSubjectActivitySubscription,
+              Namespaces.AppBskyNotificationDefsSubjectActivitySubscription
+                .$type,
             key: '',
             post: undefined,
             reply: undefined,
@@ -45,7 +46,7 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
         return {
           actorDid,
           namespace:
-            Namespaces.AppBskyNotificationDefsSubjectActivitySubscription,
+            Namespaces.AppBskyNotificationDefsSubjectActivitySubscription.$type,
           key: subject.key,
           post: subject.post ? {} : undefined,
           reply: subject.reply ? {} : undefined,

package/src/data-plane/server/routes/bookmarks.ts

@@ -67,7 +67,7 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
       return {
         ref: {
           actorDid,
-          namespace: Namespaces.AppBskyBookmarkDefsBookmark,
+          namespace: Namespaces.AppBskyBookmarkDefsBookmark.$type,
           key: bookmark.key,
         },
         subjectUri: bookmark.subjectUri,

package/src/data-plane/server/routes/mutes.ts

@@ -2,7 +2,7 @@ import assert from 'node:assert'
 import { ServiceImpl } from '@connectrpc/connect'
 import { keyBy } from '@atproto/common'
 import { AtUri } from '@atproto/syntax'
-import { ids } from '../../../lexicon/lexicons'
+import { app } from '../../../lexicons'
 import { Service } from '../../../proto/bsky_connect'
 import { Database } from '../db'
 import { CreatedAtDidKeyset, TimeCidKeyset, paginate } from '../db/pagination'
@@ -186,4 +186,4 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
 })
 
 const isListUri = (uri: string) =>
-  new AtUri(uri).collection === ids.AppBskyGraphList
+  new AtUri(uri).collection === app.bsky.graph.list.$type

package/src/data-plane/server/routes/notifs.ts

@@ -2,13 +2,8 @@ import { Timestamp } from '@bufbuild/protobuf'
 import { ServiceImpl } from '@connectrpc/connect'
 import { sql } from 'kysely'
 import { keyBy } from '@atproto/common'
-import { jsonStringToLex } from '@atproto/lexicon'
-import {
-  ChatPreference,
-  FilterablePreference,
-  Preference,
-  Preferences,
-} from '../../../lexicon/types/app/bsky/notification/defs'
+import { lexParse } from '@atproto/lex'
+import { app } from '../../../lexicons/index.js'
 import { Service } from '../../../proto/bsky_connect'
 import {
   ChatNotificationInclude,
@@ -179,7 +174,11 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
       .selectFrom('private_data')
       .selectAll()
       .where('actorDid', 'in', dids)
-      .where('namespace', '=', Namespaces.AppBskyNotificationDefsPreferences)
+      .where(
+        'namespace',
+        '=',
+        Namespaces.AppBskyNotificationDefsPreferences.$type,
+      )
       .where('key', '=', 'self')
       .execute()
 
@@ -189,7 +188,7 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
       if (!row) {
         return {}
       }
-      const p = jsonStringToLex(row.payload) as Preferences
+      const p = lexParse<app.bsky.notification.defs.Preferences>(row.payload)
       return notificationPreferencesLexToProtobuf(p, row.payload)
     })
 
@@ -198,11 +197,11 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
 })
 
 export const notificationPreferencesLexToProtobuf = (
-  p: Preferences,
+  p: app.bsky.notification.defs.Preferences,
   json: string,
 ): NotificationPreferences => {
   const lexChatPreferenceToProtobuf = (
-    p: ChatPreference,
+    p: app.bsky.notification.defs.ChatPreference,
   ): ChatNotificationPreference =>
     new ChatNotificationPreference({
       include:
@@ -213,7 +212,7 @@ export const notificationPreferencesLexToProtobuf = (
     })
 
   const lexFilterablePreferenceToProtobuf = (
-    p: FilterablePreference,
+    p: app.bsky.notification.defs.FilterablePreference,
   ): FilterableNotificationPreference =>
     new FilterableNotificationPreference({
       include:
@@ -224,7 +223,9 @@ export const notificationPreferencesLexToProtobuf = (
       push: { enabled: p.push ?? true },
     })
 
-  const lexPreferenceToProtobuf = (p: Preference): NotificationPreference =>
+  const lexPreferenceToProtobuf = (
+    p: app.bsky.notification.defs.Preference,
+  ): NotificationPreference =>
     new NotificationPreference({
       list: { enabled: p.list ?? true },
       push: { enabled: p.push ?? true },

package/src/data-plane/server/routes/profile.ts

@@ -1,12 +1,9 @@
 import { Timestamp } from '@bufbuild/protobuf'
 import { ServiceImpl } from '@connectrpc/connect'
 import { Selectable, sql } from 'kysely'
-import {
-  AppBskyNotificationDeclaration,
-  ChatBskyActorDeclaration,
-} from '@atproto/api'
 import { keyBy } from '@atproto/common'
-import { parseRecordBytes } from '../../../hydration/util'
+import { parseJsonBytes } from '../../../hydration/util'
+import { app, chat } from '../../../lexicons/index.js'
 import { Service } from '../../../proto/bsky_connect'
 import { VerificationMeta } from '../../../proto/bsky_pb'
 import { Database } from '../db'
@@ -96,7 +93,8 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
 
       const status = statuses.records[i]
 
-      const chatDeclaration = parseRecordBytes<ChatBskyActorDeclaration.Record>(
+      const chatDeclaration = parseJsonBytes(
+        chat.bsky.actor.declaration.main,
         chatDeclarations.records[i].record,
       )
 
@@ -115,7 +113,8 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
       const ageAssuranceForDids = new Set(returnAgeAssuranceForDids)
 
       const activitySubscription = () => {
-        const record = parseRecordBytes<AppBskyNotificationDeclaration.Record>(
+        const record = parseJsonBytes(
+          app.bsky.notification.declaration.main,
           notifDeclarations.records[i].record,
         )
 

package/src/data-plane/server/routes/records.ts

@@ -2,40 +2,42 @@ import { Timestamp } from '@bufbuild/protobuf'
 import { ServiceImpl } from '@connectrpc/connect'
 import * as ui8 from 'uint8arrays'
 import { keyBy } from '@atproto/common'
+import { l } from '@atproto/lex'
 import { AtUri } from '@atproto/syntax'
-import { ids } from '../../../lexicon/lexicons'
+import { app, chat, com } from '../../../lexicons/index.js'
 import { Service } from '../../../proto/bsky_connect'
 import { PostRecordMeta, Record } from '../../../proto/bsky_pb'
 import { Database } from '../db'
 
 export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
-  getBlockRecords: getRecords(db, ids.AppBskyGraphBlock),
-  getFeedGeneratorRecords: getRecords(db, ids.AppBskyFeedGenerator),
-  getFollowRecords: getRecords(db, ids.AppBskyGraphFollow),
-  getLikeRecords: getRecords(db, ids.AppBskyFeedLike),
-  getListBlockRecords: getRecords(db, ids.AppBskyGraphListblock),
-  getListItemRecords: getRecords(db, ids.AppBskyGraphListitem),
-  getListRecords: getRecords(db, ids.AppBskyGraphList),
+  getBlockRecords: getRecords(db, app.bsky.graph.block),
+  getFeedGeneratorRecords: getRecords(db, app.bsky.feed.generator),
+  getFollowRecords: getRecords(db, app.bsky.graph.follow),
+  getLikeRecords: getRecords(db, app.bsky.feed.like),
+  getListBlockRecords: getRecords(db, app.bsky.graph.listblock),
+  getListItemRecords: getRecords(db, app.bsky.graph.listitem),
+  getListRecords: getRecords(db, app.bsky.graph.list),
   getPostRecords: getPostRecords(db),
-  getProfileRecords: getRecords(db, ids.AppBskyActorProfile),
-  getRepostRecords: getRecords(db, ids.AppBskyFeedRepost),
-  getThreadGateRecords: getRecords(db, ids.AppBskyFeedThreadgate),
-  getPostgateRecords: getRecords(db, ids.AppBskyFeedPostgate),
-  getLabelerRecords: getRecords(db, ids.AppBskyLabelerService),
-  getActorChatDeclarationRecords: getRecords(db, ids.ChatBskyActorDeclaration),
+  getProfileRecords: getRecords(db, app.bsky.actor.profile),
+  getRepostRecords: getRecords(db, app.bsky.feed.repost),
+  getThreadGateRecords: getRecords(db, app.bsky.feed.threadgate),
+  getPostgateRecords: getRecords(db, app.bsky.feed.postgate),
+  getLabelerRecords: getRecords(db, app.bsky.labeler.service),
+  getActorChatDeclarationRecords: getRecords(db, chat.bsky.actor.declaration),
   getNotificationDeclarationRecords: getRecords(
     db,
-    ids.AppBskyNotificationDeclaration,
+    app.bsky.notification.declaration,
   ),
-  getGermDeclarationRecords: getRecords(db, ids.ComGermnetworkDeclaration),
-  getStarterPackRecords: getRecords(db, ids.AppBskyGraphStarterpack),
-  getVerificationRecords: getRecords(db, ids.AppBskyGraphVerification),
-  getStatusRecords: getRecords(db, ids.AppBskyActorStatus),
+  getGermDeclarationRecords: getRecords(db, com.germnetwork.declaration),
+  getStarterPackRecords: getRecords(db, app.bsky.graph.starterpack),
+  getVerificationRecords: getRecords(db, app.bsky.graph.verification),
+  getStatusRecords: getRecords(db, app.bsky.actor.status),
 })
 
-export const getRecords =
-  (db: Database, collection?: string) =>
-  async (req: { uris: string[] }): Promise<{ records: Record[] }> => {
+export const getRecords = (db: Database, ns?: l.Main<l.RecordSchema>) => {
+  const collection = ns ? l.getMain(ns).$type : undefined
+
+  return async (req: { uris: string[] }): Promise<{ records: Record[] }> => {
     const validUris = collection
       ? req.uris.filter((uri) => new AtUri(uri).collection === collection)
       : req.uris
@@ -71,9 +73,10 @@ export const getRecords =
     })
     return { records }
   }
+}
 
 export const getPostRecords = (db: Database) => {
-  const getBaseRecords = getRecords(db, ids.AppBskyFeedPost)
+  const getBaseRecords = getRecords(db, app.bsky.feed.post)
   return async (req: {
     uris: string[]
   }): Promise<{ records: Record[]; meta: PostRecordMeta[] }> => {

package/src/data-plane/server/util.ts

@@ -1,9 +1,5 @@
 import { sql } from 'kysely'
-import {
-  Record as PostRecord,
-  ReplyRef,
-} from '../../lexicon/types/app/bsky/feed/post'
-import { Record as GateRecord } from '../../lexicon/types/app/bsky/feed/threadgate'
+import { GateRecord, PostRecord, PostReplyRef } from '../../views/types'
 import { parseThreadGate } from '../../views/util'
 import { DatabaseSchema } from './db/database-schema'
 import { valuesList } from './db/util'
@@ -72,7 +68,7 @@ export const getAncestorsAndSelfQb = (
 }
 
 export const invalidReplyRoot = (
-  reply: ReplyRef,
+  reply: PostReplyRef,
   parent: {
     record: PostRecord
     invalidReplyRoot: boolean | null

package/src/feature-gates/README.md

@@ -5,43 +5,79 @@ evaluation and experiment tracking.
 
 ## Usage
 
-Call `checkGates` at the **top of each request handler** to evaluate feature
-gates for the current user. This ensures consistent targeting throughout the
-request lifecycle.
+Feature gates are accessible on `HydrationCtx` as `features`. A default "scope"
+is defined in `Hydrator.createContext`, which is called by every request
+handler. The default scope supplies anonymous `deviceId` and `sessionId`
+identifiers for targeting unauthenticated users.
 
-> [!NOTE]
-> Only pass in the gates you wish to check for this endpoint. Passing in more
-> will result in extraneous calls to our exposures endpoint, which could skew
-> experiment results in unexpected ways.
+Feature gates can be checked via the following methods.
+
+```typescript
+// check a single gate
+const enabled = ctx.features.checkGate(
+  ctx.features.Gate.ThreadsReplyRankingExplorationEnable,
+)
+
+// check multiple gates
+const gates = ctx.features.checkGates([
+  ctx.features.Gate.ThreadsReplyRankingExplorationEnable,
+  ctx.features.Gate.SomeOtherGate,
+])
+const enabled = gates.get(
+  ctx.features.Gate.ThreadsReplyRankingExplorationEnable,
+)
+```
+
+### User Context
+
+To accurately gate features by user, we need additional context about that user.
+For most use cases, we get this data from within the request handlers.
+
+Here, the `features` client will be scoped to the current user, allowing for
+accurate gate checks throughout the request lifecycle.
+
+```typescript
+const features: ScopedFeatureGatesClient = ctx.featureGatesClient.scope(
+  ctx.featureGatesClient.parseUserContextFromHandler({
+    viewer,
+    req,
+  }),
+)
 
-```ts
 const hydrateCtx = await ctx.hydrator.createContext({
-  // ...
-  featureGatesMap: ctx.featureGatesClient.checkGates(
-    ['threads:reply_ranking_exploration:enable'],
-    { viewer, req },
-  ),
+  labelers,
+  viewer,
+  features,
 })
 ```
 
-The returned `CheckedFeatureGatesMap` can then be passed through context and
-accessed wherever needed.
+> [!NOTE]
+> Although `ctx.featureGatesClient` also has a `checkGates` method, the
+> intention is to use the `ScopedFeatureGatesClient` returned by `scope()` for
+> gate checks within the application.
 
-## User Identification
+You can also pass the user context directly to `checkGate` or `checkGates`. This
+overrides any default scope set on the client, allowing for flexibility in cases
+where user context is only available at the point of gate evaluation.
 
-If the user is authenticated, we use their DID as the identifier for feature
-targeting via the `viewer` param of the `checkGates` call.
+```typescript
+const enabled = ctx.featureGatesClient.checkGate(
+  ctx.featureGatesClient.Gate.ImageFeatureEnabled,
+  { did: imageAuthor.did },
+)
+```
 
-For unauthenticated users, and for experiments that don't require DID-level
-targeting, we rely on identifiers passed from the client as headers:
+### Adding Gates
 
-- `X-Bsky-Device-Id` - persistent device/client identifier
-- `X-Bsky-Session-Id` - current session identifier
+See `gates.ts` and add them to the enum. You can optionally prevent metrics from
+being emitted for a gate by adding the gate to the `IGNORE_METRICS_FOR_GATES`
+set.
 
-> [!WARNING]
-> If both `stableId` and `did` are missing, all gates return `false`. This
-> prevents untargeted users from being enrolled in experiments.
+## Metrics
 
-## Adding New Gates
+Check out the Growthbook docs for more info here. Basically, every feature eval
+fires the `onFeatureUsage` callback. Any feature that is part of an experiment
+_will also fire the `trackingCallback` callback._
 
-Add new gate IDs to the `FeatureGate` type in `gates.ts`.
+For some use cases, this can be noisy and/or performance intensive, so make use
+of `IGNORE_METRICS_FOR_GATES` to silence metrics for specific gates.

package/src/feature-gates/gates.ts

@@ -1,10 +1,24 @@
 /**
- * ADD ALL FEATURE GATES HERE.
+ * Enum of all gates in the system. This should be the single source of truth
+ * for all gates, and should be used in all places where gates are checked or
+ * defined.
  */
+export enum Gate {
+  SuggestedUsersDiscoverEnable = 'suggested_users:discover_agent:enable',
+  SuggestedUsersSocialProofEnable = 'suggested_users:social_proof:enable',
+  ThreadsReplyRankingExplorationEnable = 'threads:reply_ranking_exploration:enable',
+  SearchFilteringExplorationEnable = 'search:filtering_exploration:enable',
+  SuggestedUsersForExploreEnable = 'suggested_users:for_explore:enable',
+  SuggestedUsersForDiscoverEnable = 'suggested_users:for_discover:enable',
+  SuggestedUsersForSeeMoreEnable = 'suggested_users:for_see_more:enable',
 
-export type FeatureGate =
-  | 'suggested_users:discover_agent:enable'
-  | 'suggested_users:social_proof:enable'
-  | 'suggested_onboarding_users:discover_agent:enable'
-  | 'threads:reply_ranking_exploration:enable'
-  | 'search:filtering_exploration:enable'
+  // temp
+  AATest = 'aa-test-appview',
+}
+
+/**
+ * Set of gates that should be ignored when tracking gate evaluations for
+ * analytics purposes. This is useful for gates that are not user-facing or are
+ * overly noisy.
+ */
+export const IGNORE_METRICS_FOR_GATES: Set<Gate> = new Set([])