@atproto/ozone 0.2.8 → 0.2.11

package/src/api/set/upsertSet.ts

@@ -1,38 +0,0 @@
-import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.set.upsertSet({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const access = auth.credentials
-      const db = ctx.db
-      const { name, description } = input.body
-
-      if (!access.isModerator) {
-        throw new AuthRequiredError(
-          'Must be a moderator to create or update a set',
-        )
-      }
-
-      const setService = ctx.setService(db)
-
-      await setService.upsert({
-        name,
-        description: description ?? null,
-      })
-      const setWithSize = await setService.getByNameWithSize(name)
-
-      // Unlikely to happen since we just upserted the set
-      if (!setWithSize) {
-        throw new InvalidRequestError(`Set not found`)
-      }
-
-      return {
-        encoding: 'application/json',
-        body: setService.view(setWithSize),
-      }
-    },
-  })
-}

package/src/api/setting/listOptions.ts

@@ -1,44 +0,0 @@
-import { AuthRequiredError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.setting.listOptions({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params, auth }) => {
-      const access = auth.credentials
-      const db = ctx.db
-      const { prefix, scope, keys, limit, cursor } = params
-      let did = ctx.cfg.service.did
-
-      if (scope === 'personal') {
-        if (access.type !== 'moderator') {
-          throw new AuthRequiredError(
-            'Must use moderator auth to get personal set details',
-          )
-        }
-
-        did = access.iss
-      }
-
-      const settingService = ctx.settingService(db)
-
-      const result = await settingService.query({
-        scope: scope === 'personal' ? 'personal' : 'instance',
-        did,
-        keys,
-        prefix,
-        limit,
-        cursor,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: {
-          options: result.options.map((option) => settingService.view(option)),
-          cursor: result.cursor,
-        },
-      }
-    },
-  })
-}

package/src/api/setting/removeOptions.ts

@@ -1,64 +0,0 @@
-import { AuthRequiredError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Member } from '../../db/schema/member.js'
-import { Server } from '../../lexicon/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.setting.removeOptions({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const access = auth.credentials
-      const db = ctx.db
-      const { keys, scope } = input.body
-      let did = ctx.cfg.service.did
-      let managerRole: Member['role'][] = []
-
-      if (scope === 'personal') {
-        if (access.type !== 'moderator') {
-          throw new AuthRequiredError(
-            'Must use moderator auth to delete personal setting',
-          )
-        }
-
-        did = access.iss
-      }
-
-      // When attempting to delete an instance setting using admin_token will allow removing any setting
-      // otherwise, admins can remove settings that are manageable by all roles
-      // moderators can remove settings that are manageable by moderator and triage roles
-      // triage can remove settings that are manageable by triage role
-      if (scope === 'instance') {
-        managerRole = [
-          'tools.ozone.team.defs#roleModerator',
-          'tools.ozone.team.defs#roleTriage',
-          'tools.ozone.team.defs#roleAdmin',
-          'tools.ozone.team.defs#roleVerifier',
-        ]
-
-        if (access.type !== 'admin_token' && !access.isAdmin) {
-          if (access.isModerator) {
-            managerRole = [
-              'tools.ozone.team.defs#roleModerator',
-              'tools.ozone.team.defs#roleTriage',
-            ]
-          } else if (access.isTriage) {
-            managerRole = ['tools.ozone.team.defs#roleTriage']
-          }
-        }
-      }
-
-      const settingService = ctx.settingService(db)
-
-      await settingService.removeOptions(keys, {
-        scope: scope === 'personal' ? 'personal' : 'instance',
-        managerRole,
-        did,
-      })
-
-      return {
-        encoding: 'application/json',
-        body: {},
-      }
-    },
-  })
-}

package/src/api/setting/upsertOption.ts

