@atproto/ozone 0.2.9 → 0.2.11

package/src/db/pagination.ts

@@ -1,335 +0,0 @@
-import { DynamicModule, SqlBool, sql } from 'kysely'
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { AnyQb, DbRef } from './types.js'
-
-export type Cursor = { primary: string; secondary: string }
-export type LabeledResult = {
-  primary: string | number
-  secondary: string | number
-}
-
-/**
- * The GenericKeyset is an abstract class that sets-up the interface and partial implementation
- * of a keyset-paginated cursor with two parts. There are three types involved:
- *  - Result: a raw result (i.e. a row from the db) containing data that will make-up a cursor.
- *    - E.g. { createdAt: '2022-01-01T12:00:00Z', cid: 'bafyx' }
- *  - LabeledResult: a Result processed such that the "primary" and "secondary" parts of the cursor are labeled.
- *    - E.g. { primary: '2022-01-01T12:00:00Z', secondary: 'bafyx' }
- *  - Cursor: the two string parts that make-up the packed/string cursor.
- *    - E.g. packed cursor '1641038400000::bafyx' in parts { primary: '1641038400000', secondary: 'bafyx' }
- *
- * These types relate as such. Implementers define the relations marked with a *:
- *   Result -*-> LabeledResult <-*-> Cursor <--> packed/string cursor
- *                     ↳ SQL Condition
- */
-export abstract class GenericKeyset<R, LR extends LabeledResult> {
-  constructor(
-    public primary: DbRef,
-    public secondary: DbRef,
-  ) {}
-  abstract labelResult(result: R): LR
-  abstract labeledResultToCursor(labeled: LR): Cursor
-  abstract cursorToLabeledResult(cursor: Cursor): LR
-  packFromResult(results: R | R[]): string | undefined {
-    const result = Array.isArray(results) ? results.at(-1) : results
-    if (!result) return
-    return this.pack(this.labelResult(result))
-  }
-  pack(labeled?: LR): string | undefined {
-    if (!labeled) return
-    const cursor = this.labeledResultToCursor(labeled)
-    return this.packCursor(cursor)
-  }
-  unpack(cursorStr?: string): LR | undefined {
-    const cursor = this.unpackCursor(cursorStr)
-    if (!cursor) return
-    return this.cursorToLabeledResult(cursor)
-  }
-  packCursor(cursor?: Cursor): string | undefined {
-    if (!cursor) return
-    return `${cursor.primary}::${cursor.secondary}`
-  }
-  unpackCursor(cursorStr?: string): Cursor | undefined {
-    if (!cursorStr) return
-    const result = cursorStr.split('::')
-    const [primary, secondary, ...others] = result
-    if (!primary || !secondary || others.length > 0) {
-      throw new InvalidRequestError('Malformed cursor')
-    }
-    return {
-      primary,
-      secondary,
-    }
-  }
-  getSql(labeled?: LR, direction?: 'asc' | 'desc', tryIndex?: boolean) {
-    if (labeled === undefined) return
-    if (tryIndex) {
-      // The tryIndex param will likely disappear and become the default implementation: here for now for gradual rollout query-by-query.
-      if (direction === 'asc') {
-        return sql<SqlBool>`((${this.primary}, ${this.secondary}) > (${labeled.primary}, ${labeled.secondary}))`
-      } else {
-        return sql<SqlBool>`((${this.primary}, ${this.secondary}) < (${labeled.primary}, ${labeled.secondary}))`
-      }
-    } else {
-      // @NOTE this implementation can struggle to use an index on (primary, secondary) for pagination due to the "or" usage.
-      if (direction === 'asc') {
-        return sql<SqlBool>`((${this.primary} > ${labeled.primary}) or (${this.primary} = ${labeled.primary} and ${this.secondary} > ${labeled.secondary}))`
-      } else {
-        return sql<SqlBool>`((${this.primary} < ${labeled.primary}) or (${this.primary} = ${labeled.primary} and ${this.secondary} < ${labeled.secondary}))`
-      }
-    }
-  }
-}
-
-type StatusKeysetParam = {
-  lastReviewedAt: string | null
-  lastReportedAt: string | null
-  id: number
-}
-
-export class StatusKeyset extends GenericKeyset<StatusKeysetParam, Cursor> {
-  labelResult(result: StatusKeysetParam): Cursor
-  labelResult(result: StatusKeysetParam) {
-    const primaryField = (
-      this.primary as ReturnType<DynamicModule<unknown>['ref']>
-    ).dynamicReference.includes('lastReviewedAt')
-      ? 'lastReviewedAt'
-      : 'lastReportedAt'
-
-    return {
-      primary: result[primaryField]
-        ? new Date(`${result[primaryField]}`).getTime().toString()
-        : '',
-      secondary: result.id.toString(),
-    }
-  }
-  labeledResultToCursor(labeled: Cursor) {
-    return {
-      primary: labeled.primary,
-      secondary: labeled.secondary,
-    }
-  }
-  cursorToLabeledResult(cursor: Cursor) {
-    return {
-      primary: cursor.primary
-        ? new Date(parseInt(cursor.primary, 10)).toISOString()
-        : '',
-      secondary: cursor.secondary,
-    }
-  }
-  unpackCursor(cursorStr?: string): Cursor | undefined {
-    if (!cursorStr) return
-    const result = cursorStr.split('::')
-    const [primary, secondary, ...others] = result
-    if (!secondary || others.length > 0) {
-      throw new InvalidRequestError('Malformed cursor')
-    }
-    return {
-      primary,
-      secondary,
-    }
-  }
-  // This is specifically built to handle nullable columns as primary sorting column
-  getSql(labeled?: Cursor, direction?: 'asc' | 'desc') {
-    if (labeled === undefined) return
-    if (direction === 'asc') {
-      return !labeled.primary
-        ? sql<SqlBool>`(${this.primary} IS NULL AND ${this.secondary} > ${labeled.secondary})`
-        : sql<SqlBool>`((${this.primary}, ${this.secondary}) > (${labeled.primary}, ${labeled.secondary}) OR (${this.primary} is null))`
-    } else {
-      return !labeled.primary
-        ? sql<SqlBool>`(${this.primary} IS NULL AND ${this.secondary} < ${labeled.secondary})`
-        : sql<SqlBool>`((${this.primary}, ${this.secondary}) < (${labeled.primary}, ${labeled.secondary}) OR (${this.primary} is null))`
-    }
-  }
-}
-
-type TimeIdKeysetParam = {
-  id: number
-  createdAt: string | Date
-}
-type TimeIdResult = TimeIdKeysetParam
-
-export class TimeIdKeyset extends GenericKeyset<TimeIdKeysetParam, Cursor> {
-  labelResult(result: TimeIdResult): Cursor
-  labelResult(result: TimeIdResult) {
-    return { primary: result.createdAt, secondary: result.id.toString() }
-  }
-  labeledResultToCursor(labeled: Cursor) {
-    return {
-      primary: new Date(labeled.primary).getTime().toString(),
-      secondary: labeled.secondary,
-    }
-  }
-  cursorToLabeledResult(cursor: Cursor) {
-    const primaryDate = new Date(parseInt(cursor.primary, 10))
-    if (isNaN(primaryDate.getTime())) {
-      throw new InvalidRequestError('Malformed cursor')
-    }
-    return {
-      primary: primaryDate.toISOString(),
-      secondary: cursor.secondary,
-    }
-  }
-}
-
-type CreatedAtUriKeysetParam = {
-  createdAt: string
-  uri: string
-}
-
-export class CreatedAtUriKeyset extends GenericKeyset<
-  CreatedAtUriKeysetParam,
-  Cursor
-> {
-  labelResult(result: CreatedAtUriKeysetParam): Cursor
-  labelResult(result: CreatedAtUriKeysetParam) {
-    return { primary: result.createdAt, secondary: result.uri }
-  }
-  labeledResultToCursor(labeled: Cursor) {
-    return {
-      primary: new Date(labeled.primary).getTime().toString(),
-      secondary: labeled.secondary,
-    }
-  }
-  cursorToLabeledResult(cursor: Cursor) {
-    const primaryDate = new Date(parseInt(cursor.primary, 10))
-    if (isNaN(primaryDate.getTime())) {
-      throw new InvalidRequestError('Malformed cursor')
-    }
-    return {
-      primary: primaryDate.toISOString(),
-      secondary: cursor.secondary,
-    }
-  }
-}
-
-type EndAtIdKeysetParam = {
-  id: number
-  endAt: string | null
-}
-
-// Special value used here to represent a "permanent" endAt (i.e. a record that should be sorted as if it has an endAt infinitely far in the future).
-// Chosen to sort before all real timestamps in DESC order.
-const PERMANENT_ENDSAT = '9999-12-31T23:59:59.999Z'
-
-export class EndAtIdKeyset extends GenericKeyset<EndAtIdKeysetParam, Cursor> {
-  labelResult(result: EndAtIdKeysetParam): Cursor
-  labelResult(result: EndAtIdKeysetParam) {
-    return {
-      primary: result.endAt ?? PERMANENT_ENDSAT,
-      secondary: result.id.toString(),
-    }
-  }
-  labeledResultToCursor(labeled: Cursor) {
-    return {
-      primary: new Date(labeled.primary).getTime().toString(),
-      secondary: labeled.secondary,
-    }
-  }
-  cursorToLabeledResult(cursor: Cursor) {
-    const primaryDate = new Date(parseInt(cursor.primary, 10))
-    if (isNaN(primaryDate.getTime())) {
-      throw new InvalidRequestError('Malformed cursor')
-    }
-    return {
-      primary: primaryDate.toISOString(),
-      secondary: cursor.secondary,
-    }
-  }
-  // Override to substitute the PERMANENT_ENDSAT sentinel for NULL endAt rows
-  // so cursor pagination works across permanent (endAt IS NULL) assignments.
-  getSql(labeled?: Cursor, direction?: 'asc' | 'desc', tryIndex?: boolean) {
-    if (labeled === undefined) return
-    const primaryRef = sql`COALESCE(${this.primary}, ${PERMANENT_ENDSAT})`
-    if (tryIndex) {
-      if (direction === 'asc') {
-        return sql<SqlBool>`((${primaryRef}, ${this.secondary}) > (${labeled.primary}, ${labeled.secondary}))`
-      } else {
-        return sql<SqlBool>`((${primaryRef}, ${this.secondary}) < (${labeled.primary}, ${labeled.secondary}))`
-      }
-    } else {
-      if (direction === 'asc') {
-        return sql<SqlBool>`((${primaryRef} > ${labeled.primary}) or (${primaryRef} = ${labeled.primary} and ${this.secondary} > ${labeled.secondary}))`
-      } else {
-        return sql<SqlBool>`((${primaryRef} < ${labeled.primary}) or (${primaryRef} = ${labeled.primary} and ${this.secondary} < ${labeled.secondary}))`
-      }
-    }
-  }
-}
-
-type ComputedAtIdKeysetParam = {
-  id: number
-  computedAt: string | Date
-}
-
-export class ComputedAtIdKeyset extends GenericKeyset<
-  ComputedAtIdKeysetParam,
-  Cursor
-> {
-  labelResult(result: ComputedAtIdKeysetParam): Cursor
-  labelResult(result: ComputedAtIdKeysetParam) {
-    return { primary: result.computedAt, secondary: result.id.toString() }
-  }
-  labeledResultToCursor(labeled: Cursor) {
-    return {
-      primary: new Date(labeled.primary).getTime().toString(),
-      secondary: labeled.secondary,
-    }
-  }
-  cursorToLabeledResult(cursor: Cursor) {
-    const primaryDate = new Date(parseInt(cursor.primary, 10))
-    if (isNaN(primaryDate.getTime())) {
-      throw new InvalidRequestError('Malformed cursor')
-    }
-    return {
-      primary: primaryDate.toISOString(),
-      secondary: cursor.secondary,
-    }
-  }
-}
-
-export const paginate = <
-  QB extends AnyQb,
-  K extends GenericKeyset<unknown, any>,
->(
-  qb: QB,
-  opts: {
-    limit?: number
-    cursor?: string
-    direction?: 'asc' | 'desc'
-    keyset: K
-    tryIndex?: boolean
-    // By default, pg does nullsFirst
-    nullsLast?: boolean
-  },
-): QB => {
-  const {
-    limit,
-    cursor,
-    keyset,
-    direction = 'desc',
-    tryIndex,
-    nullsLast,
-  } = opts
-  const keysetSql = keyset.getSql(keyset.unpack(cursor), direction, tryIndex)
-  return qb
-    .$if(!!limit, (q) => q.limit(limit as number))
-    .$if(!nullsLast, (q) =>
-      q.orderBy(keyset.primary, direction).orderBy(keyset.secondary, direction),
-    )
-    .$if(!!nullsLast, (q) =>
-      q
-        .orderBy(
-          direction === 'asc'
-            ? sql`${keyset.primary} asc nulls last`
-            : sql`${keyset.primary} desc nulls last`,
-        )
-        .orderBy(
-          direction === 'asc'
-            ? sql`${keyset.secondary} asc nulls last`
-            : sql`${keyset.secondary} desc nulls last`,
-        ),
-    )
-    .$if(!!keysetSql, (qb) => (keysetSql ? qb.where(keysetSql) : qb)) as QB
-}

