@atproto/ozone 0.0.12 → 0.0.14

package/dist/logger.d.ts

@@ -1,5 +1,6 @@
 import { subsystemLogger } from '@atproto/common';
 export declare const dbLogger: ReturnType<typeof subsystemLogger>;
+export declare const seqLogger: ReturnType<typeof subsystemLogger>;
 export declare const httpLogger: ReturnType<typeof subsystemLogger>;
 export declare const langLogger: ReturnType<typeof subsystemLogger>;
 export declare const loggerMiddleware: import("pino-http").HttpLogger;

package/dist/mod-service/util.d.ts

@@ -0,0 +1,3 @@
+import { LabelRow } from '../db/schema/label';
+import { Label } from '../lexicon/types/com/atproto/label/defs';
+export declare const formatLabel: (row: LabelRow) => Label;

package/dist/sequencer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './sequencer';
+export * from './outbox';

package/dist/sequencer/outbox.d.ts

@@ -0,0 +1,16 @@
+import { AsyncBuffer } from '@atproto/common';
+import { Sequencer, LabelsEvt } from './sequencer';
+export type OutboxOpts = {
+    maxBufferSize: number;
+};
+export declare class Outbox {
+    sequencer: Sequencer;
+    private caughtUp;
+    lastSeen: number;
+    cutoverBuffer: LabelsEvt[];
+    outBuffer: AsyncBuffer<LabelsEvt>;
+    constructor(sequencer: Sequencer, opts?: Partial<OutboxOpts>);
+    events(backfillCursor?: number, signal?: AbortSignal): AsyncGenerator<LabelsEvt>;
+    getBackfill(backfillCursor: number): AsyncGenerator<LabelsEvt, void, unknown>;
+}
+export default Outbox;

package/dist/sequencer/sequencer.d.ts