@@ -1,156 +0,0 @@
-import assert from 'node:assert'
-import { ToolsOzoneTeamDefs } from '@atproto/api'
-import { AuthRequiredError } from '@atproto/xrpc-server'
-import { AdminTokenOutput, ModeratorOutput } from '../../auth-verifier.js'
-import { AppContext } from '../../context.js'
-import { Member } from '../../db/schema/member.js'
-import { Server } from '../../lexicon/index.js'
-import { SettingService } from '../../setting/service.js'
-import { settingValidators } from '../../setting/validators.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.setting.upsertOption({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const access = auth.credentials
-      const db = ctx.db
-      const { key, value, description, managerRole, scope } = input.body
-      const serviceDid = ctx.cfg.service.did
-      let ownerDid = serviceDid
-
-      if (scope === 'personal' && access.type !== 'moderator') {
-        throw new AuthRequiredError(
-          'Must use moderator auth to create or update a personal setting',
-        )
-      }
-
-      // if the caller is using moderator auth and storing personal setting
-      // use the caller's DID as the owner
-      if (scope === 'personal' && access.type === 'moderator') {
-        ownerDid = access.iss
-      }
-
-      const now = new Date()
-      const baseOption = {
-        key,
-        value,
-        did: ownerDid,
-        createdBy: ownerDid,
-        lastUpdatedBy: ownerDid,
-        description: description || '',
-        createdAt: now,
-        updatedAt: now,
-      }
-
-      const settingService = ctx.settingService(db)
-      if (scope === 'personal') {
-        await settingService.upsert({
-          ...baseOption,
-          scope: 'personal',
-          managerRole: null,
-        })
-      } else {
-        const manageableRoles = getRolesForInstanceOption(access)
-        const existingSetting = await getExistingSetting(
-          settingService,
-          ownerDid,
-          key,
-          'instance',
-        )
-
-        if (
-          existingSetting?.managerRole &&
-          !manageableRoles.includes(existingSetting.managerRole)
-        ) {
-          throw new AuthRequiredError(`Not permitted to update setting ${key}`)
-        }
-        const option = {
-          ...baseOption,
-          scope: 'instance' as const,
-          managerRole: getManagerRole(managerRole),
-        }
-
-        if (settingValidators.has(key)) {
-          await settingValidators.get(key)?.(option)
-        }
-
-        await settingService.upsert(option)
-      }
-
-      const newOption = await getExistingSetting(
-        settingService,
-        ownerDid,
-        key,
-        scope,
-      )
-      assert(newOption, 'Failed to get the updated setting')
-
-      return {
-        encoding: 'application/json',
-        body: {
-          option: settingService.view(newOption),
-        },
-      }
-    },
-  })
-}
-
-const getExistingSetting = async (
-  settingService: SettingService,
-  did: string,
-  key: string,
-  scope: string,
-) => {
-  const result = await settingService.query({
-    scope: scope === 'personal' ? 'personal' : 'instance',
-    keys: [key],
-    limit: 1,
-    did,
-  })
-
-  return result.options[0]
-}
-
-const getRolesForInstanceOption = (
-  access: AdminTokenOutput['credentials'] | ModeratorOutput['credentials'],
-) => {
-  const fullPermission = [
-    ToolsOzoneTeamDefs.ROLEADMIN,
-    ToolsOzoneTeamDefs.ROLEMODERATOR,
-    ToolsOzoneTeamDefs.ROLETRIAGE,
-    ToolsOzoneTeamDefs.ROLEVERIFIER,
-  ]
-  if (access.type === 'admin_token') {
-    return fullPermission
-  }
-
-  if (access.isAdmin) {
-    return fullPermission
-  }
-
-  if (access.isModerator) {
-    return [ToolsOzoneTeamDefs.ROLEMODERATOR, ToolsOzoneTeamDefs.ROLETRIAGE]
-  }
-
-  if (access.isVerifier) {
-    return [ToolsOzoneTeamDefs.ROLEVERIFIER]
-  }
-
-  return [ToolsOzoneTeamDefs.ROLETRIAGE]
-}
-
-const getManagerRole = (role?: string) => {
-  let managerRole: Member['role'] | null = null
-
-  if (role === ToolsOzoneTeamDefs.ROLEADMIN) {
-    managerRole = ToolsOzoneTeamDefs.ROLEADMIN
-  } else if (role === ToolsOzoneTeamDefs.ROLEMODERATOR) {
-    managerRole = ToolsOzoneTeamDefs.ROLEMODERATOR
-  } else if (role === ToolsOzoneTeamDefs.ROLETRIAGE) {
-    managerRole = ToolsOzoneTeamDefs.ROLETRIAGE
-  } else if (role === ToolsOzoneTeamDefs.ROLEVERIFIER) {
-    managerRole = ToolsOzoneTeamDefs.ROLEVERIFIER
-  }
-
-  return managerRole
-}