package/src/db/schema/account_events_stats.ts

@@ -1,16 +0,0 @@
-import { GeneratedAlways, Selectable } from 'kysely'
-
-export const tableName = 'account_events_stats'
-
-export type AccountEventsStats = {
-  subjectDid: GeneratedAlways<string>
-  takedownCount: GeneratedAlways<number>
-  suspendCount: GeneratedAlways<number>
-  escalateCount: GeneratedAlways<number>
-  reportCount: GeneratedAlways<number>
-  appealCount: GeneratedAlways<number>
-}
-
-export type AccountEventsStatsRow = Selectable<AccountEventsStats>
-
-export type PartialDB = { [tableName]: AccountEventsStats }

package/src/db/schema/account_record_events_stats.ts

@@ -1,15 +0,0 @@
-import { GeneratedAlways, Selectable } from 'kysely'
-
-export const tableName = 'account_record_events_stats'
-
-type AccountRecordEventsStats = {
-  subjectDid: GeneratedAlways<string>
-  totalReports: GeneratedAlways<number>
-  reportedCount: GeneratedAlways<number>
-  escalatedCount: GeneratedAlways<number>
-  appealedCount: GeneratedAlways<number>
-}
-
-export type AccountRecordEventsStatsRow = Selectable<AccountRecordEventsStats>
-
-export type PartialDB = { [tableName]: AccountRecordEventsStats }

