@atproto/ozone 0.2.8 → 0.2.11

package/src/jetstream/service.ts

@@ -1,107 +0,0 @@
-import { WebSocketKeepAlive } from '@atproto/ws-client'
-
-type JetstreamRecord = Record<string, unknown>
-type OnCreateCallback<T extends JetstreamRecord> = (
-  e: CommitCreateEvent<T>,
-) => Promise<void>
-
-export type JetstreamOptions = {
-  endpoint: string
-  /**
-   * The record collections that you want to receive updates for.
-   * Leave this empty to receive updates for all record collections.
-   */
-  wantedCollections?: string[]
-  /**
-   * The DIDs that you want to receive updates for.
-   * Leave this empty to receive updates for all DIDs.
-   */
-  wantedDids?: string[]
-
-  /**
-   * The Unix timestamp in microseconds that you want to receive updates from.
-   */
-  cursor?: number
-}
-export type EventBase = {
-  did: string
-  time_us: number
-  // @TODO: Limited to just commit events for now
-  kind: 'commit'
-}
-export type CommitBase = {
-  collection: string
-  rkey: string
-  cid: string
-}
-export interface CommitCreateEvent<RecordType extends JetstreamRecord>
-  extends EventBase {
-  kind: 'commit'
-  commit: {
-    operation: 'create'
-    record: RecordType
-  } & CommitBase
-}
-
-export interface CommitDeleteEvent extends EventBase {
-  kind: 'commit'
-  commit: {
-    operation: 'delete'
-  } & CommitBase
-}
-
-export class Jetstream {
-  public ws?: WebSocketKeepAlive
-  public url: URL
-  /** The current cursor. */
-  public cursor?: number
-
-  constructor(opts: JetstreamOptions) {
-    this.url = new URL(opts.endpoint)
-    opts.wantedCollections?.forEach((collection) => {
-      this.url.searchParams.append('wantedCollections', collection)
-    })
-    opts.wantedDids?.forEach((did) => {
-      this.url.searchParams.append('wantedDids', did)
-    })
-    if (opts.cursor) this.cursor = opts.cursor
-  }
-
-  async start(options: {
-    onCreate?: Record<string, OnCreateCallback<any>>
-    onDelete?: Record<string, (e: CommitDeleteEvent) => Promise<void>>
-  }) {
-    this.ws = new WebSocketKeepAlive({
-      getUrl: async () => {
-        if (this.cursor)
-          this.url.searchParams.set('cursor', this.cursor.toString())
-        return this.url.toString()
-      },
-    })
-
-    for await (const message of this.ws) {
-      const parsedMessage = JSON.parse(message.toString())
-      if (parsedMessage.kind === 'commit') {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars -- `record` is used via `typeof record` below
-        const { collection, operation, record } = parsedMessage.commit || {}
-
-        if (operation === 'create') {
-          options.onCreate?.[collection]?.(
-            parsedMessage as CommitCreateEvent<typeof record>,
-          )
-        } else if (operation === 'delete') {
-          options.onDelete?.[collection]?.(parsedMessage as CommitDeleteEvent)
-        }
-      }
-    }
-  }
-
-  /**
-   * Closes the WebSocket connection.
-   */
-  async close() {
-    // @TODO This should return a promise that fulfills when the connection is
-    // fully closed.
-    this.ws?.ws?.close()
-  }
-}

package/src/logger.ts

@@ -1,29 +0,0 @@
-import { type IncomingMessage } from 'node:http'
-import { pinoHttp, stdSerializers } from 'pino-http'
-import { obfuscateHeaders, subsystemLogger } from '@atproto/common'
-
-export const dbLogger: ReturnType<typeof subsystemLogger> =
-  subsystemLogger('ozone:db')
-export const seqLogger: ReturnType<typeof subsystemLogger> =
-  subsystemLogger('ozone:sequencer')
-export const httpLogger: ReturnType<typeof subsystemLogger> =
-  subsystemLogger('ozone')
-export const langLogger: ReturnType<typeof subsystemLogger> =
-  subsystemLogger('ozone:lang')
-export const verificationLogger: ReturnType<typeof subsystemLogger> =
-  subsystemLogger('ozone:verification')
-
-export const loggerMiddleware = pinoHttp({
-  logger: httpLogger,
-  serializers: {
-    err: (err: unknown) => ({
-      code: err?.['code'],
-      message: err?.['message'],
-    }),
-    req: (req: IncomingMessage) => {
-      const serialized = stdSerializers.req(req)
-      const headers = obfuscateHeaders(serialized.headers)
-      return { ...serialized, headers }
-    },
-  },
-})

package/src/mod-service/expiring-tags.ts

@@ -1,104 +0,0 @@
-import { Selectable } from 'kysely'
-import { Database } from '../db/index.js'
-import { ExpiringTag } from '../db/schema/expiring_tag.js'
-
-export type ExpiringTagRow = Selectable<ExpiringTag>
-
-export type ExpiringTagGroup = {
-  did: string
-  recordPath: string
-  convoId: string
-  createdBy: string
-  tags: string[]
-  ids: number[]
-}
-
-export async function insertExpiringTags(
-  db: Database,
-  params: {
-    eventId: number
-    did: string
-    recordPath: string
-    convoId: string
-    tags: string[]
-    expiresAt: string
-    createdBy: string
-  },
-): Promise<void> {
-  await db.db
-    .insertInto('expiring_tag')
-    .values(
-      params.tags.map((tag) => ({
-        eventId: params.eventId,
-        did: params.did,
-        recordPath: params.recordPath,
-        convoId: params.convoId,
-        tag,
-        expiresAt: params.expiresAt,
-        createdBy: params.createdBy,
-      })),
-    )
-    .execute()
-}
-
-export async function removeExpiringTags(
-  db: Database,
-  params: {
-    did: string
-    recordPath: string
-    convoId: string
-    tags: string[]
-  },
-): Promise<void> {
-  await db.db
-    .deleteFrom('expiring_tag')
-    .where('did', '=', params.did)
-    .where('recordPath', '=', params.recordPath)
-    .where('convoId', '=', params.convoId)
-    .where('tag', 'in', params.tags)
-    .execute()
-}
-
-export async function deleteExpiringTagsByIds(
-  db: Database,
-  ids: number[],
-): Promise<void> {
-  await db.db.deleteFrom('expiring_tag').where('id', 'in', ids).execute()
-}
-
-export async function getExpiredTags(
-  db: Database,
-): Promise<ExpiringTagGroup[]> {
-  const now = new Date().toISOString()
-  const rows = await db.db
-    .selectFrom('expiring_tag')
-    .where('expiresAt', '<', now)
-    .selectAll()
-    .execute()
-
-  if (!rows.length) return []
-
-  // Group by (did, recordPath, convoId, createdBy) so each reversal event has the correct author
-  const grouped = new Map<string, ExpiringTagGroup>()
-  for (const row of rows) {
-    const key = `${row.did}|${row.recordPath}|${row.convoId}|${row.createdBy}`
-    let group = grouped.get(key)
-    if (!group) {
-      group = {
-        did: row.did,
-        recordPath: row.recordPath,
-        convoId: row.convoId,
-        createdBy: row.createdBy,
-        tags: [],
-        ids: [],
-      }
-      grouped.set(key, group)
-    }
-    if (!group.tags.includes(row.tag)) {
-      group.tags.push(row.tag)
-    }
-    group.ids.push(row.id)
-  }
-
-  return [...grouped.values()]
-}