@atproto/bsky 0.0.251 → 0.0.254

package/src/data-plane/server/indexing/plugins/feed-generator.ts

@@ -1,80 +0,0 @@
-import { Selectable } from 'kysely'
-import { Cid, getBlobCidString } 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 IndexedFeedGenerator = Selectable<DatabaseSchemaType['feed_generator']>
-
-const insertFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-  cid: Cid,
-  obj: app.bsky.feed.generator.Main,
-  timestamp: string,
-): Promise<IndexedFeedGenerator | null> => {
-  const inserted = await db
-    .insertInto('feed_generator')
-    .values({
-      uri: uri.toString(),
-      cid: cid.toString(),
-      creator: uri.host,
-      feedDid: obj.did,
-      displayName: obj.displayName,
-      description: obj.description,
-      descriptionFacets: obj.descriptionFacets
-        ? JSON.stringify(obj.descriptionFacets)
-        : undefined,
-      avatarCid: getBlobCidString(obj.avatar),
-      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<IndexedFeedGenerator | null> => {
-  const deleted = await db
-    .deleteFrom('feed_generator')
-    .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.feed.generator.main,
-    insertFn,
-    findDuplicate,
-    deleteFn,
-    notifsForInsert,
-    notifsForDelete,
-  })
-}
-
-export default makePlugin

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

@@ -1,132 +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 { countAll, excluded } from '../../db/util.js'
-import { RecordProcessor } from '../processor.js'
-
-type IndexedFollow = Selectable<DatabaseSchemaType['follow']>
-
-const insertFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-  cid: Cid,
-  obj: app.bsky.graph.follow.Main,
-  timestamp: string,
-): Promise<IndexedFollow | null> => {
-  const inserted = await db
-    .insertInto('follow')
-    .values({
-      uri: uri.toString(),
-      cid: cid.toString(),
-      creator: uri.host,
-      subjectDid: obj.subject,
-      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.follow.Main,
-): Promise<AtUri | null> => {
-  const found = await db
-    .selectFrom('follow')
-    .where('creator', '=', uri.host)
-    .where('subjectDid', '=', obj.subject)
-    .selectAll()
-    .executeTakeFirst()
-  return found ? new AtUri(found.uri) : null
-}
-
-const notifsForInsert = (obj: IndexedFollow) => {
-  return [
-    {
-      did: obj.subjectDid,
-      author: obj.creator,
-      recordUri: obj.uri,
-      recordCid: obj.cid,
-      reason: 'follow' as const,
-      reasonSubject: null,
-      sortAt: obj.sortAt,
-    },
-  ]
-}
-
-const deleteFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-): Promise<IndexedFollow | null> => {
-  const deleted = await db
-    .deleteFrom('follow')
-    .where('uri', '=', uri.toString())
-    .returningAll()
-    .executeTakeFirst()
-  return deleted || null
-}
-
-const notifsForDelete = (
-  deleted: IndexedFollow,
-  replacedBy: IndexedFollow | null,
-) => {
-  const toDelete = replacedBy ? [] : [deleted.uri]
-  return { notifs: [], toDelete }
-}
-
-const updateAggregates = async (db: DatabaseSchema, follow: IndexedFollow) => {
-  const followersCountQb = db
-    .insertInto('profile_agg')
-    .values({
-      did: follow.subjectDid,
-      followersCount: db
-        .selectFrom('follow')
-        .where('follow.subjectDid', '=', follow.subjectDid)
-        .select(countAll.as('count')),
-    })
-    .onConflict((oc) =>
-      oc.column('did').doUpdateSet({
-        followersCount: excluded(db, 'followersCount'),
-      }),
-    )
-  const followsCountQb = db
-    .insertInto('profile_agg')
-    .values({
-      did: follow.creator,
-      followsCount: db
-        .selectFrom('follow')
-        .where('follow.creator', '=', follow.creator)
-        .select(countAll.as('count')),
-    })
-    .onConflict((oc) =>
-      oc.column('did').doUpdateSet({
-        followsCount: excluded(db, 'followsCount'),
-      }),
-    )
-  await Promise.all([followersCountQb.execute(), followsCountQb.execute()])
-}
-
-export type PluginType = ReturnType<typeof makePlugin>
-export const makePlugin = (
-  db: Database,
-  background: BackgroundQueue<Database>,
-) => {
-  return new RecordProcessor(db, background, {
-    schema: app.bsky.graph.follow.main,
-    insertFn,
-    findDuplicate,
-    deleteFn,
-    notifsForInsert,
-    notifsForDelete,
-    updateAggregates,
-  })
-}
-
-export default makePlugin

package/src/data-plane/server/indexing/plugins/germ-declaration.ts

@@ -1,57 +0,0 @@
-import { Cid } from '@atproto/lex'
-import { AtUri } from '@atproto/syntax'
-import { com } 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: com.germnetwork.declaration.main,
-    insertFn,
-    findDuplicate,
-    deleteFn,
-    notifsForInsert,
-    notifsForDelete,
-  })
-}
-
-export default makePlugin

