@atproto/bsky 0.0.250 → 0.0.253

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

@@ -1,90 +0,0 @@
-import { Cid, getBlobCidString } from '@atproto/lex'
-import { AtUri } from '@atproto/syntax'
-import { app } from '../../../../lexicons/index.js'
-import { BackgroundQueue } from '../../background.js'
-import { DatabaseSchema, DatabaseSchemaType } from '../../db/database-schema.js'
-import { Database } from '../../db/index.js'
-import { RecordProcessor } from '../processor.js'
-
-type IndexedProfile = DatabaseSchemaType['profile']
-
-const insertFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-  cid: Cid,
-  obj: app.bsky.actor.profile.Main,
-  timestamp: string,
-): Promise<IndexedProfile | null> => {
-  if (uri.rkey !== 'self') return null
-  const inserted = await db
-    .insertInto('profile')
-    .values({
-      uri: uri.toString(),
-      cid: cid.toString(),
-      creator: uri.host,
-      displayName: obj.displayName,
-      description: obj.description,
-      avatarCid: getBlobCidString(obj.avatar),
-      bannerCid: getBlobCidString(obj.banner),
-      joinedViaStarterPackUri: obj.joinedViaStarterPack?.uri,
-      createdAt: obj.createdAt ?? new Date().toISOString(),
-      indexedAt: timestamp,
-    })
-    .onConflict((oc) => oc.doNothing())
-    .returningAll()
-    .executeTakeFirst()
-  return inserted || null
-}
-
-const findDuplicate = async (): Promise<AtUri | null> => {
-  return null
-}
-
-const notifsForInsert = (obj: IndexedProfile) => {
-  if (!obj.joinedViaStarterPackUri) return []
-  const starterPackUri = new AtUri(obj.joinedViaStarterPackUri)
-  return [
-    {
-      did: starterPackUri.host,
-      author: obj.creator,
-      recordUri: obj.uri,
-      recordCid: obj.cid,
-      reason: 'starterpack-joined' as const,
-      reasonSubject: obj.joinedViaStarterPackUri,
-      sortAt: obj.indexedAt,
-    },
-  ]
-}
-
-const deleteFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-): Promise<IndexedProfile | null> => {
-  const deleted = await db
-    .deleteFrom('profile')
-    .where('uri', '=', uri.toString())
-    .returningAll()
-    .executeTakeFirst()
-  return deleted || null
-}
-
-const notifsForDelete = () => {
-  return { notifs: [], toDelete: [] }
-}
-
-export type PluginType = ReturnType<typeof makePlugin>
-export const makePlugin = (
-  db: Database,
-  background: BackgroundQueue<Database>,
-) => {
-  return new RecordProcessor(db, background, {
-    schema: app.bsky.actor.profile.main,
-    insertFn,
-    findDuplicate,
-    deleteFn,
-    notifsForInsert,
-    notifsForDelete,
-  })
-}
-
-export default makePlugin

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

