@atproto/bsky 0.0.251 → 0.0.254

package/src/data-plane/server/db/migrations/20250812T183735692Z-add-bookmarks.ts

@@ -1,23 +0,0 @@
-import { Kysely } from 'kysely'
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  await db.schema
-    .createTable('bookmark')
-    .addColumn('creator', 'varchar', (col) => col.notNull())
-    .addColumn('key', 'varchar', (col) => col.notNull())
-    .addColumn('subjectUri', 'varchar', (col) => col.notNull())
-    .addColumn('subjectCid', 'varchar', (col) => col.notNull())
-    .addColumn('indexedAt', 'varchar', (col) => col.notNull())
-    // Supports paginating over creator's bookmarks sorting by key.
-    .addPrimaryKeyConstraint('bookmark_pkey', ['creator', 'key'])
-    // Supports checking for bookmark presence by the creator on specific uris, and supports counting bookmarks by uri.
-    .addUniqueConstraint('bookmark_unique_uri_creator', [
-      'subjectUri',
-      'creator',
-    ])
-    .execute()
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema.dropTable('bookmark').execute()
-}

package/src/data-plane/server/db/migrations/20250813T174955711Z-add-post-agg-bookmarks.ts

@@ -1,12 +0,0 @@
-import { Kysely } from 'kysely'
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  await db.schema
-    .alterTable('post_agg')
-    .addColumn('bookmarkCount', 'bigint', (col) => col.notNull().defaultTo(0))
-    .execute()
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema.alterTable('post_agg').dropColumn('bookmarkCount').execute()
-}

package/src/data-plane/server/db/migrations/20251120T004738098Z-update-actor-age-assurance-v2.ts

@@ -1,28 +0,0 @@
-import { Kysely } from 'kysely'
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  await db.schema
-    .alterTable('actor')
-    .addColumn('ageAssuranceAccess', 'text')
-    .execute()
-  await db.schema
-    .alterTable('actor')
-    .addColumn('ageAssuranceCountryCode', 'text')
-    .execute()
-  await db.schema
-    .alterTable('actor')
-    .addColumn('ageAssuranceRegionCode', 'text')
-    .execute()
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema.alterTable('actor').dropColumn('ageAssuranceAccess').execute()
-  await db.schema
-    .alterTable('actor')
-    .dropColumn('ageAssuranceCountryCode')
-    .execute()
-  await db.schema
-    .alterTable('actor')
-    .dropColumn('ageAssuranceRegionCode')
-    .execute()
-}

package/src/data-plane/server/db/migrations/20260112T133951271Z-add-drafts.ts

@@ -1,24 +0,0 @@
-import { Kysely } from 'kysely'
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  await db.schema
-    .createTable('draft')
-    .addColumn('creator', 'varchar', (col) => col.notNull())
-    .addColumn('key', 'varchar', (col) => col.notNull())
-    .addColumn('createdAt', 'varchar', (col) => col.notNull())
-    .addColumn('updatedAt', 'varchar', (col) => col.notNull())
-    .addColumn('payload', 'text', (col) => col.notNull())
-    .addPrimaryKeyConstraint('draft_pkey', ['creator', 'key'])
-    .execute()
-
-  // Supports getting paginated drafts by updatedAt.
-  await db.schema
-    .createIndex('draft_creator_updated_at_key_idx')
-    .on('draft')
-    .columns(['creator', 'updatedAt', 'key'])
-    .execute()
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema.dropTable('draft').execute()
-}

package/src/data-plane/server/db/migrations/20260604T224952774Z-post-embed-gallery-image.ts

@@ -1,19 +0,0 @@
-import { Kysely } from 'kysely'
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  await db.schema
-    .createTable('post_embed_gallery_image')
-    .addColumn('postUri', 'varchar', (col) => col.notNull())
-    .addColumn('position', 'varchar', (col) => col.notNull())
-    .addColumn('imageCid', 'varchar', (col) => col.notNull())
-    .addColumn('alt', 'varchar', (col) => col.notNull())
-    .addPrimaryKeyConstraint('post_embed_gallery_image_pkey', [
-      'postUri',
-      'position',
-    ])
-    .execute()
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema.dropTable('post_embed_gallery_image').execute()
-}

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