package/src/db/schema/account_record_status_stats.ts

@@ -1,15 +0,0 @@
-import { GeneratedAlways, Selectable } from 'kysely'
-
-export const tableName = 'account_record_status_stats'
-
-type AccountRecordStatusStats = {
-  did: GeneratedAlways<string>
-  subjectCount: GeneratedAlways<number>
-  pendingCount: GeneratedAlways<number>
-  processedCount: GeneratedAlways<number>
-  takendownCount: GeneratedAlways<number>
-}
-
-export type AccountRecordStatusStatsRow = Selectable<AccountRecordStatusStats>
-
-export type PartialDB = { [tableName]: AccountRecordStatusStats }

package/src/db/schema/account_strike.ts

@@ -1,13 +0,0 @@
-export const accountStrikeTableName = 'account_strike'
-
-export interface AccountStrike {
-  did: string // Primary key
-  firstStrikeAt: string | null
-  lastStrikeAt: string | null
-  activeStrikeCount: number
-  totalStrikeCount: number
-}
-
-export type PartialDB = {
-  [accountStrikeTableName]: AccountStrike
-}

package/src/db/schema/blob_push_event.ts

@@ -1,21 +0,0 @@
-import { Generated } from 'kysely'
-
-export const eventTableName = 'blob_push_event'
-
-export type BlobPushEventType = 'pds_takedown' | 'appview_takedown'
-
-export interface BlobPushEvent {
-  id: Generated<number>
-  eventType: BlobPushEventType
-  subjectDid: string
-  subjectBlobCid: string
-  subjectUri: string | null
-  takedownRef: string | null
-  confirmedAt: Date | null
-  lastAttempted: Date | null
-  attempts: Generated<number>
-}
-
-export type PartialDB = {
-  [eventTableName]: BlobPushEvent
-}

