@atproto/ozone 0.1.24 → 0.1.26

package/src/lexicon/lexicons.ts

@@ -11006,6 +11006,226 @@ export const schemaDict = {
       },
     },
   },
+  ToolsOzoneTeamAddMember: {
+    lexicon: 1,
+    id: 'tools.ozone.team.addMember',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Add a member to the ozone team. Requires admin role.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['did', 'role'],
+            properties: {
+              did: {
+                type: 'string',
+                format: 'did',
+              },
+              role: {
+                type: 'string',
+                knownValues: [
+                  'tools.ozone.team.defs#roleAdmin',
+                  'tools.ozone.team.defs#roleModerator',
+                  'tools.ozone.team.defs#roleTriage',
+                ],
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:tools.ozone.team.defs#member',
+          },
+        },
+        errors: [
+          {
+            name: 'MemberAlreadyExists',
+            description: 'Member already exists in the team.',
+          },
+        ],
+      },
+    },
+  },
+  ToolsOzoneTeamDefs: {
+    lexicon: 1,
+    id: 'tools.ozone.team.defs',
+    defs: {
+      member: {
+        type: 'object',
+        required: ['did', 'role'],
+        properties: {
+          did: {
+            type: 'string',
+            format: 'did',
+          },
+          disabled: {
+            type: 'boolean',
+          },
+          profile: {
+            type: 'ref',
+            ref: 'lex:app.bsky.actor.defs#profileViewDetailed',
+          },
+          createdAt: {
+            type: 'string',
+            format: 'datetime',
+          },
+          updatedAt: {
+            type: 'string',
+            format: 'datetime',
+          },
+          lastUpdatedBy: {
+            type: 'string',
+          },
+          role: {
+            type: 'string',
+            knownValues: [
+              'lex:tools.ozone.team.defs#roleAdmin',
+              'lex:tools.ozone.team.defs#roleModerator',
+              'lex:tools.ozone.team.defs#roleTriage',
+            ],
+          },
+        },
+      },
+      roleAdmin: {
+        type: 'token',
+        description:
+          'Admin role. Highest level of access, can perform all actions.',
+      },
+      roleModerator: {
+        type: 'token',
+        description: 'Moderator role. Can perform most actions.',
+      },
+      roleTriage: {
+        type: 'token',
+        description:
+          'Triage role. Mostly intended for monitoring and escalating issues.',
+      },
+    },
+  },
+  ToolsOzoneTeamDeleteMember: {
+    lexicon: 1,
+    id: 'tools.ozone.team.deleteMember',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Delete a member from ozone team. Requires admin role.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['did'],
+            properties: {
+              did: {
+                type: 'string',
+                format: 'did',
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'MemberNotFound',
+            description: 'The member being deleted does not exist',
+          },
+        ],
+      },
+    },
+  },
+  ToolsOzoneTeamListMembers: {
+    lexicon: 1,
+    id: 'tools.ozone.team.listMembers',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'List all members with access to the ozone service.',
+        parameters: {
+          type: 'params',
+          properties: {
+            limit: {
+              type: 'integer',
+              minimum: 1,
+              maximum: 100,
+              default: 50,
+            },
+            cursor: {
+              type: 'string',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['members'],
+            properties: {
+              cursor: {
+                type: 'string',
+              },
+              members: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:tools.ozone.team.defs#member',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  ToolsOzoneTeamUpdateMember: {
+    lexicon: 1,
+    id: 'tools.ozone.team.updateMember',
+    defs: {
+      main: {
+        type: 'procedure',
+        description:
+          'Update a member in the ozone service. Requires admin role.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['did'],
+            properties: {
+              did: {
+                type: 'string',
+                format: 'did',
+              },
+              disabled: {
+                type: 'boolean',
+              },
+              role: {
+                type: 'string',
+                knownValues: [
+                  'tools.ozone.team.defs#roleAdmin',
+                  'tools.ozone.team.defs#roleModerator',
+                  'tools.ozone.team.defs#roleTriage',
+                ],
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:tools.ozone.team.defs#member',
+          },
+        },
+        errors: [
+          {
+            name: 'MemberNotFound',
+            description: 'The member being updated does not exist in the team',
+          },
+        ],
+      },
+    },
+  },
 }
 export const schemas: LexiconDoc[] = Object.values(schemaDict) as LexiconDoc[]
 export const lexicons: Lexicons = new Lexicons(schemas)
@@ -11216,4 +11436,9 @@ export const ids = {
   ToolsOzoneModerationQueryStatuses: 'tools.ozone.moderation.queryStatuses',
   ToolsOzoneModerationSearchRepos: 'tools.ozone.moderation.searchRepos',
   ToolsOzoneServerGetConfig: 'tools.ozone.server.getConfig',
+  ToolsOzoneTeamAddMember: 'tools.ozone.team.addMember',
+  ToolsOzoneTeamDefs: 'tools.ozone.team.defs',
+  ToolsOzoneTeamDeleteMember: 'tools.ozone.team.deleteMember',
+  ToolsOzoneTeamListMembers: 'tools.ozone.team.listMembers',
+  ToolsOzoneTeamUpdateMember: 'tools.ozone.team.updateMember',
 }

package/src/lexicon/types/tools/ozone/team/addMember.ts

@@ -0,0 +1,53 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import * as ToolsOzoneTeamDefs from './defs'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  did: string
+  role:
+    | 'tools.ozone.team.defs#roleAdmin'
+    | 'tools.ozone.team.defs#roleModerator'
+    | 'tools.ozone.team.defs#roleTriage'
+    | (string & {})
+  [k: string]: unknown
+}
+
+export type OutputSchema = ToolsOzoneTeamDefs.Member
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?: 'MemberAlreadyExists'
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

package/src/lexicon/types/tools/ozone/team/defs.ts

@@ -0,0 +1,42 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import * as AppBskyActorDefs from '../../../app/bsky/actor/defs'
+
+export interface Member {
+  did: string
+  disabled?: boolean
+  profile?: AppBskyActorDefs.ProfileViewDetailed
+  createdAt?: string
+  updatedAt?: string
+  lastUpdatedBy?: string
+  role:
+    | 'lex:tools.ozone.team.defs#roleAdmin'
+    | 'lex:tools.ozone.team.defs#roleModerator'
+    | 'lex:tools.ozone.team.defs#roleTriage'
+    | (string & {})
+  [k: string]: unknown
+}
+
+export function isMember(v: unknown): v is Member {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'tools.ozone.team.defs#member'
+  )
+}
+
+export function validateMember(v: unknown): ValidationResult {
+  return lexicons.validate('tools.ozone.team.defs#member', v)
+}
+
+/** Admin role. Highest level of access, can perform all actions. */
+export const ROLEADMIN = 'tools.ozone.team.defs#roleAdmin'
+/** Moderator role. Can perform most actions. */
+export const ROLEMODERATOR = 'tools.ozone.team.defs#roleModerator'
+/** Triage role. Mostly intended for monitoring and escalating issues. */
+export const ROLETRIAGE = 'tools.ozone.team.defs#roleTriage'

package/src/lexicon/types/tools/ozone/team/deleteMember.ts

@@ -0,0 +1,39 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  did: string
+  [k: string]: unknown
+}
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?: 'MemberNotFound'
+}
+
+export type HandlerOutput = HandlerError | void
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