@@ -1,176 +0,0 @@
-import { Insertable, Selectable } from 'kysely'
-import { Cid } from '@atproto/lex'
-import { AtUri, normalizeDatetimeAlways } from '@atproto/syntax'
-import { app } from '../../../../lexicons/index.js'
-import { BackgroundQueue } from '../../background.js'
-import { DatabaseSchema, DatabaseSchemaType } from '../../db/database-schema.js'
-import { Database } from '../../db/index.js'
-import { Notification } from '../../db/tables/notification.js'
-import { countAll, excluded } from '../../db/util.js'
-import { RecordProcessor } from '../processor.js'
-
-type Notif = Insertable<Notification>
-type IndexedRepost = Selectable<DatabaseSchemaType['repost']>
-
-const insertFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-  cid: Cid,
-  obj: app.bsky.feed.repost.Main,
-  timestamp: string,
-): Promise<IndexedRepost | null> => {
-  const repost = {
-    uri: uri.toString(),
-    cid: cid.toString(),
-    creator: uri.host,
-    subject: obj.subject.uri,
-    subjectCid: obj.subject.cid,
-    via: obj.via?.uri,
-    viaCid: obj.via?.cid,
-    createdAt: normalizeDatetimeAlways(obj.createdAt),
-    indexedAt: timestamp,
-  }
-  const [inserted] = await Promise.all([
-    db
-      .insertInto('repost')
-      .values(repost)
-      .onConflict((oc) => oc.doNothing())
-      .returningAll()
-      .executeTakeFirst(),
-    db
-      .insertInto('feed_item')
-      .values({
-        type: 'repost',
-        uri: repost.uri,
-        cid: repost.cid,
-        postUri: repost.subject,
-        originatorDid: repost.creator,
-        sortAt:
-          repost.indexedAt < repost.createdAt
-            ? repost.indexedAt
-            : repost.createdAt,
-      })
-      .onConflict((oc) => oc.doNothing())
-      .executeTakeFirst(),
-  ])
-
-  return inserted || null
-}
-
-const findDuplicate = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-  obj: app.bsky.feed.repost.Main,
-): Promise<AtUri | null> => {
-  const found = await db
-    .selectFrom('repost')
-    .where('creator', '=', uri.host)
-    .where('subject', '=', obj.subject.uri)
-    .selectAll()
-    .executeTakeFirst()
-  return found ? new AtUri(found.uri) : null
-}
-
-const notifsForInsert = (obj: IndexedRepost) => {
-  const subjectUri = new AtUri(obj.subject)
-  // prevent self-notifications
-  const isRepostFromSubjectUser = subjectUri.host === obj.creator
-  if (isRepostFromSubjectUser) {
-    return []
-  }
-
-  const notifs: Notif[] = [
-    // Notification to the author of the reposted record.
-    {
-      did: subjectUri.host,
-      author: obj.creator,
-      recordUri: obj.uri,
-      recordCid: obj.cid,
-      reason: 'repost' as const,
-      reasonSubject: subjectUri.toString(),
-      sortAt: obj.sortAt,
-    },
-  ]
-
-  if (obj.via) {
-    const viaUri = new AtUri(obj.via)
-    const isRepostFromViaSubjectUser = viaUri.host === obj.creator
-    // prevent self-notifications
-    if (!isRepostFromViaSubjectUser) {
-      notifs.push(
-        // Notification to the reposter via whose repost the repost was made.
-        {
-          did: viaUri.host,
-          author: obj.creator,
-          recordUri: obj.uri,
-          recordCid: obj.cid,
-          reason: 'repost-via-repost' as const,
-          reasonSubject: viaUri.toString(),
-          sortAt: obj.sortAt,
-        },
-      )
-    }
-  }
-
-  return notifs
-}
-
-const deleteFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-): Promise<IndexedRepost | null> => {
-  const uriStr = uri.toString()
-  const [deleted] = await Promise.all([
-    db
-      .deleteFrom('repost')
-      .where('uri', '=', uriStr)
-      .returningAll()
-      .executeTakeFirst(),
-    db.deleteFrom('feed_item').where('uri', '=', uriStr).executeTakeFirst(),
-  ])
-  return deleted || null
-}
-
-const notifsForDelete = (
-  deleted: IndexedRepost,
-  replacedBy: IndexedRepost | null,
-) => {
-  const toDelete = replacedBy ? [] : [deleted.uri]
-  return { notifs: [], toDelete }
-}
-
-const updateAggregates = async (db: DatabaseSchema, repost: IndexedRepost) => {
-  const repostCountQb = db
-    .insertInto('post_agg')
-    .values({
-      uri: repost.subject,
-      repostCount: db
-        .selectFrom('repost')
-        .where('repost.subject', '=', repost.subject)
-        .select(countAll.as('count')),
-    })
-    .onConflict((oc) =>
-      oc
-        .column('uri')
-        .doUpdateSet({ repostCount: excluded(db, 'repostCount') }),
-    )
-  await repostCountQb.execute()
-}
-
-export type PluginType = ReturnType<typeof makePlugin>
-export const makePlugin = (
-  db: Database,
-  background: BackgroundQueue<Database>,
-) => {
-  return new RecordProcessor(db, background, {
-    schema: app.bsky.feed.repost.main,
-    insertFn,
-    findDuplicate,
-    deleteFn,
-    notifsForInsert,
-    notifsForDelete,
-    updateAggregates,
-  })
-}
-
-export default makePlugin

package/src/data-plane/server/indexing/plugins/starter-pack.ts