package/src/db/schema/communication_template.ts

@@ -1,19 +0,0 @@
-import { Generated, GeneratedAlways } from 'kysely'
-
-export const communicationTemplateTableName = 'communication_template'
-
-export interface CommunicationTemplate {
-  id: GeneratedAlways<number>
-  name: string
-  contentMarkdown: string
-  subject: string | null
-  lang: string | null
-  disabled: Generated<boolean>
-  createdAt: Date
-  updatedAt: Date
-  lastUpdatedBy: string
-}
-
-export type PartialDB = {
-  [communicationTemplateTableName]: CommunicationTemplate
-}

package/src/db/schema/expiring_tag.ts

@@ -1,18 +0,0 @@
-import { Generated } from 'kysely'
-
-export const tableName = 'expiring_tag'
-
-export interface ExpiringTag {
-  id: Generated<number>
-  eventId: number
-  did: string
-  recordPath: string
-  convoId: string
-  tag: string
-  expiresAt: string
-  createdBy: string
-}
-
-export type PartialDB = {
-  [tableName]: ExpiringTag
-}

package/src/db/schema/firehose_cursor.ts

@@ -1,13 +0,0 @@
-import { Generated } from 'kysely'
-
-export const firehoseCursorTableName = 'firehose_cursor'
-
-export interface FirehoseCursor {
-  service: string
-  cursor: number | null
-  updatedAt: Generated<string>
-}
-
-export type PartialDB = {
-  [firehoseCursorTableName]: FirehoseCursor
-}

