@atproto/ozone 0.1.25 → 0.1.26

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,
+      }
+    })
+  }
+}