@sideline/domain 0.3.0 → 0.5.0

package/src/api/Auth.ts

@@ -6,9 +6,10 @@ import {
   HttpApiSecurity,
 } from '@effect/platform';
 import { Context, Schema } from 'effect';
+import { Snowflake } from '~/models/Discord.js';
 import { Permission } from '~/models/Role.js';
 import { TeamId } from '~/models/Team.js';
-import { Gender, Locale, Position, Proficiency, UserId } from '~/models/User.js';
+import { Gender, Locale, UserId } from '~/models/User.js';
 
 export { UserId } from '~/models/User.js';
 
@@ -30,9 +31,6 @@ export class CurrentUser extends Schema.Class<CurrentUser>('CurrentUser')({
   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),
   locale: Locale,
 }) {}
 
@@ -42,6 +40,15 @@ export class UpdateLocaleRequest extends Schema.Class<UpdateLocaleRequest>('Upda
 
 export class CreateTeamRequest extends Schema.Class<CreateTeamRequest>('CreateTeamRequest')({
   name: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(100)),
+  guildId: Snowflake,
+}) {}
+
+export class DiscordGuild extends Schema.Class<DiscordGuild>('DiscordGuild')({
+  id: Snowflake,
+  name: Schema.String,
+  icon: Schema.NullOr(Schema.String),
+  owner: Schema.Boolean,
+  botPresent: Schema.Boolean,
 }) {}
 
 export class CompleteProfileRequest extends Schema.Class<CompleteProfileRequest>(
@@ -56,11 +63,6 @@ export class CompleteProfileRequest extends Schema.Class<CompleteProfileRequest>
     }),
   ),
   gender: Gender,
-  jerseyNumber: Schema.optionalWith(Schema.Number.pipe(Schema.int(), Schema.between(0, 99)), {
-    as: 'Option',
-  }),
-  position: Position,
-  proficiency: Proficiency,
 }) {}
 
 export class UpdateProfileRequest extends Schema.Class<UpdateProfileRequest>(
@@ -77,9 +79,6 @@ export class UpdateProfileRequest extends Schema.Class<UpdateProfileRequest>(
     ),
   ),
   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>()(
@@ -146,6 +145,12 @@ export class AuthApiGroup extends HttpApiGroup.make('auth')
       .addError(Unauthorized, { status: 401 })
       .middleware(AuthMiddleware),
   )
