@atproto/bsky 0.0.76 → 0.0.78

package/src/data-plane/server/db/migrations/20240723T220703655Z-quotes.ts

@@ -0,0 +1,28 @@
+import { Kysely, sql } from 'kysely'
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .createTable('quote')
+    .addColumn('uri', 'varchar', (col) => col.primaryKey())
+    .addColumn('cid', 'varchar', (col) => col.notNull())
+    .addColumn('subject', 'varchar', (col) => col.notNull())
+    .addColumn('subjectCid', 'varchar', (col) => col.notNull())
+    .addColumn('createdAt', 'varchar', (col) => col.notNull())
+    .addColumn('indexedAt', 'varchar', (col) => col.notNull())
+    .addColumn('sortAt', 'varchar', (col) =>
+      col
+        .generatedAlwaysAs(sql`least("createdAt", "indexedAt")`)
+        .stored()
+        .notNull(),
+    )
+    .execute()
+  await db.schema
+    .createIndex('quote_subject_cursor_idx')
+    .on('quote')
+    .columns(['subject', 'sortAt', 'cid'])
+    .execute()
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema.dropTable('quote').execute()
+}

package/src/data-plane/server/db/migrations/20240801T193939827Z-post-gate.ts

@@ -0,0 +1,17 @@
+import { Kysely } from 'kysely'
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .createTable('post_gate')
+    .addColumn('uri', 'varchar', (col) => col.primaryKey())
+    .addColumn('cid', 'varchar', (col) => col.notNull())
+    .addColumn('creator', 'varchar', (col) => col.notNull())
+    .addColumn('postUri', 'varchar', (col) => col.notNull().unique())
+    .addColumn('createdAt', 'varchar', (col) => col.notNull())
+    .addColumn('indexedAt', 'varchar', (col) => col.notNull())
+    .execute()
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema.dropTable('post_gate').execute()
+}

package/src/data-plane/server/db/migrations/20240808T224251220Z-post-gate-flags.ts

@@ -0,0 +1,25 @@
+import { Kysely } from 'kysely'
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .alterTable('post')
+    .addColumn('violatesEmbeddingRules', 'boolean')
+    .execute()
+  await db.schema
+    .alterTable('post')
+    .addColumn('hasThreadGate', 'boolean')
+    .execute()
+  await db.schema
+    .alterTable('post')
+    .addColumn('hasPostGate', 'boolean')
+    .execute()
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .alterTable('post')
+    .dropColumn('violatesEmbeddingRules')
+    .execute()
+  await db.schema.alterTable('post').dropColumn('hasThreadGate').execute()
+  await db.schema.alterTable('post').dropColumn('hasPostGate').execute()
+}

package/src/data-plane/server/db/migrations/index.ts

@@ -38,3 +38,7 @@ export * as _20240530T170337073Z from './20240530T170337073Z-account-deactivatio
 export * as _20240606T171229898Z from './20240606T171229898Z-thread-mutes'
 export * as _20240606T222548219Z from './20240606T222548219Z-starter-packs'
 export * as _20240719T203853939Z from './20240719T203853939Z-priority-notifs'
+export * as _20240723T220700077Z from './20240723T220700077Z-quotes-post-aggs'
+export * as _20240723T220703655Z from './20240723T220703655Z-quotes'
+export * as _20240801T193939827Z from './20240801T193939827Z-post-gate'
+export * as _20240808T224251220Z from './20240808T224251220Z-post-gate-flags'

package/src/data-plane/server/db/tables/post-agg.ts