@@ -1,74 +0,0 @@
-import { Selectable } from 'kysely'
-import { Cid } from '@atproto/lex'
-import { AtUri, normalizeDatetimeAlways } from '@atproto/syntax'
-import { app } from '../../../../lexicons/index.js'
-import { BackgroundQueue } from '../../background.js'
-import { DatabaseSchema, DatabaseSchemaType } from '../../db/database-schema.js'
-import { Database } from '../../db/index.js'
-import { RecordProcessor } from '../processor.js'
-
-type IndexedStarterPack = Selectable<DatabaseSchemaType['starter_pack']>
-
-const insertFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-  cid: Cid,
-  obj: app.bsky.graph.starterpack.Main,
-  timestamp: string,
-): Promise<IndexedStarterPack | null> => {
-  const inserted = await db
-    .insertInto('starter_pack')
-    .values({
-      uri: uri.toString(),
-      cid: cid.toString(),
-      creator: uri.host,
-      name: obj.name,
-      createdAt: normalizeDatetimeAlways(obj.createdAt),
-      indexedAt: timestamp,
-    })
-    .onConflict((oc) => oc.doNothing())
-    .returningAll()
-    .executeTakeFirst()
-  return inserted || null
-}
-
-const findDuplicate = async (): Promise<AtUri | null> => {
-  return null
-}
-
-const notifsForInsert = () => {
-  return []
-}
-
-const deleteFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-): Promise<IndexedStarterPack | null> => {
-  const deleted = await db
-    .deleteFrom('starter_pack')
-    .where('uri', '=', uri.toString())
-    .returningAll()
-    .executeTakeFirst()
-  return deleted || null
-}
-
-const notifsForDelete = () => {
-  return { notifs: [], toDelete: [] }
-}
-
-export type PluginType = ReturnType<typeof makePlugin>
-export const makePlugin = (
-  db: Database,
-  background: BackgroundQueue<Database>,
-) => {
-  return new RecordProcessor(db, background, {
-    schema: app.bsky.graph.starterpack.main,
-    insertFn,
-    findDuplicate,
-    deleteFn,
-    notifsForInsert,
-    notifsForDelete,
-  })
-}
-
-export default makePlugin

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

@@ -1,57 +0,0 @@
-import { Cid } from '@atproto/lex'
-import { AtUri } from '@atproto/syntax'
-import { app } from '../../../../lexicons/index.js'
-import { BackgroundQueue } from '../../background.js'
-import { DatabaseSchema } from '../../db/database-schema.js'
-import { Database } from '../../db/index.js'
-import { RecordProcessor } from '../processor.js'
-
-// @NOTE this indexer is a placeholder to ensure it gets indexed in the generic records table
-
-const insertFn = async (
-  _db: DatabaseSchema,
-  uri: AtUri,
-  _cid: Cid,
-  _obj: unknown,
-  _timestamp: string,
-): Promise<unknown | null> => {
-  if (uri.rkey !== 'self') return null
-  return true
-}
-
-const findDuplicate = async (): Promise<AtUri | null> => {
-  return null
-}
-
-const notifsForInsert = () => {
-  return []
-}
-
-const deleteFn = async (
-  _db: DatabaseSchema,
-  uri: AtUri,
-): Promise<unknown | null> => {
-  if (uri.rkey !== 'self') return null
-  return true
-}
-
-const notifsForDelete = () => {
-  return { notifs: [], toDelete: [] }
-}
-
-export type PluginType = ReturnType<typeof makePlugin>
-export const makePlugin = (
-  db: Database,
-  background: BackgroundQueue<Database>,
-) => {
-  return new RecordProcessor(db, background, {
-    schema: app.bsky.actor.status.main,
-    insertFn,
-    findDuplicate,
-    deleteFn,
-    notifsForInsert,
-    notifsForDelete,
-  })
-}
-
-export default makePlugin

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