package/src/api/team/addMember.ts

@@ -1,51 +0,0 @@
-import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { getMemberRole } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.team.addMember({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const access = auth.credentials
-      const db = ctx.db
-      const { did, role } = input.body
-
-      if (!access.isAdmin) {
-        throw new AuthRequiredError('Must be an admin to add a member')
-      }
-
-      const newMember = await db.transaction(async (dbTxn) => {
-        const teamService = ctx.teamService(dbTxn)
-        const alreadyExists = await teamService.doesMemberExist(did)
-
-        if (alreadyExists) {
-          throw new InvalidRequestError(
-            'member already exists',
-            'MemberAlreadyExists',
-          )
-        }
-
-        const profiles = await teamService.getProfiles([did])
-        const profile = profiles.get(did)
-
-        const member = await teamService.create({
-          did,
-          handle: profile?.handle || null,
-          displayName: profile?.displayName || null,
-          disabled: false,
-          role: getMemberRole(role),
-          lastUpdatedBy:
-            access.type === 'admin_token' ? 'admin_token' : access.iss,
-        })
-        const memberView = await teamService.view([member])
-        return memberView[0]
-      })
-
-      return {
-        encoding: 'application/json',
-        body: newMember,
-      }
-    },
-  })
-}

package/src/api/team/deleteMember.ts

@@ -1,29 +0,0 @@
-import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.team.deleteMember({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const access = auth.credentials
-      const db = ctx.db
-      const { did } = input.body
-
-      if (!access.isAdmin) {
-        throw new AuthRequiredError('Must be an admin to delete a member')
-      }
-      if ('did' in auth.credentials && did === auth.credentials.did) {
-        throw new InvalidRequestError(
-          'You can not delete yourself from the team',
-          'CannotDeleteSelf',
-        )
-      }
-      await db.transaction(async (dbTxn) => {
-        const teamService = ctx.teamService(dbTxn)
-        await teamService.assertCanDelete(did)
-        await teamService.delete(did)
-      })
-    },
-  })
-}

package/src/api/team/listMembers.ts

@@ -1,20 +0,0 @@
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.team.listMembers({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ params }) => {
-      const teamService = ctx.teamService(ctx.db)
-      const { members, cursor } = await teamService.list(params)
-
-      return {
-        encoding: 'application/json',
-        body: {
-          cursor,
-          members: await teamService.view(members),
-        },
-      }
-    },
-  })
-}

package/src/api/team/updateMember.ts

@@ -1,47 +0,0 @@
-import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
-import { AppContext } from '../../context.js'
-import { Server } from '../../lexicon/index.js'
-import { getMemberRole } from '../util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.tools.ozone.team.updateMember({
-    auth: ctx.authVerifier.modOrAdminToken,
-    handler: async ({ input, auth }) => {
-      const access = auth.credentials
-      const db = ctx.db
-      const { did, role, ...rest } = input.body
-
-      if (!access.isAdmin) {
-        throw new AuthRequiredError('Must be an admin to update a member')
-      }
-
-      if (did === ctx.cfg.service.did) {
-        throw new InvalidRequestError('Can not update service owner')
-      }
-
-      const updatedMember = await db.transaction(async (dbTxn) => {
-        const teamService = ctx.teamService(dbTxn)
-
-        const memberExists = await teamService.doesMemberExist(did)
-
-        if (!memberExists) {
-          throw new InvalidRequestError('member not found', 'MemberNotFound')
-        }
-
-        const updated = await teamService.update(did, {
-          ...rest,
-          ...(role ? { role: getMemberRole(role) } : {}),
-          lastUpdatedBy:
-            access.type === 'admin_token' ? 'admin_token' : access.iss,
-        })
-        const memberView = await teamService.view([updated])
-        return memberView[0]
-      })
-
-      return {
-        encoding: 'application/json',
-        body: updatedMember,
-      }
-    },
-  })
-}