package/src/lexicon/types/tools/ozone/team/listMembers.ts

@@ -0,0 +1,48 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import * as ToolsOzoneTeamDefs from './defs'
+
+export interface QueryParams {
+  limit: number
+  cursor?: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  cursor?: string
+  members: ToolsOzoneTeamDefs.Member[]
+  [k: string]: unknown
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

package/src/lexicon/types/tools/ozone/team/updateMember.ts

@@ -0,0 +1,54 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import * as ToolsOzoneTeamDefs from './defs'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  did: string
+  disabled?: boolean
+  role?:
+    | 'tools.ozone.team.defs#roleAdmin'
+    | 'tools.ozone.team.defs#roleModerator'
+    | 'tools.ozone.team.defs#roleTriage'
+    | (string & {})
+  [k: string]: unknown
+}
+
+export type OutputSchema = ToolsOzoneTeamDefs.Member
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?: 'MemberNotFound'
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

package/src/team/index.ts

@@ -0,0 +1,213 @@
+import Database from '../db'
+import { Selectable } from 'kysely'
+import { Member } from '../db/schema/member'
+import { Member as TeamMember } from '../lexicon/types/tools/ozone/team/defs'
+import { ProfileViewDetailed } from '../lexicon/types/app/bsky/actor/defs'
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { chunkArray } from '@atproto/common'
+import AppContext from '../context'
+import { httpLogger } from '../logger'
+
+export type TeamServiceCreator = (db: Database) => TeamService
+
+export class TeamService {
+  constructor(public db: Database) {}
+
+  static creator() {
+    return (db: Database) => new TeamService(db)
+  }
+
+  async list({
+    cursor,
+    limit = 25,
+  }: {
+    cursor?: string
+    limit?: number
+  }): Promise<{ members: Selectable<Member>[]; cursor?: string }> {
+    let builder = this.db.db.selectFrom('member').selectAll()
+    if (cursor) {
+      builder = builder.where('createdAt', '>', new Date(cursor))
+    }
+    const members = await builder
+      .limit(limit)
+      .orderBy('createdAt', 'asc')
+      .execute()
+
+    return { members, cursor: members.at(-1)?.createdAt.toISOString() }
+  }
+
+  async create({
+    role,
+    did,
+    disabled,
+    updatedAt,
+    createdAt,
+    lastUpdatedBy,
+  }: Omit<Selectable<Member>, 'createdAt' | 'updatedAt'> & {
+    createdAt?: Date
+    updatedAt?: Date
+  }): Promise<Selectable<Member>> {
+    const now = new Date()
+    const newMember = await this.db.db
+      .insertInto('member')
+      .values({
+        role,
+        did,
+        disabled,
+        lastUpdatedBy,
+        updatedAt: updatedAt || now,
+        createdAt: createdAt || now,
+      })
+      .returningAll()
+      .executeTakeFirstOrThrow()
+
+    return newMember
+  }
+
+  async upsert({
+    role,
+    did,
+    lastUpdatedBy,
+  }: Pick<
+    Selectable<Member>,
+    'role' | 'did' | 'lastUpdatedBy'
+  >): Promise<void> {
+    const now = new Date()
+    await this.db.db
+      .insertInto('member')
+      .values({
+        role,
+        did,
+        lastUpdatedBy,
+        disabled: false,
+        updatedAt: now,
+        createdAt: now,
+      })
+      .onConflict((oc) =>
+        oc.column('did').doUpdateSet({ role, updatedAt: now, lastUpdatedBy }),
+      )
+      .execute()
+  }
+
+  async update(
+    did: string,
+    updates: Partial<
+      Pick<
+        Selectable<Member>,
+        'role' | 'disabled' | 'lastUpdatedBy' | 'updatedAt'
+      >
+    >,
+  ): Promise<Selectable<Member>> {
+    const { role, disabled, lastUpdatedBy, updatedAt = new Date() } = updates
+    const updatedMember = await this.db.db
+      .updateTable('member')
+      .where('did', '=', did)
+      .set({
+        role,
+        disabled,
+        lastUpdatedBy,
+        updatedAt,
+      })
+      .returningAll()
+      .executeTakeFirstOrThrow()
+
+    return updatedMember
+  }
+
+  async delete(did: string): Promise<void> {
+    await this.db.db.deleteFrom('member').where('did', '=', did).execute()
+  }
+
+  async assertCanDelete(did: string): Promise<void> {
+    const memberExists = await this.doesMemberExist(did)
+
+    if (!memberExists) {
+      throw new InvalidRequestError('member not found', 'MemberNotFound')
+    }
+  }
+
+  async doesMemberExist(did: string): Promise<boolean> {
+    const member = await this.db.db
+      .selectFrom('member')
+      .select('did')
+      .where('did', '=', did)
+      .executeTakeFirst()
+
+    return !!member
+  }
+
+  async getMember(did: string): Promise<Selectable<Member> | undefined> {
+    const member = await this.db.db
+      .selectFrom('member')
+      .selectAll()
+      .where('did', '=', did)
+      .executeTakeFirst()
+
+    return member
+  }
+
+  getMemberRole(member?: Selectable<Member>) {
+    const isAdmin = member?.role === 'tools.ozone.team.defs#roleAdmin'
+    const isModerator =
+      isAdmin || member?.role === 'tools.ozone.team.defs#roleModerator'
+    const isTriage =
+      isModerator || member?.role === 'tools.ozone.team.defs#roleTriage'
+
+    return {
+      isModerator,
+      isAdmin,
+      isTriage,
+    }
+  }
+
+  // getProfiles() only allows 25 DIDs at a time so we need to query in chunks
+  async getProfiles(
+    dids: string[],
+    ctx: AppContext,
+  ): Promise<Map<string, ProfileViewDetailed>> {
+    const profiles = new Map<string, ProfileViewDetailed>()
+
+    try {
+      const headers = await ctx.appviewAuth()
+
+      for (const actors of chunkArray(dids, 25)) {
+        const { data } = await ctx.appviewAgent.api.app.bsky.actor.getProfiles(
+          { actors },
+          headers,
+        )
+
+        data.profiles.forEach((profile) => {
+          profiles.set(profile.did, profile)
+        })
+      }
+    } catch (error) {
+      httpLogger.error(
+        { error, dids },
+        'Failed to get profiles for team members',
+      )
+    }
+
+    return profiles
+  }
+
+  async view(
+    members: Selectable<Member>[],
+    ctx: AppContext,
+  ): Promise<TeamMember[]> {
+    const profiles = await this.getProfiles(
+      members.map(({ did }) => did),
+      ctx,
+    )
+    return members.map((member) => {
+      return {
+        did: member.did,
+        role: member.role,
+        disabled: member.disabled,
+        profile: profiles.get(member.did),
+        createdAt: member.createdAt.toISOString(),
+        updatedAt: member.updatedAt.toISOString(),
+        lastUpdatedBy: member.lastUpdatedBy,
+      }
+    })
+  }
+}