package/src/data-plane/server/indexing/plugins/labeler.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 IndexedLabeler = Selectable<DatabaseSchemaType['labeler']>
-
-const insertFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-  cid: Cid,
-  obj: app.bsky.labeler.service.Main,
-  timestamp: string,
-): Promise<IndexedLabeler | null> => {
-  if (uri.rkey !== 'self') return null
-  const inserted = await db
-    .insertInto('labeler')
-    .values({
-      uri: uri.toString(),
-      cid: cid.toString(),
-      creator: uri.host,
-      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<IndexedLabeler | null> => {
-  const deleted = await db
-    .deleteFrom('labeler')
-    .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.labeler.service.main,
-    insertFn,
-    findDuplicate,
-    deleteFn,
-    notifsForInsert,
-    notifsForDelete,
-  })
-}
-
-export default makePlugin

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

@@ -1,151 +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 IndexedLike = Selectable<DatabaseSchemaType['like']>
-
-const insertFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-  cid: Cid,
-  obj: app.bsky.feed.like.Main,
-  timestamp: string,
-): Promise<IndexedLike | null> => {
-  const inserted = await db
-    .insertInto('like')
-    .values({
-      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,
-    })
-    .onConflict((oc) => oc.doNothing())
-    .returningAll()
-    .executeTakeFirst()
-  return inserted || null
-}
-
-const findDuplicate = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-  obj: app.bsky.feed.like.Main,
-): Promise<AtUri | null> => {
-  const found = await db
-    .selectFrom('like')
-    .where('creator', '=', uri.host)
-    .where('subject', '=', obj.subject.uri)
-    .selectAll()
-    .executeTakeFirst()
-  return found ? new AtUri(found.uri) : null
-}
-
-const notifsForInsert = (obj: IndexedLike) => {
-  const subjectUri = new AtUri(obj.subject)
-  // prevent self-notifications
-  const isLikeFromSubjectUser = subjectUri.host === obj.creator
-  if (isLikeFromSubjectUser) {
-    return []
-  }
-
-  const notifs: Notif[] = [
-    // Notification to the author of the liked record.
-    {
-      did: subjectUri.host,
-      author: obj.creator,
-      recordUri: obj.uri,
-      recordCid: obj.cid,
-      reason: 'like' as const,
-      reasonSubject: subjectUri.toString(),
-      sortAt: obj.sortAt,
-    },
-  ]
-
-  if (obj.via) {
-    const viaUri = new AtUri(obj.via)
-    const isLikeFromViaSubjectUser = viaUri.host === obj.creator
-    // prevent self-notifications
-    if (!isLikeFromViaSubjectUser) {
-      notifs.push(
-        // Notification to the reposter via whose repost the like was made.
-        {
-          did: viaUri.host,
-          author: obj.creator,
-          recordUri: obj.uri,
-          recordCid: obj.cid,
-          reason: 'like-via-repost' as const,
-          reasonSubject: viaUri.toString(),
-          sortAt: obj.sortAt,
-        },
-      )
-    }
-  }
-
-  return notifs
-}
-
-const deleteFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-): Promise<IndexedLike | null> => {
-  const deleted = await db
-    .deleteFrom('like')
-    .where('uri', '=', uri.toString())
-    .returningAll()
-    .executeTakeFirst()
-  return deleted || null
-}
-
-const notifsForDelete = (
-  deleted: IndexedLike,
-  replacedBy: IndexedLike | null,
-) => {
-  const toDelete = replacedBy ? [] : [deleted.uri]
-  return { notifs: [], toDelete }
-}
-
-const updateAggregates = async (db: DatabaseSchema, like: IndexedLike) => {
-  const likeCountQb = db
-    .insertInto('post_agg')
-    .values({
-      uri: like.subject,
-      likeCount: db
-        .selectFrom('like')
-        .where('like.subject', '=', like.subject)
-        .select(countAll.as('count')),
-    })
-    .onConflict((oc) =>
-      oc.column('uri').doUpdateSet({ likeCount: excluded(db, 'likeCount') }),
-    )
-  await likeCountQb.execute()
-}
-
-export type PluginType = ReturnType<typeof makePlugin>
-export const makePlugin = (
-  db: Database,
-  background: BackgroundQueue<Database>,
-) => {
-  return new RecordProcessor(db, background, {
-    schema: app.bsky.feed.like.main,
-    insertFn,
-    findDuplicate,
-    deleteFn,
-    notifsForInsert,
-    notifsForDelete,
-    updateAggregates,
-  })
-}
-
-export default makePlugin