@@ -1,60 +0,0 @@
-// NOTE this file can be edited by hand, but it is also appended to by the migration:create command.
-// It's important that every migration is exported from here with the proper name. We'd simplify
-// this with kysely's FileMigrationProvider, but it doesn't play nicely with the build process.
-
-export * as _20230309T045948368Z from './20230309T045948368Z-init.js'
-export * as _20230408T152211201Z from './20230408T152211201Z-notification-init.js'
-export * as _20230417T210628672Z from './20230417T210628672Z-moderation-init.js'
-export * as _20230420T211446071Z from './20230420T211446071Z-did-cache.js'
-export * as _20230427T194702079Z from './20230427T194702079Z-notif-record-index.js'
-export * as _20230605T144730094Z from './20230605T144730094Z-post-profile-aggs.js'
-export * as _20230607T211442112Z from './20230607T211442112Z-feed-generator-init.js'
-export * as _20230608T155101190Z from './20230608T155101190Z-algo-whats-hot-view.js'
-export * as _20230608T201813132Z from './20230608T201813132Z-mute-lists.js'
-export * as _20230608T205147239Z from './20230608T205147239Z-mutes.js'
-export * as _20230609T153623961Z from './20230609T153623961Z-blocks.js'
-export * as _20230609T232122649Z from './20230609T232122649Z-actor-deletion-indexes.js'
-export * as _20230610T203555962Z from './20230610T203555962Z-suggested-follows.js'
-export * as _20230611T215300060Z from './20230611T215300060Z-actor-state.js'
-export * as _20230620T161134972Z from './20230620T161134972Z-post-langs.js'
-export * as _20230627T212437895Z from './20230627T212437895Z-optional-handle.js'
-export * as _20230629T220835893Z from './20230629T220835893Z-remove-post-hierarchy.js'
-export * as _20230703T045536691Z from './20230703T045536691Z-feed-and-label-indices.js'
-export * as _20230720T164800037Z from './20230720T164800037Z-posts-cursor-idx.js'
-export * as _20230807T035309811Z from './20230807T035309811Z-feed-item-delete-invite-for-user-idx.js'
-export * as _20230808T172902639Z from './20230808T172902639Z-repo-rev.js'
-export * as _20230810T203349843Z from './20230810T203349843Z-action-duration.js'
-export * as _20230817T195936007Z from './20230817T195936007Z-native-notifications.js'
-export * as _20230830T205507322Z from './20230830T205507322Z-suggested-feeds.js'
-export * as _20230904T211011773Z from './20230904T211011773Z-block-lists.js'
-export * as _20230906T222220386Z from './20230906T222220386Z-thread-gating.js'
-export * as _20230920T213858047Z from './20230920T213858047Z-add-tags-to-post.js'
-export * as _20230929T192920807Z from './20230929T192920807Z-record-cursor-indexes.js'
-export * as _20231003T202833377Z from './20231003T202833377Z-create-moderation-subject-status.js'
-export * as _20231220T225126090Z from './20231220T225126090Z-blob-takedowns.js'
-export * as _20240124T023719200Z from './20240124T023719200Z-tagged-suggestions.js'
-export * as _20240226T225725627Z from './20240226T225725627Z-labelers.js'
-export * as _20240530T170337073Z from './20240530T170337073Z-account-deactivation.js'
-export * as _20240606T171229898Z from './20240606T171229898Z-thread-mutes.js'
-export * as _20240606T222548219Z from './20240606T222548219Z-starter-packs.js'
-export * as _20240719T203853939Z from './20240719T203853939Z-priority-notifs.js'
-export * as _20240723T220700077Z from './20240723T220700077Z-quotes-post-aggs.js'
-export * as _20240723T220703655Z from './20240723T220703655Z-quotes.js'
-export * as _20240801T193939827Z from './20240801T193939827Z-post-gate.js'
-export * as _20240808T224251220Z from './20240808T224251220Z-post-gate-flags.js'
-export * as _20240829T211238293Z from './20240829T211238293Z-simplify-actor-sync.js'
-export * as _20240831T134810923Z from './20240831T134810923Z-pinned-posts.js'
-export * as _20241114T153108102Z from './20241114T153108102Z-add-starter-packs-name.js'
-export * as _20250116T222618297Z from './20250116T222618297Z-post-embed-video.js'
-export * as _20250207T174822012Z from './20250207T174822012Z-add-label-exp.js'
-export * as _20250404T163421487Z from './20250404T163421487Z-verifications.js'
-export * as _20250526T023712742Z from './20250526T023712742Z-like-repost-via.js'
-export * as _20250528T221913281Z from './20250528T221913281Z-add-record-tags.js'
-export * as _20250602T190357447Z from './20250602T190357447Z-add-private-data.js'
-export * as _20250611T140649895Z from './20250611T140649895Z-add-activity-subscription.js'
-export * as _20250627T025331240Z from './20250627T025331240Z-add-actor-age-assurance-columns.js'
-export * as _20250812T183735692Z from './20250812T183735692Z-add-bookmarks.js'
-export * as _20250813T174955711Z from './20250813T174955711Z-add-post-agg-bookmarks.js'
-export * as _20251120T004738098Z from './20251120T004738098Z-update-actor-age-assurance-v2.js'
-export * as _20260112T133951271Z from './20260112T133951271Z-add-drafts.js'
-export * as _20260604T224952774Z from './20260604T224952774Z-post-embed-gallery-image.js'

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