+  .add(
+    HttpApiEndpoint.get('myGuilds', '/me/guilds')
+      .addSuccess(Schema.Array(DiscordGuild))
+      .addError(Unauthorized, { status: 401 })
+      .middleware(AuthMiddleware),
+  )
   .add(
     HttpApiEndpoint.post('createTeam', '/me/teams')
       .addSuccess(UserTeam)

package/src/api/GroupApi.ts

@@ -0,0 +1,229 @@
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from '@effect/platform';
+import { Schema } from 'effect';
+import { AuthMiddleware } from '~/api/Auth.js';
+import { Snowflake } from '~/models/Discord.js';
+import { GroupId } from '~/models/GroupModel.js';
+import { RoleId } from '~/models/Role.js';
+import { TeamId } from '~/models/Team.js';
+import { TeamMemberId } from '~/models/TeamMember.js';
+
+export class GroupInfo extends Schema.Class<GroupInfo>('GroupInfo')({
+  groupId: GroupId,
+  teamId: TeamId,
+  parentId: Schema.NullOr(GroupId),
+  name: Schema.String,
+  emoji: Schema.NullOr(Schema.String),
+  memberCount: Schema.Number,
+}) {}
+
+export class GroupDetail extends Schema.Class<GroupDetail>('GroupDetail')({
+  groupId: GroupId,
+  teamId: TeamId,
+  parentId: Schema.NullOr(GroupId),
+  name: Schema.String,
+  emoji: Schema.NullOr(Schema.String),
+  roles: Schema.Array(
+    Schema.Struct({
+      roleId: RoleId,
+      roleName: Schema.String,
+    }),
+  ),
+  members: Schema.Array(
+    Schema.Struct({
+      memberId: TeamMemberId,
+      name: Schema.NullOr(Schema.String),
+      discordUsername: Schema.String,
+    }),
+  ),
+}) {}
+
+export class CreateGroupRequest extends Schema.Class<CreateGroupRequest>('CreateGroupRequest')({
+  name: Schema.NonEmptyString,
+  parentId: Schema.NullOr(GroupId),
+  emoji: Schema.NullOr(Schema.String),
+}) {}
+
+export class UpdateGroupRequest extends Schema.Class<UpdateGroupRequest>('UpdateGroupRequest')({
+  name: Schema.NonEmptyString,
+  emoji: Schema.NullOr(Schema.String),
+}) {}
+
+export class AddGroupMemberRequest extends Schema.Class<AddGroupMemberRequest>(
+  'AddGroupMemberRequest',
+)({
+  memberId: TeamMemberId,
+}) {}
+
+export class AssignGroupRoleRequest extends Schema.Class<AssignGroupRoleRequest>(
+  'AssignGroupRoleRequest',
+)({
+  roleId: RoleId,
+}) {}
+
+export class MoveGroupRequest extends Schema.Class<MoveGroupRequest>('MoveGroupRequest')({
+  parentId: Schema.NullOr(GroupId),
+}) {}
+
+export class ChannelMappingInfo extends Schema.Class<ChannelMappingInfo>('ChannelMappingInfo')({
+  discordChannelId: Snowflake,
+  discordChannelName: Schema.NullOr(Schema.String),
+  discordRoleId: Schema.NullOr(Snowflake),
+}) {}
+
+export class SetChannelMappingRequest extends Schema.Class<SetChannelMappingRequest>(
+  'SetChannelMappingRequest',
+)({
+  discordChannelId: Snowflake,
+}) {}
+
+export class DiscordChannelInfo extends Schema.Class<DiscordChannelInfo>('DiscordChannelInfo')({
+  id: Snowflake,
+  name: Schema.String,
+  type: Schema.Number,
+  parentId: Schema.NullOr(Snowflake),
+}) {}
+
+export class GroupNotFound extends Schema.TaggedError<GroupNotFound>()(
+  'GroupNotFound',
+  {},
+  HttpApiSchema.annotations({ status: 404 }),
+) {}
+
+export class Forbidden extends Schema.TaggedError<Forbidden>()(
+  'GroupForbidden',
+  {},
+  HttpApiSchema.annotations({ status: 403 }),
+) {}
+
+export class MemberNotFound extends Schema.TaggedError<MemberNotFound>()(
+  'GroupMemberNotFound',
+  {},
+  HttpApiSchema.annotations({ status: 404 }),
+) {}
+
+export class GroupApiGroup extends HttpApiGroup.make('group')
+  .add(
+    HttpApiEndpoint.get('listGroups', '/teams/:teamId/groups')
+      .addSuccess(Schema.Array(GroupInfo))
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('createGroup', '/teams/:teamId/groups')
+      .addSuccess(GroupInfo, { status: 201 })
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .setPayload(CreateGroupRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.get('getGroup', '/teams/:teamId/groups/:groupId')
+      .addSuccess(GroupDetail)
+      .addError(Forbidden, { status: 403 })
+      .addError(GroupNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, groupId: GroupId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.patch('updateGroup', '/teams/:teamId/groups/:groupId')
+      .addSuccess(GroupInfo)
+      .addError(Forbidden, { status: 403 })
+      .addError(GroupNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, groupId: GroupId }))
+      .setPayload(UpdateGroupRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.del('deleteGroup', '/teams/:teamId/groups/:groupId')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(GroupNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, groupId: GroupId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('addGroupMember', '/teams/:teamId/groups/:groupId/members')
+      .addSuccess(Schema.Void, { status: 204 })
+      .addError(Forbidden, { status: 403 })
+      .addError(GroupNotFound, { status: 404 })
+      .addError(MemberNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, groupId: GroupId }))
+      .setPayload(AddGroupMemberRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.del('removeGroupMember', '/teams/:teamId/groups/:groupId/members/:memberId')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(GroupNotFound, { status: 404 })
+      .addError(MemberNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, groupId: GroupId, memberId: TeamMemberId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('assignGroupRole', '/teams/:teamId/groups/:groupId/roles')
+      .addSuccess(Schema.Void, { status: 204 })
+      .addError(Forbidden, { status: 403 })
+      .addError(GroupNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, groupId: GroupId }))
+      .setPayload(AssignGroupRoleRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.del('unassignGroupRole', '/teams/:teamId/groups/:groupId/roles/:roleId')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(GroupNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, groupId: GroupId, roleId: RoleId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.patch('moveGroup', '/teams/:teamId/groups/:groupId/parent')
+      .addSuccess(GroupInfo)
+      .addError(Forbidden, { status: 403 })
+      .addError(GroupNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, groupId: GroupId }))
+      .setPayload(MoveGroupRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.get('getChannelMapping', '/teams/:teamId/groups/:groupId/channel-mapping')
+      .addSuccess(Schema.NullOr(ChannelMappingInfo))
+      .addError(Forbidden, { status: 403 })
+      .addError(GroupNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, groupId: GroupId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.put('setChannelMapping', '/teams/:teamId/groups/:groupId/channel-mapping')
+      .addSuccess(ChannelMappingInfo)
+      .addError(Forbidden, { status: 403 })
+      .addError(GroupNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, groupId: GroupId }))
+      .setPayload(SetChannelMappingRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.del('deleteChannelMapping', '/teams/:teamId/groups/:groupId/channel-mapping')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(GroupNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, groupId: GroupId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('createChannel', '/teams/:teamId/groups/:groupId/create-channel')
+      .addSuccess(Schema.Void, { status: 201 })
+      .addError(Forbidden, { status: 403 })
+      .addError(GroupNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, groupId: GroupId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.get('listDiscordChannels', '/teams/:teamId/discord-channels')
+      .addSuccess(Schema.Array(DiscordChannelInfo))
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .middleware(AuthMiddleware),
+  ) {}

package/src/api/NotificationApi.ts

@@ -31,6 +31,11 @@ export class NotificationApiGroup extends HttpApiGroup.make('notification')
     HttpApiEndpoint.get('listNotifications', '/notifications')
       .addSuccess(Schema.Array(NotificationInfo))
       .addError(Forbidden, { status: 403 })
+      .setUrlParams(
+        Schema.Struct({
+          teamId: TeamId,
+        }),
+      )
       .middleware(AuthMiddleware),
   )
   .add(
@@ -45,5 +50,10 @@ export class NotificationApiGroup extends HttpApiGroup.make('notification')
     HttpApiEndpoint.post('markAllAsRead', '/notifications/read-all')
       .addSuccess(Schema.Void)
       .addError(Forbidden, { status: 403 })
+      .setPayload(
+        Schema.Struct({
+          teamId: TeamId,
+        }),
+      )
       .middleware(AuthMiddleware),
   ) {}

package/src/api/Roster.ts

@@ -5,7 +5,7 @@ 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';
+import { Gender, UserId } from '~/models/User.js';
 
 export class RosterPlayer extends Schema.Class<RosterPlayer>('RosterPlayer')({
   memberId: TeamMemberId,
@@ -16,8 +16,6 @@ export class RosterPlayer extends Schema.Class<RosterPlayer>('RosterPlayer')({
   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),
 }) {}
@@ -27,8 +25,6 @@ export class UpdatePlayerRequest extends Schema.Class<UpdatePlayerRequest>('Upda
   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>()(

package/src/api/TrainingTypeApi.ts

@@ -0,0 +1,96 @@
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from '@effect/platform';
+import { Schema } from 'effect';
+import { AuthMiddleware } from '~/api/Auth.js';
+import { GroupId } from '~/models/GroupModel.js';
+import { TeamId } from '~/models/Team.js';
+import { TrainingTypeId } from '~/models/TrainingType.js';
+
+export class TrainingTypeInfo extends Schema.Class<TrainingTypeInfo>('TrainingTypeInfo')({
+  trainingTypeId: TrainingTypeId,
+  teamId: TeamId,
+  name: Schema.String,
+  groupName: Schema.NullOr(Schema.String),
+}) {}
+
+export class TrainingTypeDetail extends Schema.Class<TrainingTypeDetail>('TrainingTypeDetail')({
+  trainingTypeId: TrainingTypeId,
+  teamId: TeamId,
+  name: Schema.String,
+  groupId: Schema.NullOr(GroupId),
+  groupName: Schema.NullOr(Schema.String),
+  canAdmin: Schema.Boolean,
+}) {}
+
+export class TrainingTypeListResponse extends Schema.Class<TrainingTypeListResponse>(
+  'TrainingTypeListResponse',
+)({
+  canAdmin: Schema.Boolean,
+  trainingTypes: Schema.Array(TrainingTypeInfo),
+}) {}
+
+export class CreateTrainingTypeRequest extends Schema.Class<CreateTrainingTypeRequest>(
+  'CreateTrainingTypeRequest',
+)({
+  name: Schema.NonEmptyString,
+  groupId: Schema.NullOr(GroupId),
+}) {}
+
+export class UpdateTrainingTypeRequest extends Schema.Class<UpdateTrainingTypeRequest>(
+  'UpdateTrainingTypeRequest',
+)({
+  name: Schema.NonEmptyString,
+}) {}
+
+export class TrainingTypeNotFound extends Schema.TaggedError<TrainingTypeNotFound>()(
+  'TrainingTypeNotFound',
+  {},
+  HttpApiSchema.annotations({ status: 404 }),
+) {}
+
+export class Forbidden extends Schema.TaggedError<Forbidden>()(
+  'TrainingTypeForbidden',
+  {},
+  HttpApiSchema.annotations({ status: 403 }),
+) {}
+
+export class TrainingTypeApiGroup extends HttpApiGroup.make('trainingType')
+  .add(
+    HttpApiEndpoint.get('listTrainingTypes', '/teams/:teamId/training-types')
+      .addSuccess(TrainingTypeListResponse)
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('createTrainingType', '/teams/:teamId/training-types')
+      .addSuccess(TrainingTypeInfo, { status: 201 })
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .setPayload(CreateTrainingTypeRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.get('getTrainingType', '/teams/:teamId/training-types/:trainingTypeId')
+      .addSuccess(TrainingTypeDetail)
+      .addError(Forbidden, { status: 403 })
+      .addError(TrainingTypeNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, trainingTypeId: TrainingTypeId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.patch('updateTrainingType', '/teams/:teamId/training-types/:trainingTypeId')
+      .addSuccess(TrainingTypeInfo)
+      .addError(Forbidden, { status: 403 })
+      .addError(TrainingTypeNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, trainingTypeId: TrainingTypeId }))
+      .setPayload(UpdateTrainingTypeRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.del('deleteTrainingType', '/teams/:teamId/training-types/:trainingTypeId')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(TrainingTypeNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, trainingTypeId: TrainingTypeId }))
+      .middleware(AuthMiddleware),
+  ) {}

package/src/index.ts

@@ -4,6 +4,8 @@ export * as AgeThresholdApi from './api/AgeThresholdApi.js';
 
 export * as Auth from './api/Auth.js';
 
+export * as GroupApi from './api/GroupApi.js';
+
 export * as Invite from './api/Invite.js';
 
 export * as NotificationApi from './api/NotificationApi.js';
@@ -12,18 +14,28 @@ export * as RoleApi from './api/RoleApi.js';
 
 export * as Roster from './api/Roster.js';
 
-export * as SubgroupApi from './api/SubgroupApi.js';
+export * as TrainingTypeApi from './api/TrainingTypeApi.js';
 
 export * as AgeThresholdRule from './models/AgeThresholdRule.js';
 
+export * as ChannelSyncEvent from './models/ChannelSyncEvent.js';
+
+export * as Discord from './models/Discord.js';
+
+export * as DiscordChannelMapping from './models/DiscordChannelMapping.js';
+
 export * as DiscordRoleMapping from './models/DiscordRoleMapping.js';
 
+export * as GroupModel from './models/GroupModel.js';
+
 export * as MemberRole from './models/MemberRole.js';
 
 export * as Notification from './models/Notification.js';
 
 export * as Role from './models/Role.js';
 
+export * as RoleGroup from './models/RoleGroup.js';
+
 export * as RoleSyncEvent from './models/RoleSyncEvent.js';
 
 export * as RosterMemberModel from './models/RosterMemberModel.js';
@@ -32,14 +44,20 @@ export * as RosterModel from './models/RosterModel.js';
 
 export * as Session from './models/Session.js';
 
-export * as SubgroupModel from './models/SubgroupModel.js';
-
 export * as Team from './models/Team.js';
 
 export * as TeamInvite from './models/TeamInvite.js';
 
 export * as TeamMember from './models/TeamMember.js';
 
-export * as User from './models/User.js';
+export * as TrainingType from './models/TrainingType.js';
 
-export * as RoleSyncRpc from './rpc/RoleSyncRpc.js';
+export * as User from './models/User.js';
+export * as ChannelRpcEvents from './rpc/channel/ChannelRpcEvents.js';
+export * as ChannelRpcGroup from './rpc/channel/ChannelRpcGroup.js';
+export * as ChannelRpcModels from './rpc/channel/ChannelRpcModels.js';
+export * as GuildRpcGroup from './rpc/guild/GuildRpcGroup.js';
+export * as RoleRpcEvents from './rpc/role/RoleRpcEvents.js';
+export * as RoleRpcGroup from './rpc/role/RoleRpcGroup.js';
+export * as RoleRpcModels from './rpc/role/RoleRpcModels.js';
+export * as SyncRpcs from './rpc/SyncRpcs.js';

package/src/models/AgeThresholdRule.ts

@@ -1,6 +1,6 @@
 import { Model } from '@effect/sql';
 import { Schema } from 'effect';
-import { RoleId } from '~/models/Role.js';
+import { GroupId } from '~/models/GroupModel.js';
 import { TeamId } from '~/models/Team.js';
 
 export const AgeThresholdRuleId = Schema.String.pipe(Schema.brand('AgeThresholdRuleId'));
@@ -9,7 +9,7 @@ export type AgeThresholdRuleId = typeof AgeThresholdRuleId.Type;
 export class AgeThresholdRule extends Model.Class<AgeThresholdRule>('AgeThresholdRule')({
   id: Model.Generated(AgeThresholdRuleId),
   team_id: TeamId,
-  role_id: RoleId,
+  group_id: GroupId,
   min_age: Schema.NullOr(Schema.Number),
   max_age: Schema.NullOr(Schema.Number),
   created_at: Model.DateTimeInsertFromDate,

package/src/models/ChannelSyncEvent.ts

@@ -0,0 +1,30 @@
+import { Model } from '@effect/sql';
+import { Schema } from 'effect';
+import { GroupId } from '~/models/GroupModel.js';
+import { TeamId } from '~/models/Team.js';
+import { TeamMemberId } from '~/models/TeamMember.js';
+
+export const ChannelSyncEventId = Schema.String.pipe(Schema.brand('ChannelSyncEventId'));
+export type ChannelSyncEventId = typeof ChannelSyncEventId.Type;
+
+export const ChannelSyncEventType = Schema.Literal(
+  'channel_created',
+  'channel_deleted',
+  'member_added',
+  'member_removed',
+);
+export type ChannelSyncEventType = typeof ChannelSyncEventType.Type;
+
+export class ChannelSyncEvent extends Model.Class<ChannelSyncEvent>('ChannelSyncEvent')({
+  id: Model.Generated(ChannelSyncEventId),
+  team_id: TeamId,
+  guild_id: Schema.String,
+  event_type: ChannelSyncEventType,
+  group_id: GroupId,
+  group_name: Schema.NullOr(Schema.String),
+  team_member_id: Schema.NullOr(TeamMemberId),
+  discord_user_id: Schema.NullOr(Schema.String),
+  processed_at: Schema.NullOr(Schema.String),
+  error: Schema.NullOr(Schema.String),
+  created_at: Model.DateTimeInsertFromDate,
+}) {}

package/src/models/Discord.ts

@@ -0,0 +1,4 @@
+import { Schema } from 'effect';
+
+export const Snowflake = Schema.String.pipe(Schema.brand('Snowflake'));
+export type Snowflake = typeof Snowflake.Type;

package/src/models/DiscordChannelMapping.ts

@@ -0,0 +1,18 @@
+import { Model } from '@effect/sql';
+import { Schema } from 'effect';
+import { GroupId } from '~/models/GroupModel.js';
+import { TeamId } from '~/models/Team.js';
+
+export const DiscordChannelMappingId = Schema.String.pipe(Schema.brand('DiscordChannelMappingId'));
+export type DiscordChannelMappingId = typeof DiscordChannelMappingId.Type;
+
+export class DiscordChannelMapping extends Model.Class<DiscordChannelMapping>(
+  'DiscordChannelMapping',
+)({
+  id: Model.Generated(DiscordChannelMappingId),
+  team_id: TeamId,
+  group_id: GroupId,
+  discord_channel_id: Schema.String,
+  discord_role_id: Schema.OptionFromNullOr(Schema.String),
+  created_at: Model.DateTimeInsertFromDate,
+}) {}

package/src/models/GroupModel.ts

@@ -0,0 +1,15 @@
+import { Model } from '@effect/sql';
+import { Schema } from 'effect';
+import { TeamId } from '~/models/Team.js';
+
+export const GroupId = Schema.String.pipe(Schema.brand('GroupId'));
+export type GroupId = typeof GroupId.Type;
+
+export class Group extends Model.Class<Group>('Group')({
+  id: Model.Generated(GroupId),
+  team_id: TeamId,
+  parent_id: Schema.NullOr(GroupId),
+  name: Schema.String,
+  emoji: Schema.NullOr(Schema.String),
+  created_at: Model.DateTimeInsertFromDate,
+}) {}

package/src/models/Notification.ts

@@ -7,8 +7,8 @@ export const NotificationId = Schema.String.pipe(Schema.brand('NotificationId'))
 export type NotificationId = typeof NotificationId.Type;
 
 export const NotificationType = Schema.Literal(
-  'age_role_assigned',
-  'age_role_removed',
+  'age_group_added',
+  'age_group_removed',
   'role_assigned',
   'role_removed',
 );

package/src/models/Role.ts

@@ -15,6 +15,8 @@ export const Permission = Schema.Literal(
   'member:remove',
   'role:view',
   'role:manage',
+  'training-type:create',
+  'training-type:delete',
 );
 export type Permission = typeof Permission.Type;
 
@@ -32,6 +34,8 @@ export const defaultPermissions: Record<string, ReadonlyArray<Permission>> = {
     'member:remove',
     'role:view',
     'role:manage',
+    'training-type:create',
+    'training-type:delete',
   ],
   Captain: ['roster:view', 'roster:manage', 'member:view', 'member:edit', 'role:view'],
   Player: ['roster:view', 'member:view'],

package/src/models/RoleGroup.ts

@@ -0,0 +1,8 @@
+import { Schema } from 'effect';
+import { GroupId } from '~/models/GroupModel.js';
+import { RoleId } from '~/models/Role.js';
+
+export class RoleGroup extends Schema.Class<RoleGroup>('RoleGroup')({
+  role_id: RoleId,
+  group_id: GroupId,
+}) {}

package/src/models/Team.ts

@@ -1,5 +1,6 @@
 import { Model } from '@effect/sql';
 import { Schema } from 'effect';
+import { Snowflake } from '~/models/Discord.js';
 import { UserId } from '~/models/User.js';
 
 export const TeamId = Schema.String.pipe(Schema.brand('TeamId'));
@@ -8,6 +9,7 @@ export type TeamId = typeof TeamId.Type;
 export class Team extends Model.Class<Team>('Team')({
   id: Model.Generated(TeamId),
   name: Schema.String,
+  guild_id: Snowflake,
   created_by: UserId,
   created_at: Model.DateTimeInsertFromDate,
   updated_at: Model.DateTimeUpdateFromDate,

package/src/models/TeamMember.ts

@@ -11,5 +11,6 @@ export class TeamMember extends Model.Class<TeamMember>('TeamMember')({
   team_id: TeamId,
   user_id: UserId,
   active: Schema.Boolean,
+  jersey_number: Model.FieldExcept('insert')(Schema.NullOr(Schema.Number)),
   joined_at: Model.DateTimeInsertFromDate,
 }) {}