@@ -0,0 +1,33 @@
+import TypedEmitter from 'typed-emitter';
+import Database from '../db';
+import { Labels as LabelsEvt } from '../lexicon/types/com/atproto/label/subscribeLabels';
+import { Label as LabelTable } from '../db/schema/label';
+import { Selectable } from 'kysely';
+import { PoolClient } from 'pg';
+export type { Labels as LabelsEvt } from '../lexicon/types/com/atproto/label/subscribeLabels';
+type LabelRow = Selectable<LabelTable>;
+declare const Sequencer_base: new () => SequencerEmitter;
+export declare class Sequencer extends Sequencer_base {
+    db: Database;
+    lastSeen: number;
+    destroyed: boolean;
+    pollPromise: Promise<void> | undefined;
+    queued: boolean;
+    conn: PoolClient | undefined;
+    constructor(db: Database, lastSeen?: number);
+    start(): Promise<void>;
+    destroy(): Promise<void>;
+    curr(): Promise<number | null>;
+    next(cursor: number): Promise<LabelRow | null>;
+    requestLabelRange(opts: {
+        earliestId?: number;
+        limit?: number;
+    }): Promise<LabelsEvt[]>;
+    private poll;
+}
+type SequencerEvents = {
+    events: (evts: LabelsEvt[]) => void;
+    close: () => void;
+};
+export type SequencerEmitter = TypedEmitter<SequencerEvents>;
+export default Sequencer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/ozone",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "license": "MIT",
   "description": "Backend service for moderating the Bluesky network.",
   "keywords": [
@@ -30,13 +30,13 @@
     "pino-http": "^8.2.1",
     "typed-emitter": "^2.1.0",
     "uint8arrays": "3.0.0",
-    "@atproto/api": "^0.10.1",
+    "@atproto/api": "^0.10.3",
     "@atproto/common": "^0.3.3",
     "@atproto/crypto": "^0.3.0",
     "@atproto/identity": "^0.3.2",
-    "@atproto/lexicon": "^0.3.1",
-    "@atproto/syntax": "^0.1.5",
-    "@atproto/xrpc-server": "^0.4.2"
+    "@atproto/lexicon": "^0.3.2",
+    "@atproto/syntax": "^0.2.0",
+    "@atproto/xrpc-server": "^0.4.3"
   },
   "devDependencies": {
     "@did-plc/server": "^0.0.1",
@@ -46,11 +46,11 @@
     "@types/pg": "^8.6.6",
     "@types/qs": "^6.9.7",
     "axios": "^0.27.2",
-    "@atproto/api": "^0.10.1",
-    "@atproto/dev-env": "^0.2.33",
-    "@atproto/lex-cli": "^0.3.0",
-    "@atproto/pds": "^0.4.1",
-    "@atproto/xrpc": "^0.4.1"
+    "@atproto/api": "^0.10.3",
+    "@atproto/dev-env": "^0.2.35",
+    "@atproto/lex-cli": "^0.3.1",
+    "@atproto/pds": "^0.4.3",
+    "@atproto/xrpc": "^0.4.2"
   },
   "scripts": {
     "codegen": "lex gen-server ./src/lexicon ../../lexicons/com/atproto/*/* ../../lexicons/app/bsky/*/*",

package/src/api/admin/emitModerationEvent.ts

@@ -27,17 +27,23 @@ export default function (server: Server, ctx: AppContext) {
 
       // apply access rules
 
-      // if less than moderator access then can not takedown an account
-      if (!access.moderator && isTakedownEvent && subject.isRepo()) {
-        throw new AuthRequiredError(
-          'Must be a full moderator to perform an account takedown',
-        )
-      }
       // if less than moderator access then can only take ack and escalation actions
-      if (!access.moderator && (isTakedownEvent || isReverseTakedownEvent)) {
-        throw new AuthRequiredError(
-          'Must be a full moderator to take this type of action',
-        )
+      if (isTakedownEvent || isReverseTakedownEvent) {
+        if (!access.moderator) {
+          throw new AuthRequiredError(
+            'Must be a full moderator to take this type of action',
+          )
+        }
+
+        // Non admins should not be able to take down feed generators
+        if (
+          !access.admin &&
+          subject.recordPath?.includes('app.bsky.feed.generator/')
+        ) {
+          throw new AuthRequiredError(
+            'Must be a full admin to take this type of action on feed generators',
+          )
+        }
       }
       // if less than moderator access then can not apply labels
       if (!access.moderator && isLabelEvent) {

package/src/api/index.ts

@@ -8,6 +8,8 @@ import getRepo from './admin/getRepo'
 import queryModerationStatuses from './admin/queryModerationStatuses'
 import queryModerationEvents from './admin/queryModerationEvents'
 import getModerationEvent from './admin/getModerationEvent'
+import queryLabels from './label/queryLabels'
+import subscribeLabels from './label/subscribeLabels'
 import fetchLabels from './temp/fetchLabels'
 import createCommunicationTemplate from './admin/createCommunicationTemplate'
 import updateCommunicationTemplate from './admin/updateCommunicationTemplate'
@@ -27,6 +29,8 @@ export default function (server: Server, ctx: AppContext) {
   getModerationEvent(server, ctx)
   queryModerationEvents(server, ctx)
   queryModerationStatuses(server, ctx)
+  queryLabels(server, ctx)
+  subscribeLabels(server, ctx)
   fetchLabels(server, ctx)
   listCommunicationTemplates(server, ctx)
   createCommunicationTemplate(server, ctx)

package/src/api/label/queryLabels.ts

@@ -0,0 +1,58 @@
+import { Server } from '../../lexicon'
+import AppContext from '../../context'
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { sql } from 'kysely'
+import { formatLabel } from '../../mod-service/util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.com.atproto.label.queryLabels(async ({ params }) => {
+    const { uriPatterns, sources, limit, cursor } = params
+    let builder = ctx.db.db.selectFrom('label').selectAll().limit(limit)
+    // if includes '*', then we don't need a where clause
+    if (!uriPatterns.includes('*')) {
+      builder = builder.where((qb) => {
+        // starter where clause that is always false so that we can chain `orWhere`s
+        qb = qb.where(sql`1 = 0`)
+        for (const pattern of uriPatterns) {
+          // if no '*', then we're looking for an exact match
+          if (!pattern.includes('*')) {
+            qb = qb.orWhere('uri', '=', pattern)
+          } else {
+            if (pattern.indexOf('*') < pattern.length - 1) {
+              throw new InvalidRequestError(`invalid pattern: ${pattern}`)
+            }
+            const searchPattern = pattern
+              .slice(0, -1)
+              .replaceAll('%', '') // sanitize search pattern
+              .replaceAll('_', '\\_') // escape any underscores
+            qb = qb.orWhere('uri', 'like', `${searchPattern}%`)
+          }
+        }
+        return qb
+      })
+    }
+    if (sources && sources.length > 0) {
+      builder = builder.where('src', 'in', sources)
+    }
+    if (cursor) {
+      const cursorId = parseInt(cursor, 10)
+      if (isNaN(cursorId)) {
+        throw new InvalidRequestError('invalid cursor')
+      }
+      builder = builder.where('id', '>', cursorId)
+    }
+
+    const res = await builder.execute()
+
+    const labels = res.map((l) => formatLabel(l))
+    const resCursor = res.at(-1)?.id.toString(10)
+
+    return {
+      encoding: 'application/json',
+      body: {
+        cursor: resCursor,
+        labels,
+      },
+    }
+  })
+}

package/src/api/label/subscribeLabels.ts

@@ -0,0 +1,25 @@
+import { Server } from '../../lexicon'
+import AppContext from '../../context'
+import Outbox from '../../sequencer/outbox'
+import { InvalidRequestError } from '@atproto/xrpc-server'
+
+export default function (server: Server, ctx: AppContext) {
+  server.com.atproto.label.subscribeLabels(async function* ({
+    params,
+    signal,
+  }) {
+    const { cursor } = params
+    const outbox = new Outbox(ctx.sequencer)
+
+    if (cursor !== undefined) {
+      const curr = await ctx.sequencer.curr()
+      if (cursor > (curr ?? 0)) {
+        throw new InvalidRequestError('Cursor in the future.', 'FutureCursor')
+      }
+    }
+
+    for await (const evt of outbox.events(cursor, signal)) {
+      yield { $type: 'com.atproto.label.subscribeLabels#labels', ...evt }
+    }
+  })
+}

package/src/api/temp/fetchLabels.ts

@@ -1,5 +1,6 @@
 import { Server } from '../../lexicon'
 import AppContext from '../../context'
+import { formatLabel } from '../../mod-service/util'
 import {
   UNSPECCED_TAKEDOWN_BLOBS_LABEL,
   UNSPECCED_TAKEDOWN_LABEL,
@@ -28,10 +29,7 @@ export default function (server: Server, ctx: AppContext) {
         .limit(limit)
         .execute()
 
-      const labels = labelRes.map((l) => ({
-        ...l,
-        cid: l.cid === '' ? undefined : l.cid,
-      }))
+      const labels = labelRes.map((l) => formatLabel(l))
 
       return {
         encoding: 'application/json',

package/src/config/config.ts

@@ -19,6 +19,9 @@ export const envToCfg = (env: OzoneEnvironment): OzoneConfig => {
   const dbCfg: OzoneConfig['db'] = {
     postgresUrl: env.dbPostgresUrl,
     postgresSchema: env.dbPostgresSchema,
+    poolSize: env.dbPoolSize,
+    poolMaxUses: env.dbPoolMaxUses,
+    poolIdleTimeoutMs: env.dbPoolIdleTimeoutMs,
   }
 
   assert(env.appviewUrl)
@@ -67,6 +70,9 @@ export type ServiceConfig = {
 export type DatabaseConfig = {
   postgresUrl: string
   postgresSchema?: string
+  poolSize?: number
+  poolMaxUses?: number
+  poolIdleTimeoutMs?: number
 }
 
 export type AppviewConfig = {

package/src/config/env.ts

@@ -13,6 +13,9 @@ export const readEnv = (): OzoneEnvironment => {
     pdsDid: envStr('OZONE_PDS_DID'),
     dbPostgresUrl: envStr('OZONE_DB_POSTGRES_URL'),
     dbPostgresSchema: envStr('OZONE_DB_POSTGRES_SCHEMA'),
+    dbPoolSize: envInt('OZONE_DB_POOL_SIZE'),
+    dbPoolMaxUses: envInt('OZONE_DB_POOL_MAX_USES'),
+    dbPoolIdleTimeoutMs: envInt('OZONE_DB_POOL_IDLE_TIMEOUT_MS'),
     didPlcUrl: envStr('OZONE_DID_PLC_URL'),
     adminPassword: envStr('OZONE_ADMIN_PASSWORD'),
     moderatorPassword: envStr('OZONE_MODERATOR_PASSWORD'),
@@ -33,6 +36,9 @@ export type OzoneEnvironment = {
   pdsDid?: string
   dbPostgresUrl?: string
   dbPostgresSchema?: string
+  dbPoolSize?: number
+  dbPoolMaxUses?: number
+  dbPoolIdleTimeoutMs?: number
   didPlcUrl?: string
   adminPassword?: string
   moderatorPassword?: string

package/src/context.ts

@@ -10,6 +10,7 @@ import * as auth from './auth'
 import { BackgroundQueue } from './background'
 import assert from 'assert'
 import { EventPusher } from './daemon'
+import Sequencer from './sequencer/sequencer'
 import {
   CommunicationTemplateService,
   CommunicationTemplateServiceCreator,
@@ -25,6 +26,7 @@ export type AppContextOptions = {
   signingKey: Keypair
   idResolver: IdResolver
   backgroundQueue: BackgroundQueue
+  sequencer: Sequencer
 }
 
 export class AppContext {
@@ -38,6 +40,9 @@ export class AppContext {
     const db = new Database({
       url: cfg.db.postgresUrl,
       schema: cfg.db.postgresSchema,
+      poolSize: cfg.db.poolSize,
+      poolMaxUses: cfg.db.poolMaxUses,
+      poolIdleTimeoutMs: cfg.db.poolIdleTimeoutMs,
     })
     const signingKey = await Secp256k1Keypair.import(secrets.signingKeyHex)
     const appviewAgent = new AtpAgent({ service: cfg.appview.url })
@@ -74,6 +79,8 @@ export class AppContext {
       plcUrl: cfg.identity.plcUrl,
     })
 
+    const sequencer = new Sequencer(db)
+
     return new AppContext(
       {
         db,
@@ -85,6 +92,7 @@ export class AppContext {
         signingKey,
         idResolver,
         backgroundQueue,
+        sequencer,
         ...(overrides ?? {}),
       },
       secrets,
@@ -139,6 +147,10 @@ export class AppContext {
     return this.opts.backgroundQueue
   }
 
+  get sequencer(): Sequencer {
+    return this.opts.sequencer
+  }
+
   get authVerifier() {
     return auth.authVerifier(this.idResolver, { aud: this.cfg.service.did })
   }

package/src/db/migrations/20231219T205730722Z-init.ts

@@ -68,13 +68,19 @@ export async function up(db: Kysely<unknown>): Promise<void> {
   // Label
   await db.schema
     .createTable('label')
+    .addColumn('id', 'bigserial', (col) => col.primaryKey())
     .addColumn('src', 'varchar', (col) => col.notNull())
     .addColumn('uri', 'varchar', (col) => col.notNull())
     .addColumn('cid', 'varchar', (col) => col.notNull())
     .addColumn('val', 'varchar', (col) => col.notNull())
     .addColumn('neg', 'boolean', (col) => col.notNull())
     .addColumn('cts', 'varchar', (col) => col.notNull())
-    .addPrimaryKeyConstraint('label_pkey', ['src', 'uri', 'cid', 'val'])
+    .execute()
+  await db.schema
+    .createIndex('unique_label_idx')
+    .unique()
+    .on('label')
+    .columns(['src', 'uri', 'cid', 'val'])
     .execute()
   await db.schema
     .createIndex('label_uri_index')

package/src/db/schema/label.ts

@@ -1,6 +1,9 @@
+import { Generated, Selectable } from 'kysely'
+
 export const tableName = 'label'
 
 export interface Label {
+  id: Generated<number>
   src: string
   uri: string
   cid: string
@@ -9,4 +12,8 @@ export interface Label {
   cts: string
 }
 
+export type LabelRow = Selectable<Label>
+
 export type PartialDB = { [tableName]: Label }
+
+export const LabelChannel = 'label_channel' // used with notify/listen

package/src/index.ts

@@ -81,6 +81,7 @@ export class OzoneService {
         'background queue stats',
       )
     }, 10000)
+    await this.ctx.sequencer.start()
     const server = this.app.listen(this.ctx.cfg.service.port)
     this.server = server
     server.keepAliveTimeout = 90000
@@ -94,6 +95,7 @@ export class OzoneService {
   async destroy(): Promise<void> {
     await this.terminator?.terminate()
     await this.ctx.backgroundQueue.destroy()
+    await this.ctx.sequencer.destroy()
     await this.ctx.db.close()
     clearInterval(this.dbStatsInterval)
   }

package/src/lexicon/lexicons.ts

@@ -4867,7 +4867,7 @@ export const schemaDict = {
       main: {
         type: 'query',
         description:
-          'Fetch all labels from a labeler created after a certain date. DEPRECATED: use queryLabels or subscribeLabels instead',
+          'DEPRECATED: use queryLabels or subscribeLabels instead -- Fetch all labels from a labeler created after a certain date.',
         parameters: {
           type: 'params',
           properties: {

package/src/logger.ts

@@ -3,6 +3,8 @@ import { 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> =

package/src/mod-service/index.ts

@@ -43,6 +43,7 @@ import { BlobPushEvent } from '../db/schema/blob_push_event'
 import { BackgroundQueue } from '../background'
 import { EventPusher } from '../daemon'
 import { jsonb } from '../db/types'
+import { LabelChannel } from '../db/schema/label'
 
 export type ModerationServiceCreator = (db: Database) => ModerationService
 
@@ -438,24 +439,22 @@ export class ModerationService {
       takedownRef,
     }))
 
-    const [repoEvts] = await Promise.all([
-      this.db.db
-        .insertInto('repo_push_event')
-        .values(values)
-        .onConflict((oc) =>
-          oc.columns(['subjectDid', 'eventType']).doUpdateSet({
-            takedownRef,
-            confirmedAt: null,
-            attempts: 0,
-            lastAttempted: null,
-          }),
-        )
-        .returning('id')
-        .execute(),
-      this.formatAndCreateLabels(subject.did, null, {
-        create: [UNSPECCED_TAKEDOWN_LABEL],
-      }),
-    ])
+    const repoEvts = await this.db.db
+      .insertInto('repo_push_event')
+      .values(values)
+      .onConflict((oc) =>
+        oc.columns(['subjectDid', 'eventType']).doUpdateSet({
+          takedownRef,
+          confirmedAt: null,
+          attempts: 0,
+          lastAttempted: null,
+        }),
+      )
+      .returning('id')
+      .execute()
+    await this.formatAndCreateLabels(subject.did, null, {
+      create: [UNSPECCED_TAKEDOWN_LABEL],
+    })
 
     this.db.onCommit(() => {
       this.backgroundQueue.add(async () => {
@@ -467,23 +466,21 @@ export class ModerationService {
   }
 
   async reverseTakedownRepo(subject: RepoSubject) {
-    const [repoEvts] = await Promise.all([
-      this.db.db
-        .updateTable('repo_push_event')
-        .where('eventType', 'in', TAKEDOWNS)
-        .where('subjectDid', '=', subject.did)
-        .set({
-          takedownRef: null,
-          confirmedAt: null,
-          attempts: 0,
-          lastAttempted: null,
-        })
-        .returning('id')
-        .execute(),
-      this.formatAndCreateLabels(subject.did, null, {
-        negate: [UNSPECCED_TAKEDOWN_LABEL],
-      }),
-    ])
+    const repoEvts = await this.db.db
+      .updateTable('repo_push_event')
+      .where('eventType', 'in', TAKEDOWNS)
+      .where('subjectDid', '=', subject.did)
+      .set({
+        takedownRef: null,
+        confirmedAt: null,
+        attempts: 0,
+        lastAttempted: null,
+      })
+      .returning('id')
+      .execute()
+    await this.formatAndCreateLabels(subject.did, null, {
+      negate: [UNSPECCED_TAKEDOWN_LABEL],
+    })
 
     this.db.onCommit(() => {
       this.backgroundQueue.add(async () => {
@@ -509,22 +506,22 @@ export class ModerationService {
     if (blobCids && blobCids.length > 0) {
       labels.push(UNSPECCED_TAKEDOWN_BLOBS_LABEL)
     }
-    const [recordEvts] = await Promise.all([
-      this.db.db
-        .insertInto('record_push_event')
-        .values(values)
-        .onConflict((oc) =>
-          oc.columns(['subjectUri', 'eventType']).doUpdateSet({
-            takedownRef,
-            confirmedAt: null,
-            attempts: 0,
-            lastAttempted: null,
-          }),
-        )
-        .returning('id')
-        .execute(),
-      this.formatAndCreateLabels(subject.uri, subject.cid, { create: labels }),
-    ])
+    const recordEvts = await this.db.db
+      .insertInto('record_push_event')
+      .values(values)
+      .onConflict((oc) =>
+        oc.columns(['subjectUri', 'eventType']).doUpdateSet({
+          takedownRef,
+          confirmedAt: null,
+          attempts: 0,
+          lastAttempted: null,
+        }),
+      )
+      .returning('id')
+      .execute()
+    await this.formatAndCreateLabels(subject.uri, subject.cid, {
+      create: labels,
+    })
 
     this.db.onCommit(() => {
       this.backgroundQueue.add(async () => {
@@ -579,29 +576,31 @@ export class ModerationService {
     if (blobCids && blobCids.length > 0) {
       labels.push(UNSPECCED_TAKEDOWN_BLOBS_LABEL)
     }
-    const [recordEvts] = await Promise.all([
-      this.db.db
-        .updateTable('record_push_event')
-        .where('eventType', 'in', TAKEDOWNS)
-        .where('subjectDid', '=', subject.did)
-        .where('subjectUri', '=', subject.uri)
-        .set({
-          takedownRef: null,
-          confirmedAt: null,
-          attempts: 0,
-          lastAttempted: null,
+    const recordEvts = await this.db.db
+      .updateTable('record_push_event')
+      .where('eventType', 'in', TAKEDOWNS)
+      .where('subjectDid', '=', subject.did)
+      .where('subjectUri', '=', subject.uri)
+      .set({
+        takedownRef: null,
+        confirmedAt: null,
+        attempts: 0,
+        lastAttempted: null,
+      })
+      .returning('id')
+      .execute()
+    await this.formatAndCreateLabels(subject.uri, subject.cid, {
+      negate: labels,
+    }),
+      this.db.onCommit(() => {
+        this.backgroundQueue.add(async () => {
+          await Promise.all(
+            recordEvts.map((evt) =>
+              this.eventPusher.attemptRecordEvent(evt.id),
+            ),
+          )
         })
-        .returning('id')
-        .execute(),
-      this.formatAndCreateLabels(subject.uri, subject.cid, { negate: labels }),
-    ])
-    this.db.onCommit(() => {
-      this.backgroundQueue.add(async () => {
-        await Promise.all(
-          recordEvts.map((evt) => this.eventPusher.attemptRecordEvent(evt.id)),
-        )
       })
-    })
 
     if (blobCids && blobCids.length > 0) {
       const blobEvts = await this.db.db
@@ -858,12 +857,14 @@ export class ModerationService {
       neg: !!l.neg,
     }))
     const { ref } = this.db.db.dynamic
+    await sql`notify ${ref(LabelChannel)}`.execute(this.db.db)
     const excluded = (col: string) => ref(`excluded.${col}`)
     await this.db.db
       .insertInto('label')
       .values(dbVals)
       .onConflict((oc) =>
         oc.columns(['src', 'uri', 'cid', 'val']).doUpdateSet({
+          id: sql`${excluded('id')}`,
           neg: sql`${excluded('neg')}`,
           cts: sql`${excluded('cts')}`,
         }),

package/src/mod-service/status.ts

@@ -179,6 +179,9 @@ export const adjustModerationSubjectStatus = async (
     subjectStatus.appealed = true
     newStatus.lastAppealedAt = createdAt
     subjectStatus.lastAppealedAt = createdAt
+    // Set reviewState to escalated when appeal events are emitted
+    subjectStatus.reviewState = REVIEWESCALATED
+    newStatus.reviewState = REVIEWESCALATED
   }
 
   if (

package/src/mod-service/util.ts

@@ -0,0 +1,17 @@
+import { LabelRow } from '../db/schema/label'
+import { Label } from '../lexicon/types/com/atproto/label/defs'
+
+export const formatLabel = (row: LabelRow): Label => {
+  const label: Label = {
+    src: row.src,
+    uri: row.uri,
+    val: row.val,
+    neg: row.neg,
+    cts: row.cts,
+  }
+  if (row.cid !== '') {
+    // @NOTE avoiding undefined values on label, which dag-cbor chokes on when serializing.
+    label.cid = row.cid
+  }
+  return label
+}