@sideline/domain 0.1.2 → 0.3.0

package/src/api/AgeThresholdApi.ts

@@ -0,0 +1,99 @@
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from '@effect/platform';
+import { Schema } from 'effect';
+import { AuthMiddleware } from '~/api/Auth.js';
+import { AgeThresholdRuleId } from '~/models/AgeThresholdRule.js';
+import { RoleId } from '~/models/Role.js';
+import { TeamId } from '~/models/Team.js';
+import { TeamMemberId } from '~/models/TeamMember.js';
+
+export class AgeThresholdInfo extends Schema.Class<AgeThresholdInfo>('AgeThresholdInfo')({
+  ruleId: AgeThresholdRuleId,
+  teamId: TeamId,
+  roleId: RoleId,
+  roleName: Schema.String,
+  minAge: Schema.NullOr(Schema.Number),
+  maxAge: Schema.NullOr(Schema.Number),
+}) {}
+
+export class AgeRoleChange extends Schema.Class<AgeRoleChange>('AgeRoleChange')({
+  memberId: TeamMemberId,
+  memberName: Schema.String,
+  roleId: RoleId,
+  roleName: Schema.String,
+  action: Schema.Literal('assigned', 'removed'),
+}) {}
+
+export class CreateAgeThresholdRequest extends Schema.Class<CreateAgeThresholdRequest>(
+  'CreateAgeThresholdRequest',
+)({
+  roleId: RoleId,
+  minAge: Schema.NullOr(Schema.Number),
+  maxAge: Schema.NullOr(Schema.Number),
+}) {}
+
+export class UpdateAgeThresholdRequest extends Schema.Class<UpdateAgeThresholdRequest>(
+  'UpdateAgeThresholdRequest',
+)({
+  minAge: Schema.NullOr(Schema.Number),
+  maxAge: Schema.NullOr(Schema.Number),
+}) {}
+
+export class Forbidden extends Schema.TaggedError<Forbidden>()(
+  'AgeThresholdForbidden',
+  {},
+  HttpApiSchema.annotations({ status: 403 }),
+) {}
+
+export class RuleNotFound extends Schema.TaggedError<RuleNotFound>()(
+  'AgeThresholdRuleNotFound',
+  {},
+  HttpApiSchema.annotations({ status: 404 }),
+) {}
+
+export class RoleNotFound extends Schema.TaggedError<RoleNotFound>()(
+  'AgeThresholdRoleNotFound',
+  {},
+  HttpApiSchema.annotations({ status: 404 }),
+) {}
+
+export class AgeThresholdApiGroup extends HttpApiGroup.make('ageThreshold')
+  .add(
+    HttpApiEndpoint.get('listAgeThresholds', '/teams/:teamId/age-thresholds')
+      .addSuccess(Schema.Array(AgeThresholdInfo))
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('createAgeThreshold', '/teams/:teamId/age-thresholds')
+      .addSuccess(AgeThresholdInfo, { status: 201 })
+      .addError(Forbidden, { status: 403 })
+      .addError(RoleNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .setPayload(CreateAgeThresholdRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.patch('updateAgeThreshold', '/teams/:teamId/age-thresholds/:ruleId')
+      .addSuccess(AgeThresholdInfo)
+      .addError(Forbidden, { status: 403 })
+      .addError(RuleNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, ruleId: AgeThresholdRuleId }))
+      .setPayload(UpdateAgeThresholdRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.del('deleteAgeThreshold', '/teams/:teamId/age-thresholds/:ruleId')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(RuleNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, ruleId: AgeThresholdRuleId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('evaluateAgeThresholds', '/teams/:teamId/age-thresholds/evaluate')
+      .addSuccess(Schema.Array(AgeRoleChange))
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .middleware(AuthMiddleware),
+  ) {}

package/src/api/Auth.ts

@@ -6,12 +6,21 @@ import {
   HttpApiSecurity,
 } from '@effect/platform';
 import { Context, Schema } from 'effect';
+import { Permission } from '~/models/Role.js';
+import { TeamId } from '~/models/Team.js';
 import { Gender, Locale, Position, Proficiency, UserId } from '~/models/User.js';
 
 export { UserId } from '~/models/User.js';
 
 export const MIN_AGE = 6;
 
+export class UserTeam extends Schema.Class<UserTeam>('UserTeam')({
+  teamId: TeamId,
+  teamName: Schema.String,
+  roleNames: Schema.Array(Schema.String),
+  permissions: Schema.Array(Permission),
+}) {}
+
 export class CurrentUser extends Schema.Class<CurrentUser>('CurrentUser')({
   id: UserId,
   discordId: Schema.String,
@@ -31,6 +40,10 @@ export class UpdateLocaleRequest extends Schema.Class<UpdateLocaleRequest>('Upda
   locale: Locale,
 }) {}
 
+export class CreateTeamRequest extends Schema.Class<CreateTeamRequest>('CreateTeamRequest')({
+  name: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(100)),
+}) {}
+
 export class CompleteProfileRequest extends Schema.Class<CompleteProfileRequest>(
   'CompleteProfileRequest',
 )({
@@ -50,6 +63,25 @@ export class CompleteProfileRequest extends Schema.Class<CompleteProfileRequest>
   proficiency: Proficiency,
 }) {}
 
+export class UpdateProfileRequest extends Schema.Class<UpdateProfileRequest>(
+  'UpdateProfileRequest',
+)({
+  name: Schema.NullOr(Schema.String),
+  birthYear: Schema.NullOr(
+    Schema.Number.pipe(
+      Schema.int(),
+      Schema.greaterThanOrEqualTo(1900),
+      Schema.filter((year) => year <= new Date().getFullYear() - MIN_AGE, {
+        message: () => `Birth year must be at most ${new Date().getFullYear() - MIN_AGE}`,
+      }),
+    ),
+  ),
+  gender: Schema.NullOr(Gender),
+  jerseyNumber: Schema.NullOr(Schema.Number.pipe(Schema.int(), Schema.between(0, 99))),
+  position: Schema.NullOr(Position),
+  proficiency: Schema.NullOr(Proficiency),
+}) {}
+
 export class Unauthorized extends Schema.TaggedError<Unauthorized>()(
   'Unauthorized',
   {},
@@ -101,4 +133,24 @@ export class AuthApiGroup extends HttpApiGroup.make('auth')
       .setPayload(UpdateLocaleRequest)
       .middleware(AuthMiddleware),
   )
+  .add(
+    HttpApiEndpoint.patch('updateProfile', '/me')
+      .addSuccess(CurrentUser)
+      .addError(Unauthorized, { status: 401 })
+      .setPayload(UpdateProfileRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.get('myTeams', '/me/teams')
+      .addSuccess(Schema.Array(UserTeam))
+      .addError(Unauthorized, { status: 401 })
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('createTeam', '/me/teams')
+      .addSuccess(UserTeam)
+      .addError(Unauthorized, { status: 401 })
+      .setPayload(CreateTeamRequest)
+      .middleware(AuthMiddleware),
+  )
   .prefix('/auth') {}

package/src/api/Invite.ts

@@ -2,7 +2,6 @@ import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from '@effect/platform';
 import { Schema } from 'effect';
 import { AuthMiddleware } from '~/api/Auth.js';
 import { TeamId } from '~/models/Team.js';
-import { TeamRole } from '~/models/TeamMember.js';
 
 export class InviteInfo extends Schema.Class<InviteInfo>('InviteInfo')({
   teamName: Schema.String,
@@ -12,7 +11,7 @@ export class InviteInfo extends Schema.Class<InviteInfo>('InviteInfo')({
 
 export class JoinResult extends Schema.Class<JoinResult>('JoinResult')({
   teamId: TeamId,
-  role: TeamRole,
+  roleNames: Schema.Array(Schema.String),
   isProfileComplete: Schema.Boolean,
 }) {}
 

package/src/api/NotificationApi.ts

@@ -0,0 +1,49 @@
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from '@effect/platform';
+import { Schema } from 'effect';
+import { AuthMiddleware } from '~/api/Auth.js';
+import { NotificationId, NotificationType } from '~/models/Notification.js';
+import { TeamId } from '~/models/Team.js';
+
+export class NotificationInfo extends Schema.Class<NotificationInfo>('NotificationInfo')({
+  notificationId: NotificationId,
+  teamId: TeamId,
+  type: NotificationType,
+  title: Schema.String,
+  body: Schema.String,
+  isRead: Schema.Boolean,
+  createdAt: Schema.String,
+}) {}
+
+export class Forbidden extends Schema.TaggedError<Forbidden>()(
+  'NotificationForbidden',
+  {},
+  HttpApiSchema.annotations({ status: 403 }),
+) {}
+
+export class NotificationNotFound extends Schema.TaggedError<NotificationNotFound>()(
+  'NotificationNotFound',
+  {},
+  HttpApiSchema.annotations({ status: 404 }),
+) {}
+
+export class NotificationApiGroup extends HttpApiGroup.make('notification')
+  .add(
+    HttpApiEndpoint.get('listNotifications', '/notifications')
+      .addSuccess(Schema.Array(NotificationInfo))
+      .addError(Forbidden, { status: 403 })
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.patch('markAsRead', '/notifications/:notificationId/read')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(NotificationNotFound, { status: 404 })
+      .setPath(Schema.Struct({ notificationId: NotificationId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('markAllAsRead', '/notifications/read-all')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .middleware(AuthMiddleware),
+  ) {}

package/src/api/RoleApi.ts

@@ -0,0 +1,130 @@
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from '@effect/platform';
+import { Schema } from 'effect';
+import { AuthMiddleware } from '~/api/Auth.js';
+import { Permission, RoleId } from '~/models/Role.js';
+import { TeamId } from '~/models/Team.js';
+import { TeamMemberId } from '~/models/TeamMember.js';
+
+export class RoleInfo extends Schema.Class<RoleInfo>('RoleInfo')({
+  roleId: RoleId,
+  teamId: TeamId,
+  name: Schema.String,
+  isBuiltIn: Schema.Boolean,
+  permissionCount: Schema.Number,
+}) {}
+
+export class RoleDetail extends Schema.Class<RoleDetail>('RoleDetail')({
+  roleId: RoleId,
+  teamId: TeamId,
+  name: Schema.String,
+  isBuiltIn: Schema.Boolean,
+  permissions: Schema.Array(Permission),
+}) {}
+
+export class CreateRoleRequest extends Schema.Class<CreateRoleRequest>('CreateRoleRequest')({
+  name: Schema.NonEmptyString,
+  permissions: Schema.Array(Permission),
+}) {}
+
+export class UpdateRoleRequest extends Schema.Class<UpdateRoleRequest>('UpdateRoleRequest')({
+  name: Schema.NullOr(Schema.NonEmptyString),
+  permissions: Schema.NullOr(Schema.Array(Permission)),
+}) {}
+
+export class RoleNotFound extends Schema.TaggedError<RoleNotFound>()(
+  'RoleNotFound',
+  {},
+  HttpApiSchema.annotations({ status: 404 }),
+) {}
+
+export class Forbidden extends Schema.TaggedError<Forbidden>()(
+  'RoleForbidden',
+  {},
+  HttpApiSchema.annotations({ status: 403 }),
+) {}
+
+export class CannotModifyBuiltIn extends Schema.TaggedError<CannotModifyBuiltIn>()(
+  'CannotModifyBuiltIn',
+  {},
+  HttpApiSchema.annotations({ status: 400 }),
+) {}
+
+export class AssignRoleRequest extends Schema.Class<AssignRoleRequest>('AssignRoleRequest')({
+  roleId: RoleId,
+}) {}
+
+export class MemberNotFound extends Schema.TaggedError<MemberNotFound>()(
+  'MemberNotFound',
+  {},
+  HttpApiSchema.annotations({ status: 404 }),
+) {}
+
+export class RoleInUse extends Schema.TaggedError<RoleInUse>()(
+  'RoleInUse',
+  {},
+  HttpApiSchema.annotations({ status: 409 }),
+) {}
+
+export class RoleApiGroup extends HttpApiGroup.make('role')
+  .add(
+    HttpApiEndpoint.get('listRoles', '/teams/:teamId/roles')
+      .addSuccess(Schema.Array(RoleInfo))
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('createRole', '/teams/:teamId/roles')
+      .addSuccess(RoleDetail, { status: 201 })
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .setPayload(CreateRoleRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.get('getRole', '/teams/:teamId/roles/:roleId')
+      .addSuccess(RoleDetail)
+      .addError(Forbidden, { status: 403 })
+      .addError(RoleNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, roleId: RoleId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.patch('updateRole', '/teams/:teamId/roles/:roleId')
+      .addSuccess(RoleDetail)
+      .addError(Forbidden, { status: 403 })
+      .addError(RoleNotFound, { status: 404 })
+      .addError(CannotModifyBuiltIn, { status: 400 })
+      .setPath(Schema.Struct({ teamId: TeamId, roleId: RoleId }))
+      .setPayload(UpdateRoleRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.del('deleteRole', '/teams/:teamId/roles/:roleId')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(RoleNotFound, { status: 404 })
+      .addError(CannotModifyBuiltIn, { status: 400 })
+      .addError(RoleInUse, { status: 409 })
+      .setPath(Schema.Struct({ teamId: TeamId, roleId: RoleId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('assignRole', '/teams/:teamId/members/:memberId/roles')
+      .addSuccess(Schema.Void, { status: 204 })
+      .addError(Forbidden, { status: 403 })
+      .addError(MemberNotFound, { status: 404 })
+      .addError(RoleNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, memberId: TeamMemberId }))
+      .setPayload(AssignRoleRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.del('unassignRole', '/teams/:teamId/members/:memberId/roles/:roleId')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(MemberNotFound, { status: 404 })
+      .addError(RoleNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, memberId: TeamMemberId, roleId: RoleId }))
+      .middleware(AuthMiddleware),
+  ) {}

package/src/api/Roster.ts

@@ -0,0 +1,176 @@
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from '@effect/platform';
+import { Schema } from 'effect';
+import { AuthMiddleware } from '~/api/Auth.js';
+import { Permission } from '~/models/Role.js';
+import { RosterId } from '~/models/RosterModel.js';
+import { TeamId } from '~/models/Team.js';
+import { TeamMemberId } from '~/models/TeamMember.js';
+import { Gender, Position, Proficiency, UserId } from '~/models/User.js';
+
+export class RosterPlayer extends Schema.Class<RosterPlayer>('RosterPlayer')({
+  memberId: TeamMemberId,
+  userId: UserId,
+  roleNames: Schema.Array(Schema.String),
+  permissions: Schema.Array(Permission),
+  name: Schema.NullOr(Schema.String),
+  birthYear: Schema.NullOr(Schema.Number),
+  gender: Schema.NullOr(Gender),
+  jerseyNumber: Schema.NullOr(Schema.Number),
+  position: Schema.NullOr(Position),
+  proficiency: Schema.NullOr(Proficiency),
+  discordUsername: Schema.String,
+  discordAvatar: Schema.NullOr(Schema.String),
+}) {}
+
+export class UpdatePlayerRequest extends Schema.Class<UpdatePlayerRequest>('UpdatePlayerRequest')({
+  name: Schema.NullOr(Schema.String),
+  birthYear: Schema.NullOr(Schema.Number),
+  gender: Schema.NullOr(Gender),
+  jerseyNumber: Schema.NullOr(Schema.Number),
+  position: Schema.NullOr(Position),
+  proficiency: Schema.NullOr(Proficiency),
+}) {}
+
+export class PlayerNotFound extends Schema.TaggedError<PlayerNotFound>()(
+  'PlayerNotFound',
+  {},
+  HttpApiSchema.annotations({ status: 404 }),
+) {}
+
+export class Forbidden extends Schema.TaggedError<Forbidden>()(
+  'Forbidden',
+  {},
+  HttpApiSchema.annotations({ status: 403 }),
+) {}
+
+export class RosterNotFound extends Schema.TaggedError<RosterNotFound>()(
+  'RosterNotFound',
+  {},
+  HttpApiSchema.annotations({ status: 404 }),
+) {}
+
+export class RosterInfo extends Schema.Class<RosterInfo>('RosterInfo')({
+  rosterId: RosterId,
+  teamId: TeamId,
+  name: Schema.String,
+  active: Schema.Boolean,
+  memberCount: Schema.Number,
+  createdAt: Schema.String,
+}) {}
+
+export class RosterDetail extends Schema.Class<RosterDetail>('RosterDetail')({
+  rosterId: RosterId,
+  teamId: TeamId,
+  name: Schema.String,
+  active: Schema.Boolean,
+  createdAt: Schema.String,
+  members: Schema.Array(RosterPlayer),
+}) {}
+
+export class CreateRosterRequest extends Schema.Class<CreateRosterRequest>('CreateRosterRequest')({
+  name: Schema.String,
+}) {}
+
+export class UpdateRosterRequest extends Schema.Class<UpdateRosterRequest>('UpdateRosterRequest')({
+  name: Schema.NullOr(Schema.String),
+  active: Schema.NullOr(Schema.Boolean),
+}) {}
+
+export class AddRosterMemberRequest extends Schema.Class<AddRosterMemberRequest>(
+  'AddRosterMemberRequest',
+)({
+  memberId: TeamMemberId,
+}) {}
+
+export class RosterApiGroup extends HttpApiGroup.make('roster')
+  .add(
+    HttpApiEndpoint.get('listMembers', '/teams/:teamId/members')
+      .addSuccess(Schema.Array(RosterPlayer))
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.get('getMember', '/teams/:teamId/members/:memberId')
+      .addSuccess(RosterPlayer)
+      .addError(Forbidden, { status: 403 })
+      .addError(PlayerNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, memberId: TeamMemberId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.patch('updateMember', '/teams/:teamId/members/:memberId')
+      .addSuccess(RosterPlayer)
+      .addError(Forbidden, { status: 403 })
+      .addError(PlayerNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, memberId: TeamMemberId }))
+      .setPayload(UpdatePlayerRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.del('deactivateMember', '/teams/:teamId/members/:memberId')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(PlayerNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, memberId: TeamMemberId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.get('listRosters', '/teams/:teamId/rosters')
+      .addSuccess(Schema.Array(RosterInfo))
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('createRoster', '/teams/:teamId/rosters')
+      .addSuccess(RosterInfo, { status: 201 })
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .setPayload(CreateRosterRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.get('getRoster', '/teams/:teamId/rosters/:rosterId')
+      .addSuccess(RosterDetail)
+      .addError(Forbidden, { status: 403 })
+      .addError(RosterNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, rosterId: RosterId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.patch('updateRoster', '/teams/:teamId/rosters/:rosterId')
+      .addSuccess(RosterInfo)
+      .addError(Forbidden, { status: 403 })
+      .addError(RosterNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, rosterId: RosterId }))
+      .setPayload(UpdateRosterRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.del('deleteRoster', '/teams/:teamId/rosters/:rosterId')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(RosterNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, rosterId: RosterId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('addRosterMember', '/teams/:teamId/rosters/:rosterId/members')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(RosterNotFound, { status: 404 })
+      .addError(PlayerNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, rosterId: RosterId }))
+      .setPayload(AddRosterMemberRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.del('removeRosterMember', '/teams/:teamId/rosters/:rosterId/members/:memberId')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(RosterNotFound, { status: 404 })
+      .addError(PlayerNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, rosterId: RosterId, memberId: TeamMemberId }))
+      .middleware(AuthMiddleware),
+  ) {}