@@ -7,6 +7,7 @@ export interface PostAgg {
   likeCount: Generated<number>
   replyCount: Generated<number>
   repostCount: Generated<number>
+  quoteCount: Generated<number>
 }
 
 export type PartialDB = {

package/src/data-plane/server/db/tables/post-gate.ts

@@ -0,0 +1,12 @@
+const tableName = 'post_gate'
+
+export interface Postgate {
+  uri: string
+  cid: string
+  creator: string
+  postUri: string
+  createdAt: string
+  indexedAt: string
+}
+
+export type PartialDB = { [tableName]: Postgate }

package/src/data-plane/server/db/tables/post.ts

@@ -15,6 +15,9 @@ export interface Post {
   tags: string[] | null
   invalidReplyRoot: boolean | null
   violatesThreadGate: boolean | null
+  violatesEmbeddingRules: boolean | null
+  hasThreadGate: boolean | null
+  hasPostGate: boolean | null
   createdAt: string
   indexedAt: string
   sortAt: GeneratedAlways<string>

package/src/data-plane/server/db/tables/quote.ts

@@ -0,0 +1,15 @@
+import { GeneratedAlways } from 'kysely'
+
+const tableName = 'quote'
+
+export interface Quote {
+  uri: string
+  cid: string
+  subject: string
+  subjectCid: string
+  createdAt: string
+  indexedAt: string
+  sortAt: GeneratedAlways<string>
+}
+
+export type PartialDB = { [tableName]: Quote }

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

@@ -17,6 +17,7 @@ import { Database } from '../db'
 import { Actor } from '../db/tables/actor'
 import * as Post from './plugins/post'
 import * as Threadgate from './plugins/thread-gate'
+import * as Postgate from './plugins/post-gate'
 import * as Like from './plugins/like'
 import * as Repost from './plugins/repost'
 import * as Follow from './plugins/follow'
@@ -38,6 +39,7 @@ export class IndexingService {
   records: {
     post: Post.PluginType
     threadGate: Threadgate.PluginType
+    postGate: Postgate.PluginType
     like: Like.PluginType
     repost: Repost.PluginType
     follow: Follow.PluginType
@@ -60,6 +62,7 @@ export class IndexingService {
     this.records = {
       post: Post.makePlugin(this.db, this.background),
       threadGate: Threadgate.makePlugin(this.db, this.background),
+      postGate: Postgate.makePlugin(this.db, this.background),
       like: Like.makePlugin(this.db, this.background),
       repost: Repost.makePlugin(this.db, this.background),
       follow: Follow.makePlugin(this.db, this.background),
@@ -365,6 +368,10 @@ export class IndexingService {
       .deleteFrom('thread_gate')
       .where('creator', '=', did)
       .execute()
+    await this.db.db
+      .deleteFrom('post_gate')
+      .where('creator', '=', did)
+      .execute()
     // notifications
     await this.db.db
       .deleteFrom('notification')

package/src/data-plane/server/indexing/plugins/post-gate.ts

@@ -0,0 +1,104 @@
+import { AtUri, normalizeDatetimeAlways } from '@atproto/syntax'
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { CID } from 'multiformats/cid'
+import * as Postgate from '../../../../lexicon/types/app/bsky/feed/postgate'
+import * as lex from '../../../../lexicon/lexicons'
+import { DatabaseSchema, DatabaseSchemaType } from '../../db/database-schema'
+import { Database } from '../../db'
+import RecordProcessor from '../processor'
+import { BackgroundQueue } from '../../background'
+
+const lexId = lex.ids.AppBskyFeedPostgate
+type IndexedGate = DatabaseSchemaType['post_gate']
+
+const insertFn = async (
+  db: DatabaseSchema,
+  uri: AtUri,
+  cid: CID,
+  obj: Postgate.Record,
+  timestamp: string,
+): Promise<IndexedGate | null> => {
+  const postUri = new AtUri(obj.post)
+  if (postUri.host !== uri.host || postUri.rkey !== uri.rkey) {
+    throw new InvalidRequestError(
+      'Creator and rkey of post gate does not match its post',
+    )
+  }
+  const inserted = await db
+    .insertInto('post_gate')
+    .values({
+      uri: uri.toString(),
+      cid: cid.toString(),
+      creator: uri.host,
+      postUri: obj.post,
+      createdAt: normalizeDatetimeAlways(obj.createdAt),
+      indexedAt: timestamp,
+    })
+    .onConflict((oc) => oc.doNothing())
+    .returningAll()
+    .executeTakeFirst()
+  await db
+    .updateTable('post')
+    .where('uri', '=', postUri.toString())
+    .set({ hasPostGate: true })
+    .executeTakeFirst()
+  return inserted || null
+}
+
+const findDuplicate = async (
+  db: DatabaseSchema,
+  _uri: AtUri,
+  obj: Postgate.Record,
+): Promise<AtUri | null> => {
+  const found = await db
+    .selectFrom('post_gate')
+    .where('postUri', '=', obj.post)
+    .selectAll()
+    .executeTakeFirst()
+  return found ? new AtUri(found.uri) : null
+}
+
+const notifsForInsert = () => {
+  return []
+}
+
+const deleteFn = async (
+  db: DatabaseSchema,
+  uri: AtUri,
+): Promise<IndexedGate | null> => {
+  const deleted = await db
+    .deleteFrom('post_gate')
+    .where('uri', '=', uri.toString())
+    .returningAll()
+    .executeTakeFirst()
+  if (deleted) {
+    await db
+      .updateTable('post')
+      .where('uri', '=', deleted.postUri)
+      .set({ hasPostGate: false })
+      .executeTakeFirst()
+  }
+  return deleted || null
+}
+
+const notifsForDelete = () => {
+  return { notifs: [], toDelete: [] }
+}
+
+export type PluginType = RecordProcessor<Postgate.Record, IndexedGate>
+
+export const makePlugin = (
+  db: Database,
+  background: BackgroundQueue,
+): PluginType => {
+  return new RecordProcessor(db, background, {
+    lexId,
+    insertFn,
+    findDuplicate,
+    deleteFn,
+    notifsForInsert,
+    notifsForDelete,
+  })
+}
+
+export default makePlugin

package/src/data-plane/server/indexing/plugins/post.ts

@@ -7,6 +7,7 @@ import {
   ReplyRef,
 } from '../../../../lexicon/types/app/bsky/feed/post'
 import { Record as GateRecord } from '../../../../lexicon/types/app/bsky/feed/threadgate'
+import { Record as PostgateRecord } from '../../../../lexicon/types/app/bsky/feed/postgate'
 import { isMain as isEmbedImage } from '../../../../lexicon/types/app/bsky/embed/images'
 import { isMain as isEmbedExternal } from '../../../../lexicon/types/app/bsky/embed/external'
 import { isMain as isEmbedRecord } from '../../../../lexicon/types/app/bsky/embed/record'
@@ -26,9 +27,14 @@ import {
   getDescendentsQb,
   invalidReplyRoot as checkInvalidReplyRoot,
   violatesThreadGate as checkViolatesThreadGate,
-  postToThreadgateUri,
 } from '../../util'
 import { BackgroundQueue } from '../../background'
+import { parsePostgate } from '../../../../views/util'
+import {
+  postUriToThreadgateUri,
+  postUriToPostgateUri,
+  uriToDid,
+} from '../../../../util/uris'
 
 type Notif = Insertable<Notification>
 type Post = Selectable<DatabaseSchemaType['post']>
@@ -52,6 +58,7 @@ type IndexedPost = {
   embeds?: (PostEmbedImage[] | PostEmbedExternal | PostEmbedRecord)[]
   ancestors?: PostAncestor[]
   descendents?: PostDescendent[]
+  threadgate?: GateRecord
 }
 
 const lexId = lex.ids.AppBskyFeedPost
@@ -168,6 +175,7 @@ const insertFn = async (
       await db.insertInto('post_embed_external').values(externalEmbed).execute()
     } else if (isEmbedRecord(postEmbed)) {
       const { record } = postEmbed
+      const embedUri = new AtUri(record.uri)
       const recordEmbed = {
         postUri: uri.toString(),
         embedUri: record.uri,
@@ -175,9 +183,59 @@ const insertFn = async (
       }
       embeds.push(recordEmbed)
       await db.insertInto('post_embed_record').values(recordEmbed).execute()
+
+      if (embedUri.collection === lex.ids.AppBskyFeedPost) {
+        const quote = {
+          uri: uri.toString(),
+          cid: cid.toString(),
+          subject: record.uri,
+          subjectCid: record.cid,
+          createdAt: normalizeDatetimeAlways(obj.createdAt),
+          indexedAt: timestamp,
+        }
+        await db
+          .insertInto('quote')
+          .values(quote)
+          .onConflict((oc) => oc.doNothing())
+          .returningAll()
+          .executeTakeFirst()
+
+        const quoteCountQb = db
+          .insertInto('post_agg')
+          .values({
+            uri: record.uri.toString(),
+            quoteCount: db
+              .selectFrom('quote')
+              .where('quote.subjectCid', '=', record.cid.toString())
+              .select(countAll.as('count')),
+          })
+          .onConflict((oc) =>
+            oc
+              .column('uri')
+              .doUpdateSet({ quoteCount: excluded(db, 'quoteCount') }),
+          )
+        await quoteCountQb.execute()
+
+        const { violatesEmbeddingRules } = await validatePostEmbed(
+          db,
+          embedUri.toString(),
+          uri.toString(),
+        )
+        Object.assign(insertedPost, {
+          violatesEmbeddingRules: violatesEmbeddingRules,
+        })
+        if (violatesEmbeddingRules) {
+          await db
+            .updateTable('post')
+            .where('uri', '=', insertedPost.uri)
+            .set({ violatesEmbeddingRules: violatesEmbeddingRules })
+            .executeTakeFirst()
+        }
+      }
     }
   }
 
+  const threadgate = await getThreadgateRecord(db, post.replyRoot || post.uri)
   const ancestors = await getAncestorsAndSelfQb(db, {
     uri: post.uri,
     parentHeight: REPLY_NOTIF_DEPTH,
@@ -200,6 +258,7 @@ const insertFn = async (
     embeds,
     ancestors,
     descendents,
+    threadgate,
   }
 }
 
@@ -228,19 +287,22 @@ const notifsForInsert = (obj: IndexedPost) => {
       })
     }
   }
-  for (const embed of obj.embeds ?? []) {
-    if ('embedUri' in embed) {
-      const embedUri = new AtUri(embed.embedUri)
-      if (embedUri.collection === lex.ids.AppBskyFeedPost) {
-        maybeNotify({
-          did: embedUri.host,
-          reason: 'quote',
-          reasonSubject: embedUri.toString(),
-          author: obj.post.creator,
-          recordUri: obj.post.uri,
-          recordCid: obj.post.cid,
-          sortAt: obj.post.sortAt,
-        })
+
+  if (!obj.post.violatesEmbeddingRules) {
+    for (const embed of obj.embeds ?? []) {
+      if ('embedUri' in embed) {
+        const embedUri = new AtUri(embed.embedUri)
+        if (embedUri.collection === lex.ids.AppBskyFeedPost) {
+          maybeNotify({
+            did: embedUri.host,
+            reason: 'quote',
+            reasonSubject: embedUri.toString(),
+            author: obj.post.creator,
+            recordUri: obj.post.uri,
+            recordCid: obj.post.cid,
+            sortAt: obj.post.sortAt,
+          })
+        }
       }
     }
   }
@@ -250,6 +312,8 @@ const notifsForInsert = (obj: IndexedPost) => {
     return notifs
   }
 
+  const threadgateHiddenReplies = obj.threadgate?.hiddenReplies || []
+
   // reply notifications
 
   for (const ancestor of obj.ancestors ?? []) {
@@ -265,6 +329,8 @@ const notifsForInsert = (obj: IndexedPost) => {
         recordCid: obj.post.cid,
         sortAt: obj.post.sortAt,
       })
+      // found hidden reply, don't notify any higher ancestors
+      if (threadgateHiddenReplies.includes(ancestorUri.toString())) break
     }
   }
 
@@ -304,6 +370,7 @@ const deleteFn = async (
       .executeTakeFirst(),
     db.deleteFrom('feed_item').where('postUri', '=', uriStr).executeTakeFirst(),
   ])
+  await db.deleteFrom('quote').where('subject', '=', uriStr).execute()
   const deletedEmbeds: (
     | PostEmbedImage[]
     | PostEmbedExternal
@@ -333,7 +400,27 @@ const deleteFn = async (
     deletedEmbeds.push(deletedExternals)
   }
   if (deletedPosts) {
+    const embedUri = new AtUri(deletedPosts.embedUri)
     deletedEmbeds.push(deletedPosts)
+
+    if (embedUri.collection === lex.ids.AppBskyFeedPost) {
+      await db.deleteFrom('quote').where('uri', '=', uriStr).execute()
+      await db
+        .insertInto('post_agg')
+        .values({
+          uri: deletedPosts.embedUri,
+          quoteCount: db
+            .selectFrom('quote')
+            .where('quote.subjectCid', '=', deletedPosts.embedCid.toString())
+            .select(countAll.as('count')),
+        })
+        .onConflict((oc) =>
+          oc
+            .column('uri')
+            .doUpdateSet({ quoteCount: excluded(db, 'quoteCount') }),
+        )
+        .execute()
+    }
   }
   return deleted
     ? {
@@ -434,7 +521,7 @@ async function validateReply(
   const violatesThreadGate = await checkViolatesThreadGate(
     db,
     creator,
-    new AtUri(reply.root.uri).hostname,
+    uriToDid(reply.root.uri),
     replyRefs.root?.record ?? null,
     replyRefs.gate?.record ?? null,
   )
@@ -444,10 +531,58 @@ async function validateReply(
   }
 }
 
+async function getThreadgateRecord(db: DatabaseSchema, postUri: string) {
+  const threadgateRecordUri = postUriToThreadgateUri(postUri)
+  const results = await db
+    .selectFrom('record')
+    .where('record.uri', '=', threadgateRecordUri)
+    .selectAll()
+    .execute()
+  const threadgateRecord = results.find(
+    (ref) => ref.uri === threadgateRecordUri,
+  )
+  if (threadgateRecord) {
+    return jsonStringToLex(threadgateRecord.json) as GateRecord
+  }
+}
+
+async function validatePostEmbed(
+  db: DatabaseSchema,
+  embedUri: string,
+  parentUri: string,
+) {
+  const postgateRecordUri = postUriToPostgateUri(embedUri)
+  const postgateRecord = await db
+    .selectFrom('record')
+    .where('record.uri', '=', postgateRecordUri)
+    .selectAll()
+    .executeTakeFirst()
+  if (!postgateRecord) {
+    return {
+      violatesEmbeddingRules: false,
+    }
+  }
+  const {
+    embeddingRules: { canEmbed },
+  } = parsePostgate({
+    gate: jsonStringToLex(postgateRecord.json) as PostgateRecord,
+    viewerDid: uriToDid(parentUri),
+    authorDid: uriToDid(embedUri),
+  })
+  if (canEmbed) {
+    return {
+      violatesEmbeddingRules: false,
+    }
+  }
+  return {
+    violatesEmbeddingRules: true,
+  }
+}
+
 async function getReplyRefs(db: DatabaseSchema, reply: ReplyRef) {
   const replyRoot = reply.root.uri
   const replyParent = reply.parent.uri
-  const replyGate = postToThreadgateUri(replyRoot)
+  const replyGate = postUriToThreadgateUri(replyRoot)
   const results = await db
     .selectFrom('record')
     .where('record.uri', 'in', [replyRoot, replyGate, replyParent])

package/src/data-plane/server/indexing/plugins/thread-gate.ts

@@ -37,6 +37,11 @@ const insertFn = async (
     .onConflict((oc) => oc.doNothing())
     .returningAll()
     .executeTakeFirst()
+  await db
+    .updateTable('post')
+    .where('uri', '=', postUri.toString())
+    .set({ hasThreadGate: true })
+    .executeTakeFirst()
   return inserted || null
 }
 
@@ -66,6 +71,13 @@ const deleteFn = async (
     .where('uri', '=', uri.toString())
     .returningAll()
     .executeTakeFirst()
+  if (deleted) {
+    await db
+      .updateTable('post')
+      .where('uri', '=', deleted.postUri)
+      .set({ hasThreadGate: false })
+      .executeTakeFirst()
+  }
   return deleted || null
 }
 

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

@@ -15,6 +15,7 @@ import mutes from './mutes'
 import notifs from './notifs'
 import posts from './posts'
 import profile from './profile'
+import quotes from './quotes'
 import records from './records'
 import relationships from './relationships'
 import reposts from './reposts'
@@ -42,6 +43,7 @@ export default (db: Database, idResolver: IdResolver) =>
       ...notifs(db),
       ...posts(db),
       ...profile(db),
+      ...quotes(db),
       ...records(db),
       ...relationships(db),
       ...reposts(db),

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

@@ -8,7 +8,7 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
   async getInteractionCounts(req) {
     const uris = req.refs.map((ref) => ref.uri)
     if (uris.length === 0) {
-      return { likes: [], replies: [], reposts: [] }
+      return { likes: [], replies: [], reposts: [], quotes: [] }
     }
     const res = await db.db
       .selectFrom('post_agg')
@@ -20,6 +20,7 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
       likes: uris.map((uri) => byUri[uri]?.likeCount ?? 0),
       replies: uris.map((uri) => byUri[uri]?.replyCount ?? 0),
       reposts: uris.map((uri) => byUri[uri]?.repostCount ?? 0),
+      quotes: uris.map((uri) => byUri[uri]?.quoteCount ?? 0),
     }
   },
   async getCountsForUsers(req) {

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

@@ -0,0 +1,32 @@
+import { ServiceImpl } from '@connectrpc/connect'
+import { Service } from '../../../proto/bsky_connect'
+import { Database } from '../db'
+import { paginate, TimeCidKeyset } from '../db/pagination'
+
+export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
+  async getQuotesBySubjectSorted(req) {
+    const { subject, cursor, limit } = req
+    const { ref } = db.db.dynamic
+
+    if (!subject?.uri) return { uris: [] }
+
+    let builder = db.db
+      .selectFrom('quote')
+      .where('quote.subject', '=', subject.uri)
+      .select(['quote.uri', 'quote.cid', 'quote.sortAt'])
+
+    const keyset = new TimeCidKeyset(ref('quote.sortAt'), ref('quote.cid'))
+    builder = paginate(builder, {
+      limit,
+      cursor,
+      keyset,
+    })
+
+    const quotes = await builder.execute()
+
+    return {
+      uris: quotes.map((q) => q.uri),
+      cursor: keyset.packFromResult(quotes),
+    }
+  },
+})

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

@@ -20,6 +20,7 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
   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),
   getStarterPackRecords: getRecords(db, ids.AppBskyGraphStarterpack),
@@ -74,7 +75,13 @@ export const getPostRecords = (db: Database) => {
         ? await db.db
             .selectFrom('post')
             .where('uri', 'in', req.uris)
-            .select(['uri', 'violatesThreadGate'])
+            .select([
+              'uri',
+              'violatesThreadGate',
+              'violatesEmbeddingRules',
+              'hasThreadGate',
+              'hasPostGate',
+            ])
             .execute()
         : [],
     ])
@@ -82,6 +89,9 @@ export const getPostRecords = (db: Database) => {
     const meta = req.uris.map((uri) => {
       return new PostRecordMeta({
         violatesThreadGate: !!byKey[uri]?.violatesThreadGate,
+        violatesEmbeddingRules: !!byKey[uri]?.violatesEmbeddingRules,
+        hasThreadGate: !!byKey[uri]?.hasThreadGate,
+        hasPostGate: !!byKey[uri]?.hasPostGate,
       })
     })
     return { records, meta }

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

@@ -1,6 +1,4 @@
 import { sql } from 'kysely'
-import { AtUri } from '@atproto/syntax'
-import { ids } from '../../lexicon/lexicons'
 import {
   Record as PostRecord,
   ReplyRef,
@@ -144,9 +142,3 @@ export const violatesThreadGate = async (
 
   return true
 }
-
-export const postToThreadgateUri = (postUri: string) => {
-  const gateUri = new AtUri(postUri)
-  gateUri.collection = ids.AppBskyFeedThreadgate
-  return gateUri.toString()
-}