@@ -1,26 +0,0 @@
-import { Kysely } from 'kysely'
-import { Migration, MigrationProvider } from 'kysely/migration'
-
-// Passes a context argument to migrations. We use this to thread the dialect into migrations
-
-export class CtxMigrationProvider<T> implements MigrationProvider {
-  constructor(
-    private migrations: Record<string, CtxMigration<T>>,
-    private ctx: T,
-  ) {}
-  async getMigrations(): Promise<Record<string, Migration>> {
-    const ctxMigrations: Record<string, Migration> = {}
-    Object.entries(this.migrations).forEach(([name, migration]) => {
-      ctxMigrations[name] = {
-        up: async (db) => await migration.up(db, this.ctx),
-        down: async (db) => await migration.down?.(db, this.ctx),
-      }
-    })
-    return ctxMigrations
-  }
-}
-
-export interface CtxMigration<T> {
-  up(db: Kysely<unknown>, ctx: T): Promise<void>
-  down?(db: Kysely<unknown>, ctx: T): Promise<void>
-}

package/src/data-plane/server/db/pagination.ts

@@ -1,341 +0,0 @@
-import { SqlBool, sql } from 'kysely'
-import { ensureValidRecordKey } from '@atproto/syntax'
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { AnyQb, DbRef } from './util.js'
-
-type KeysetCursor = { primary: string; secondary: string }
-type KeysetLabeledResult = {
-  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 KeysetLabeledResult> {
-  constructor(
-    public primary: DbRef,
-    public secondary: DbRef,
-  ) {}
-  abstract labelResult(result: R): LR
-  abstract labeledResultToCursor(labeled: LR): KeysetCursor
-  abstract cursorToLabeledResult(cursor: KeysetCursor): 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?: KeysetCursor): string | undefined {
-    if (!cursor) return
-    return `${cursor.primary}__${cursor.secondary}`
-  }
-  unpackCursor(cursorStr?: string): KeysetCursor | 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}))`
-      }
-    }
-  }
-  paginate<QB extends AnyQb>(
-    qb: QB,
-    opts: {
-      limit?: number
-      cursor?: string
-      direction?: 'asc' | 'desc'
-      tryIndex?: boolean
-      // By default, pg does nullsFirst
-      nullsLast?: boolean
-    },
-  ): QB {
-    const { limit, cursor, direction = 'desc', tryIndex, nullsLast } = opts
-    const keysetSql = this.getSql(this.unpack(cursor), direction, tryIndex)
-    return qb
-      .$if(!!limit, (q) => q.limit(limit as number))
-      .$if(!nullsLast, (q) =>
-        q.orderBy(this.primary, direction).orderBy(this.secondary, direction),
-      )
-      .$if(!!nullsLast, (q) =>
-        q
-          .orderBy(
-            direction === 'asc'
-              ? sql`${this.primary} asc nulls last`
-              : sql`${this.primary} desc nulls last`,
-          )
-          .orderBy(
-            direction === 'asc'
-              ? sql`${this.secondary} asc nulls last`
-              : sql`${this.secondary} desc nulls last`,
-          ),
-      )
-      .$if(!!keysetSql, (qb) => (keysetSql ? qb.where(keysetSql) : qb)) as QB
-  }
-}
-
-type SortAtCidResult = { sortAt: string; cid: string }
-type TimeCidLabeledResult = KeysetCursor
-
-export class TimeCidKeyset<
-  TimeCidResult = SortAtCidResult,
-> extends GenericKeyset<TimeCidResult, TimeCidLabeledResult> {
-  labelResult(result: TimeCidResult): TimeCidLabeledResult
-  labelResult<TimeCidResult extends SortAtCidResult>(result: TimeCidResult) {
-    return { primary: result.sortAt, secondary: result.cid }
-  }
-  labeledResultToCursor(labeled: TimeCidLabeledResult) {
-    return {
-      primary: new Date(labeled.primary).getTime().toString(),
-      secondary: labeled.secondary,
-    }
-  }
-  cursorToLabeledResult(cursor: KeysetCursor) {
-    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 class CreatedAtDidKeyset extends TimeCidKeyset<{
-  createdAt: string
-  did: string // dids are treated identically to cids in TimeCidKeyset
-}> {
-  labelResult(result: { createdAt: string; did: string }) {
-    return { primary: result.createdAt, secondary: result.did }
-  }
-}
-
-export class IndexedAtDidKeyset extends TimeCidKeyset<{
-  indexedAt: string
-  did: string // dids are treated identically to cids in TimeCidKeyset
-}> {
-  labelResult(result: { indexedAt: string; did: string }) {
-    return { primary: result.indexedAt, secondary: result.did }
-  }
-}
-
-/**
- * This is being deprecated. Use {@link GenericKeyset#paginate} instead.
- */
-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 => {
-  return opts.keyset.paginate(qb, opts)
-}
-
-type SingleKeyCursor = {
-  primary: string
-}
-
-type SingleKeyLabeledResult = {
-  primary: string | number
-}
-
-/**
- * GenericSingleKey is similar to {@link GenericKeyset} but for a single key cursor.
- */
-export abstract class GenericSingleKey<R, LR extends SingleKeyLabeledResult> {
-  constructor(public primary: DbRef) {}
-  abstract labelResult(result: R): LR
-  abstract labeledResultToCursor(labeled: LR): SingleKeyCursor
-  abstract cursorToLabeledResult(cursor: SingleKeyCursor): 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?: SingleKeyCursor): string | undefined {
-    if (!cursor) return
-    return cursor.primary
-  }
-  unpackCursor(cursorStr?: string): SingleKeyCursor | undefined {
-    if (!cursorStr) return
-    const result = cursorStr.split('__')
-    const [primary, ...others] = result
-    if (!primary || others.length > 0) {
-      throw new InvalidRequestError('Malformed cursor')
-    }
-    return {
-      primary,
-    }
-  }
-  getSql(labeled?: LR, direction?: 'asc' | 'desc') {
-    if (labeled === undefined) return
-    if (direction === 'asc') {
-      return sql<SqlBool>`${this.primary} > ${labeled.primary}`
-    }
-    return sql<SqlBool>`${this.primary} < ${labeled.primary}`
-  }
-  paginate<QB extends AnyQb>(
-    qb: QB,
-    opts: {
-      limit?: number
-      cursor?: string
-      direction?: 'asc' | 'desc'
-      // By default, pg does nullsFirst
-      nullsLast?: boolean
-    },
-  ): QB {
-    const { limit, cursor, direction = 'desc', nullsLast } = opts
-    const keySql = this.getSql(this.unpack(cursor), direction)
-    return qb
-      .$if(!!limit, (q) => q.limit(limit as number))
-      .$if(!nullsLast, (q) => q.orderBy(this.primary, direction))
-      .$if(!!nullsLast, (q) =>
-        q.orderBy(
-          direction === 'asc'
-            ? sql`${this.primary} asc nulls last`
-            : sql`${this.primary} desc nulls last`,
-        ),
-      )
-      .$if(!!keySql, (qb) => (keySql ? qb.where(keySql) : qb)) as QB
-  }
-}
-
-type SortAtResult = { sortAt: string }
-type TimeLabeledResult = SingleKeyCursor
-
-export class IsoTimeKey<TimeResult = SortAtResult> extends GenericSingleKey<
-  TimeResult,
-  TimeLabeledResult
-> {
-  labelResult(result: TimeResult): TimeLabeledResult
-  labelResult<TimeResult extends SortAtResult>(result: TimeResult) {
-    return { primary: result.sortAt }
-  }
-  labeledResultToCursor(labeled: TimeLabeledResult) {
-    return {
-      primary: new Date(labeled.primary).toISOString(),
-    }
-  }
-  cursorToLabeledResult(cursor: SingleKeyCursor) {
-    const primaryDate = new Date(cursor.primary)
-    if (isNaN(primaryDate.getTime())) {
-      throw new InvalidRequestError('Malformed cursor')
-    }
-    return {
-      primary: primaryDate.toISOString(),
-    }
-  }
-}
-
-export class IsoSortAtKey extends IsoTimeKey<{
-  sortAt: string
-}> {
-  labelResult(result: { sortAt: string }) {
-    return { primary: result.sortAt }
-  }
-}
-
-export class IsoUpdatedAtKey extends IsoTimeKey<{
-  updatedAt: string
-}> {
-  labelResult(result: { updatedAt: string }) {
-    return { primary: result.updatedAt }
-  }
-}
-
-type KeyResult = { key: string }
-type RkeyLabeledResult = SingleKeyCursor
-
-export class RkeyKey<RkeyResult = KeyResult> extends GenericSingleKey<
-  RkeyResult,
-  RkeyLabeledResult
-> {
-  labelResult(result: RkeyResult): RkeyLabeledResult
-  labelResult<RkeyResult extends KeyResult>(result: RkeyResult) {
-    return { primary: result }
-  }
-  labeledResultToCursor(labeled: RkeyLabeledResult) {
-    return {
-      primary: labeled.primary,
-    }
-  }
-  cursorToLabeledResult(cursor: SingleKeyCursor) {
-    try {
-      ensureValidRecordKey(cursor.primary)
-      return {
-        primary: cursor.primary,
-      }
-    } catch {
-      throw new InvalidRequestError('Malformed cursor')
-    }
-  }
-}
-
-export class StashKeyKey extends RkeyKey<{
-  key: string
-}> {
-  labelResult(result: { key: string }) {
-    return { primary: result.key }
-  }
-}

package/src/data-plane/server/db/tables/activity-subscription.ts

@@ -1,12 +0,0 @@
-export const tableName = 'activity_subscription'
-export interface ActivitySubscription {
-  creator: string
-  subjectDid: string
-  // key from the bsync stash.
-  key: string
-  indexedAt: string
-  post: boolean
-  reply: boolean
-}
-
-export type PartialDB = { [tableName]: ActivitySubscription }

package/src/data-plane/server/db/tables/actor-block.ts

@@ -1,14 +0,0 @@
-import { GeneratedAlways } from 'kysely'
-
-export const tableName = 'actor_block'
-export interface ActorBlock {
-  uri: string
-  cid: string
-  creator: string
-  subjectDid: string
-  createdAt: string
-  indexedAt: string
-  sortAt: GeneratedAlways<string>
-}
-
-export type PartialDB = { [tableName]: ActorBlock }

package/src/data-plane/server/db/tables/actor-state.ts

@@ -1,10 +0,0 @@
-export interface ActorState {
-  did: string
-  lastSeenNotifs: string
-  priorityNotifs: boolean
-  lastSeenPriorityNotifs: string | undefined
-}
-
-export const tableName = 'actor_state'
-
-export type PartialDB = { [tableName]: ActorState }

package/src/data-plane/server/db/tables/actor-sync.ts

@@ -1,9 +0,0 @@
-export interface ActorSync {
-  did: string
-  commitCid: string
-  repoRev: string | null
-}
-
-export const tableName = 'actor_sync'
-
-export type PartialDB = { [tableName]: ActorSync }

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

@@ -1,19 +0,0 @@
-import { Generated } from 'kysely'
-
-export interface Actor {
-  did: string
-  handle: string | null
-  indexedAt: string
-  takedownRef: string | null
-  upstreamStatus: string | null
-  trustedVerifier: Generated<boolean>
-  ageAssuranceStatus: string | null
-  ageAssuranceLastInitiatedAt: string | null
-  ageAssuranceAccess: string | null
-  ageAssuranceCountryCode: string | null
-  ageAssuranceRegionCode: string | null
-}
-
-export const tableName = 'actor'
-
-export type PartialDB = { [tableName]: Actor }

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

@@ -1,11 +0,0 @@
-export const whatsHotViewTableName = 'algo_whats_hot_view'
-
-export interface AlgoWhatsHotView {
-  uri: string
-  cid: string
-  score: number
-}
-
-export type PartialDB = {
-  [whatsHotViewTableName]: AlgoWhatsHotView
-}

package/src/data-plane/server/db/tables/blob-takedown.ts

@@ -1,9 +0,0 @@
-export interface BlobTakedown {
-  did: string
-  cid: string
-  takedownRef: string
-}
-
-export const tableName = 'blob_takedown'
-
-export type PartialDB = { [tableName]: BlobTakedown }

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

@@ -1,11 +0,0 @@
-export interface Bookmark {
-  creator: string
-  key: string
-  subjectUri: string
-  subjectCid: string
-  indexedAt: string
-}
-
-export const tableName = 'bookmark'
-
-export type PartialDB = { [tableName]: Bookmark }

package/src/data-plane/server/db/tables/did-cache.ts

@@ -1,13 +0,0 @@
-import { DidDocument } from '@atproto/identity'
-
-export interface DidCache {
-  did: string
-  doc: DidDocument
-  updatedAt: number
-}
-
-export const tableName = 'did_cache'
-
-export type PartialDB = {
-  [tableName]: DidCache
-}

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

@@ -1,11 +0,0 @@
-export interface Draft {
-  creator: string
-  key: string
-  createdAt: string
-  updatedAt: string
-  payload: string
-}
-
-export const tableName = 'draft'
-
-export type PartialDB = { [tableName]: Draft }