package/src/db/schema/index.ts

@@ -1,60 +0,0 @@
-import { Kysely } from 'kysely'
-import * as accountEventsStats from './account_events_stats.js'
-import * as accountRecordEventsStats from './account_record_events_stats.js'
-import * as accountRecordStatusStats from './account_record_status_stats.js'
-import * as accountStrike from './account_strike.js'
-import * as blobPushEvent from './blob_push_event.js'
-import * as communicationTemplate from './communication_template.js'
-import * as expiringTag from './expiring_tag.js'
-import * as firehoseCursor from './firehose_cursor.js'
-import * as jobCursor from './job_cursor.js'
-import * as label from './label.js'
-import * as member from './member.js'
-import * as modEvent from './moderation_event.js'
-import * as modSubjectStatus from './moderation_subject_status.js'
-import * as moderatorAssignment from './moderator_assignment.js'
-import * as set from './ozone_set.js'
-import * as recordEventsStats from './record_events_stats.js'
-import * as recordPushEvent from './record_push_event.js'
-import * as repoPushEvent from './repo_push_event.js'
-import * as report from './report.js'
-import * as reportActivity from './report_activity.js'
-import * as reportQueue from './report_queue.js'
-import * as reportStat from './report_stat.js'
-import * as safelink from './safelink.js'
-import * as scheduledAction from './scheduled-action.js'
-import * as setting from './setting.js'
-import * as signingKey from './signing_key.js'
-import * as verification from './verification.js'
-
-export type DatabaseSchemaType = modEvent.PartialDB &
-  modSubjectStatus.PartialDB &
-  report.PartialDB &
-  reportActivity.PartialDB &
-  reportQueue.PartialDB &
-  label.PartialDB &
-  signingKey.PartialDB &
-  repoPushEvent.PartialDB &
-  recordPushEvent.PartialDB &
-  blobPushEvent.PartialDB &
-  communicationTemplate.PartialDB &
-  set.PartialDB &
-  member.PartialDB &
-  setting.PartialDB &
-  accountEventsStats.PartialDB &
-  recordEventsStats.PartialDB &
-  accountRecordEventsStats.PartialDB &
-  accountRecordStatusStats.PartialDB &
-  accountStrike.PartialDB &
-  verification.PartialDB &
-  firehoseCursor.PartialDB &
-  jobCursor.PartialDB &
-  safelink.PartialDB &
-  scheduledAction.PartialDB &
-  moderatorAssignment.PartialDB &
-  reportStat.PartialDB &
-  expiringTag.PartialDB
-
-export type DatabaseSchema = Kysely<DatabaseSchemaType>
-
-export default DatabaseSchema

package/src/db/schema/job_cursor.ts

@@ -1,13 +0,0 @@
-import { Generated } from 'kysely'
-
-export const jobCursorTableName = 'job_cursor'
-
-export interface JobCursor {
-  job: string
-  cursor: string | null
-  updatedAt: Generated<string>
-}
-
-export type PartialDB = {
-  [jobCursorTableName]: JobCursor
-}