package/src/data-plane/server/indexing/plugins/list-block.ts

@@ -1,84 +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 IndexedListBlock = Selectable<DatabaseSchemaType['list_block']>
-
-const insertFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-  cid: Cid,
-  obj: app.bsky.graph.listblock.Main,
-  timestamp: string,
-): Promise<IndexedListBlock | null> => {
-  const inserted = await db
-    .insertInto('list_block')
-    .values({
-      uri: uri.toString(),
-      cid: cid.toString(),
-      creator: uri.host,
-      subjectUri: obj.subject,
-      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.listblock.Main,
-): Promise<AtUri | null> => {
-  const found = await db
-    .selectFrom('list_block')
-    .where('creator', '=', uri.host)
-    .where('subjectUri', '=', obj.subject)
-    .selectAll()
-    .executeTakeFirst()
-  return found ? new AtUri(found.uri) : null
-}
-
-const notifsForInsert = () => {
-  return []
-}
-
-const deleteFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-): Promise<IndexedListBlock | null> => {
-  const deleted = await db
-    .deleteFrom('list_block')
-    .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.listblock.main,
-    insertFn,
-    findDuplicate,
-    deleteFn,
-    notifsForInsert,
-    notifsForDelete,
-  })
-}
-
-export default makePlugin

package/src/data-plane/server/indexing/plugins/list-item.ts

@@ -1,92 +0,0 @@
-import { Selectable } from 'kysely'
-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 IndexedListItem = Selectable<DatabaseSchemaType['list_item']>
-
-const insertFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-  cid: Cid,
-  obj: app.bsky.graph.listitem.Main,
-  timestamp: string,
-): Promise<IndexedListItem | null> => {
-  const listUri = new AtUri(obj.list)
-  if (listUri.hostname !== uri.hostname) {
-    throw new InvalidRequestError(
-      'Creator of listitem does not match creator of list',
-    )
-  }
-  const inserted = await db
-    .insertInto('list_item')
-    .values({
-      uri: uri.toString(),
-      cid: cid.toString(),
-      creator: uri.host,
-      subjectDid: obj.subject,
-      listUri: obj.list,
-      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.listitem.Main,
-): Promise<AtUri | null> => {
-  const found = await db
-    .selectFrom('list_item')
-    .where('listUri', '=', obj.list)
-    .where('subjectDid', '=', obj.subject)
-    .selectAll()
-    .executeTakeFirst()
-  return found ? new AtUri(found.uri) : null
-}
-
-const notifsForInsert = () => {
-  return []
-}
-
-const deleteFn = async (
-  db: DatabaseSchema,
-  uri: AtUri,
-): Promise<IndexedListItem | null> => {
-  const deleted = await db
-    .deleteFrom('list_item')
-    .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.listitem.main,
-    insertFn,
-    findDuplicate,
-    deleteFn,
-    notifsForInsert,
-    notifsForDelete,
-  })
-}
-
-export default makePlugin