@@ -1,101 +0,0 @@
-import { Cid } from '@atproto/lex'
-import { AtUri, normalizeDatetimeAlways } from '@atproto/syntax'
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { app } from '../../../../lexicons/index.js'
-import { BackgroundQueue } from '../../background.js'
-import { DatabaseSchema, DatabaseSchemaType } from '../../db/database-schema.js'
-import { Database } from '../../db/index.js'
-import { RecordProcessor } from '../processor.js'
-
-type IndexedGate = DatabaseSchemaType['thread_gate']
-
-const insertFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-  cid: Cid,
-  obj: app.bsky.feed.threadgate.Main,
-  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 thread gate does not match its post',
-    )
-  }
-  const inserted = await db
-    .insertInto('thread_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({ hasThreadGate: true })
-    .executeTakeFirst()
-  return inserted || null
-}
-
-const findDuplicate = async (
-  db: DatabaseSchema,
-  _uri: AtUri,
-  obj: app.bsky.feed.threadgate.Main,
-): Promise<AtUri | null> => {
-  const found = await db
-    .selectFrom('thread_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('thread_gate')
-    .where('uri', '=', uri.toString())
-    .returningAll()
-    .executeTakeFirst()
-  if (deleted) {
-    await db
-      .updateTable('post')
-      .where('uri', '=', deleted.postUri)
-      .set({ hasThreadGate: false })
-      .executeTakeFirst()
-  }
-  return deleted || null
-}
-
-const notifsForDelete = () => {
-  return { notifs: [], toDelete: [] }
-}
-
-export type PluginType = ReturnType<typeof makePlugin>
-export const makePlugin = (
-  db: Database,
-  background: BackgroundQueue<Database>,
-) => {
-  return new RecordProcessor(db, background, {
-    schema: app.bsky.feed.threadgate.main,
-    insertFn,
-    findDuplicate,
-    deleteFn,
-    notifsForInsert,
-    notifsForDelete,
-  })
-}
-
-export default makePlugin

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

@@ -1,113 +0,0 @@
-import { Selectable } from 'kysely'
-import { Cid } from '@atproto/lex'
-import { AtUri, normalizeDatetimeAlways } from '@atproto/syntax'
-import { app } from '../../../../lexicons/index.js'
-import { BackgroundQueue } from '../../background.js'
-import { DatabaseSchema, DatabaseSchemaType } from '../../db/database-schema.js'
-import { Database } from '../../db/index.js'
-import { RecordProcessor } from '../processor.js'
-
-type IndexedVerification = Selectable<DatabaseSchemaType['verification']>
-
-const insertFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-  cid: Cid,
-  obj: app.bsky.graph.verification.Main,
-  timestamp: string,
-): Promise<IndexedVerification | null> => {
-  const inserted = await db
-    .insertInto('verification')
-    .values({
-      uri: uri.toString(),
-      cid: cid.toString(),
-      rkey: uri.rkey,
-      creator: uri.host,
-      subject: obj.subject,
-      handle: obj.handle,
-      displayName: obj.displayName,
-      createdAt: normalizeDatetimeAlways(obj.createdAt),
-      indexedAt: timestamp,
-    })
-    .onConflict((oc) => oc.doNothing())
-    .returningAll()
-    .executeTakeFirst()
-  return inserted || null
-}
-
-const findDuplicate = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-  obj: app.bsky.graph.verification.Main,
-): Promise<AtUri | null> => {
-  const found = await db
-    .selectFrom('verification')
-    .where('subject', '=', obj.subject)
-    .where('creator', '=', uri.host)
-    .selectAll()
-    .executeTakeFirst()
-  return found ? new AtUri(found.uri) : null
-}
-
-const notifsForInsert = (obj: IndexedVerification) => {
-  return [
-    {
-      did: obj.subject,
-      author: obj.creator,
-      recordUri: obj.uri,
-      recordCid: obj.cid,
-      reason: 'verified' as const,
-      reasonSubject: null,
-      sortAt: obj.sortedAt,
-    },
-  ]
-}
-
-const deleteFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-): Promise<IndexedVerification | null> => {
-  const deleted = await db
-    .deleteFrom('verification')
-    .where('uri', '=', uri.toString())
-    .returningAll()
-    .executeTakeFirst()
-  return deleted || null
-}
-
-const notifsForDelete = (
-  deleted: IndexedVerification,
-  _replacedBy: IndexedVerification | null,
-) => {
-  return {
-    notifs: [
-      {
-        did: deleted.subject,
-        author: deleted.creator,
-        recordUri: deleted.uri,
-        recordCid: deleted.cid,
-        reason: 'unverified' as const,
-        reasonSubject: null,
-        sortAt: new Date().toISOString(),
-      },
-    ],
-    toDelete: [],
-  }
-}
-
-export type PluginType = ReturnType<typeof makePlugin>
-export const makePlugin = (
-  db: Database,
-  background: BackgroundQueue<Database>,
-) => {
-  return new RecordProcessor(db, background, {
-    schema: app.bsky.graph.verification.main,
-    insertFn,
-    findDuplicate,
-    deleteFn,
-    notifsForInsert,
-    notifsForDelete,
-  })
-}
-
-export default makePlugin