package/src/db/schema/label.ts

@@ -1,22 +0,0 @@
-import { Generated, Selectable } from 'kysely'
-
-export const tableName = 'label'
-
-export interface Label {
-  id: Generated<number>
-  src: string
-  uri: string
-  cid: string
-  val: string
-  neg: boolean
-  cts: string
-  exp: string | null
-  sig: Buffer | null
-  signingKeyId: number | null
-}
-
-export type LabelRow = Selectable<Label>
-
-export type PartialDB = { [tableName]: Label }
-
-export const LabelChannel = 'label_channel' // used with notify/listen

package/src/db/schema/member.ts

@@ -1,22 +0,0 @@
-import { Generated } from 'kysely'
-
-export const memberTableName = 'member'
-
-export interface Member {
-  did: string
-  role:
-    | 'tools.ozone.team.defs#roleAdmin'
-    | 'tools.ozone.team.defs#roleTriage'
-    | 'tools.ozone.team.defs#roleVerifier'
-    | 'tools.ozone.team.defs#roleModerator'
-  disabled: Generated<boolean>
-  handle: string | null
-  displayName: string | null
-  createdAt: Date
-  updatedAt: Date
-  lastUpdatedBy: string
-}
-
-export type PartialDB = {
-  [memberTableName]: Member
-}

package/src/db/schema/moderation_event.ts

@@ -1,61 +0,0 @@
-import { Generated } from 'kysely'
-
-export const eventTableName = 'moderation_event'
-
-export interface ModerationEvent {
-  id: Generated<number>
-  action:
-    | 'tools.ozone.moderation.defs#modEventTakedown'
-    | 'tools.ozone.moderation.defs#modEventAcknowledge'
-    | 'tools.ozone.moderation.defs#modEventEscalate'
-    | 'tools.ozone.moderation.defs#modEventComment'
-    | 'tools.ozone.moderation.defs#modEventLabel'
-    | 'tools.ozone.moderation.defs#modEventReport'
-    | 'tools.ozone.moderation.defs#modEventMute'
-    | 'tools.ozone.moderation.defs#modEventUnmute'
-    | 'tools.ozone.moderation.defs#modEventMuteReporter'
-    | 'tools.ozone.moderation.defs#modEventUnmuteReporter'
-    | 'tools.ozone.moderation.defs#modEventReverseTakedown'
-    | 'tools.ozone.moderation.defs#modEventEmail'
-    | 'tools.ozone.moderation.defs#modEventResolveAppeal'
-    | 'tools.ozone.moderation.defs#modEventTag'
-    | 'tools.ozone.moderation.defs#accountEvent'
-    | 'tools.ozone.moderation.defs#identityEvent'
-    | 'tools.ozone.moderation.defs#recordEvent'
-    | 'tools.ozone.moderation.defs#modEventPriorityScore'
-    | 'tools.ozone.moderation.defs#ageAssuranceEvent'
-    | 'tools.ozone.moderation.defs#ageAssuranceOverrideEvent'
-    | 'tools.ozone.moderation.defs#ageAssurancePurgeEvent'
-    | 'tools.ozone.moderation.defs#revokeAccountCredentialsEvent'
-  subjectType:
-    | 'com.atproto.admin.defs#repoRef'
-    | 'com.atproto.repo.strongRef'
-    | 'chat.bsky.convo.defs#messageRef'
-    | 'chat.bsky.convo.defs#convoRef'
-  subjectDid: string
-  subjectUri: string | null
-  subjectCid: string | null
-  subjectBlobCids: string[] | null
-  subjectConvoId: string | null
-  subjectMessageId: string | null
-  createLabelVals: string | null
-  negateLabelVals: string | null
-  comment: string | null
-  createdAt: string
-  createdBy: string
-  durationInHours: number | null
-  expiresAt: string | null
-  meta: Record<string, string | boolean | number> | null
-  addedTags: string[] | null
-  removedTags: string[] | null
-  legacyRefId: number | null
-  modTool: { name: string; meta?: { [_ in string]: unknown } } | null
-  externalId: string | null
-  severityLevel: string | null
-  strikeCount: number | null
-  strikeExpiresAt: string | null
-}
-
-export type PartialDB = {
-  [eventTableName]: ModerationEvent
-}