@sideline/domain 0.4.0 → 0.5.0

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/TrainingTypeApi.ts

@@ -1,29 +1,24 @@
 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 { TeamMemberId } from '~/models/TeamMember.js';
 import { TrainingTypeId } from '~/models/TrainingType.js';
 
 export class TrainingTypeInfo extends Schema.Class<TrainingTypeInfo>('TrainingTypeInfo')({
   trainingTypeId: TrainingTypeId,
   teamId: TeamId,
   name: Schema.String,
-  coachCount: Schema.Number,
+  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,
-  coaches: Schema.Array(
-    Schema.Struct({
-      memberId: TeamMemberId,
-      name: Schema.NullOr(Schema.String),
-      discordUsername: Schema.String,
-    }),
-  ),
 }) {}
 
 export class TrainingTypeListResponse extends Schema.Class<TrainingTypeListResponse>(
@@ -37,6 +32,7 @@ export class CreateTrainingTypeRequest extends Schema.Class<CreateTrainingTypeRe
   'CreateTrainingTypeRequest',
 )({
   name: Schema.NonEmptyString,
+  groupId: Schema.NullOr(GroupId),
 }) {}
 
 export class UpdateTrainingTypeRequest extends Schema.Class<UpdateTrainingTypeRequest>(
@@ -45,12 +41,6 @@ export class UpdateTrainingTypeRequest extends Schema.Class<UpdateTrainingTypeRe
   name: Schema.NonEmptyString,
 }) {}
 
-export class AddTrainingTypeCoachRequest extends Schema.Class<AddTrainingTypeCoachRequest>(
-  'AddTrainingTypeCoachRequest',
-)({
-  memberId: TeamMemberId,
-}) {}
-
 export class TrainingTypeNotFound extends Schema.TaggedError<TrainingTypeNotFound>()(
   'TrainingTypeNotFound',
   {},
@@ -63,12 +53,6 @@ export class Forbidden extends Schema.TaggedError<Forbidden>()(
   HttpApiSchema.annotations({ status: 403 }),
 ) {}
 
-export class MemberNotFound extends Schema.TaggedError<MemberNotFound>()(
-  'TrainingTypeMemberNotFound',
-  {},
-  HttpApiSchema.annotations({ status: 404 }),
-) {}
-
 export class TrainingTypeApiGroup extends HttpApiGroup.make('trainingType')
   .add(
     HttpApiEndpoint.get('listTrainingTypes', '/teams/:teamId/training-types')
@@ -109,35 +93,4 @@ export class TrainingTypeApiGroup extends HttpApiGroup.make('trainingType')
       .addError(TrainingTypeNotFound, { status: 404 })
       .setPath(Schema.Struct({ teamId: TeamId, trainingTypeId: TrainingTypeId }))
       .middleware(AuthMiddleware),
-  )
-  .add(
-    HttpApiEndpoint.post(
-      'addTrainingTypeCoach',
-      '/teams/:teamId/training-types/:trainingTypeId/coaches',
-    )
-      .addSuccess(Schema.Void, { status: 204 })
-      .addError(Forbidden, { status: 403 })
-      .addError(TrainingTypeNotFound, { status: 404 })
-      .addError(MemberNotFound, { status: 404 })
-      .setPath(Schema.Struct({ teamId: TeamId, trainingTypeId: TrainingTypeId }))
-      .setPayload(AddTrainingTypeCoachRequest)
-      .middleware(AuthMiddleware),
-  )
-  .add(
-    HttpApiEndpoint.del(
-      'removeTrainingTypeCoach',
-      '/teams/:teamId/training-types/:trainingTypeId/coaches/:memberId',
-    )
-      .addSuccess(Schema.Void)
-      .addError(Forbidden, { status: 403 })
-      .addError(TrainingTypeNotFound, { status: 404 })
-      .addError(MemberNotFound, { status: 404 })
-      .setPath(
-        Schema.Struct({
-          teamId: TeamId,
-          trainingTypeId: TrainingTypeId,
-          memberId: TeamMemberId,
-        }),
-      )
-      .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,8 +14,6 @@ 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';
@@ -26,12 +26,16 @@ 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';
@@ -40,8 +44,6 @@ 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';
@@ -54,6 +56,7 @@ 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';

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

@@ -1,6 +1,6 @@
 import { Model } from '@effect/sql';
 import { Schema } from 'effect';
-import { SubgroupId } from '~/models/SubgroupModel.js';
+import { GroupId } from '~/models/GroupModel.js';
 import { TeamId } from '~/models/Team.js';
 import { TeamMemberId } from '~/models/TeamMember.js';
 
@@ -20,8 +20,8 @@ export class ChannelSyncEvent extends Model.Class<ChannelSyncEvent>('ChannelSync
   team_id: TeamId,
   guild_id: Schema.String,
   event_type: ChannelSyncEventType,
-  subgroup_id: SubgroupId,
-  subgroup_name: Schema.NullOr(Schema.String),
+  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),

package/src/models/DiscordChannelMapping.ts

@@ -1,6 +1,6 @@
 import { Model } from '@effect/sql';
 import { Schema } from 'effect';
-import { SubgroupId } from '~/models/SubgroupModel.js';
+import { GroupId } from '~/models/GroupModel.js';
 import { TeamId } from '~/models/Team.js';
 
 export const DiscordChannelMappingId = Schema.String.pipe(Schema.brand('DiscordChannelMappingId'));
@@ -11,7 +11,7 @@ export class DiscordChannelMapping extends Model.Class<DiscordChannelMapping>(
 )({
   id: Model.Generated(DiscordChannelMappingId),
   team_id: TeamId,
-  subgroup_id: SubgroupId,
+  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/TrainingType.ts

@@ -1,5 +1,6 @@
 import { Model } from '@effect/sql';
 import { Schema } from 'effect';
+import { GroupId } from '~/models/GroupModel.js';
 import { TeamId } from '~/models/Team.js';
 
 export const TrainingTypeId = Schema.String.pipe(Schema.brand('TrainingTypeId'));
@@ -9,5 +10,6 @@ export class TrainingType extends Model.Class<TrainingType>('TrainingType')({
   id: Model.Generated(TrainingTypeId),
   team_id: TeamId,
   name: Schema.String,
+  group_id: Schema.NullOr(GroupId),
   created_at: Model.DateTimeInsertFromDate,
 }) {}

package/src/rpc/SyncRpcs.ts

@@ -1,5 +1,6 @@
 import { RpcGroup } from '@effect/rpc';
 import { ChannelRpcGroup } from './channel/ChannelRpcGroup.js';
+import { GuildRpcGroup } from './guild/GuildRpcGroup.js';
 import { RoleRpcGroup } from './role/RoleRpcGroup.js';
 
-export class SyncRpcs extends RpcGroup.make().merge(RoleRpcGroup, ChannelRpcGroup) {}
+export class SyncRpcs extends RpcGroup.make().merge(RoleRpcGroup, ChannelRpcGroup, GuildRpcGroup) {}

package/src/rpc/channel/ChannelRpcEvents.ts

@@ -1,5 +1,5 @@
 import { Schema } from 'effect';
-import { ChannelSyncEvent, Discord, SubgroupModel, Team, TeamMember } from '~/index.js';
+import { ChannelSyncEvent, Discord, GroupModel, Team, TeamMember } from '~/index.js';
 
 export class ChannelCreatedEvent extends Schema.TaggedClass<ChannelCreatedEvent>()(
   'channel_created',
@@ -7,8 +7,8 @@ export class ChannelCreatedEvent extends Schema.TaggedClass<ChannelCreatedEvent>
     id: ChannelSyncEvent.ChannelSyncEventId,
     team_id: Team.TeamId,
     guild_id: Discord.Snowflake,
-    subgroup_id: SubgroupModel.SubgroupId,
-    subgroup_name: Schema.String,
+    group_id: GroupModel.GroupId,
+    group_name: Schema.String,
   },
 ) {}
 
@@ -18,7 +18,7 @@ export class ChannelDeletedEvent extends Schema.TaggedClass<ChannelDeletedEvent>
     id: ChannelSyncEvent.ChannelSyncEventId,
     team_id: Team.TeamId,
     guild_id: Discord.Snowflake,
-    subgroup_id: SubgroupModel.SubgroupId,
+    group_id: GroupModel.GroupId,
   },
 ) {}
 
@@ -28,8 +28,8 @@ export class ChannelMemberAddedEvent extends Schema.TaggedClass<ChannelMemberAdd
     id: ChannelSyncEvent.ChannelSyncEventId,
     team_id: Team.TeamId,
     guild_id: Discord.Snowflake,
-    subgroup_id: SubgroupModel.SubgroupId,
-    subgroup_name: Schema.String,
+    group_id: GroupModel.GroupId,
+    group_name: Schema.String,
     team_member_id: TeamMember.TeamMemberId,
     discord_user_id: Discord.Snowflake,
   },
@@ -41,7 +41,7 @@ export class ChannelMemberRemovedEvent extends Schema.TaggedClass<ChannelMemberR
     id: ChannelSyncEvent.ChannelSyncEventId,
     team_id: Team.TeamId,
     guild_id: Discord.Snowflake,
-    subgroup_id: SubgroupModel.SubgroupId,
+    group_id: GroupModel.GroupId,
     team_member_id: TeamMember.TeamMemberId,
     discord_user_id: Discord.Snowflake,
   },

package/src/rpc/channel/ChannelRpcGroup.ts

@@ -1,6 +1,6 @@
 import { Rpc, RpcGroup } from '@effect/rpc';
 import { Schema } from 'effect';
-import { ChannelSyncEvent, Discord, SubgroupModel, Team } from '~/index.js';
+import { ChannelSyncEvent, Discord, GroupModel, Team } from '~/index.js';
 import { UnprocessedChannelEvent } from './ChannelRpcEvents.js';
 import { ChannelMapping } from './ChannelRpcModels.js';
 
@@ -16,18 +16,18 @@ export const ChannelRpcGroup = RpcGroup.make(
     payload: { id: ChannelSyncEvent.ChannelSyncEventId, error: Schema.String },
   }),
   Rpc.make('GetMapping', {
-    payload: { team_id: Team.TeamId, subgroup_id: SubgroupModel.SubgroupId },
+    payload: { team_id: Team.TeamId, group_id: GroupModel.GroupId },
     success: Schema.OptionFromNullOr(ChannelMapping),
   }),
   Rpc.make('UpsertMapping', {
     payload: {
       team_id: Team.TeamId,
-      subgroup_id: SubgroupModel.SubgroupId,
+      group_id: GroupModel.GroupId,
       discord_channel_id: Discord.Snowflake,
       discord_role_id: Discord.Snowflake,
     },
   }),
   Rpc.make('DeleteMapping', {
-    payload: { team_id: Team.TeamId, subgroup_id: SubgroupModel.SubgroupId },
+    payload: { team_id: Team.TeamId, group_id: GroupModel.GroupId },
   }),
 ).prefix('Channel/');

package/src/rpc/channel/ChannelRpcModels.ts

@@ -1,10 +1,10 @@
 import { Schema } from 'effect';
-import { Discord, DiscordChannelMapping, SubgroupModel, Team } from '~/index.js';
+import { Discord, DiscordChannelMapping, GroupModel, Team } from '~/index.js';
 
 export class ChannelMapping extends Schema.Class<ChannelMapping>('ChannelMapping')({
   id: DiscordChannelMapping.DiscordChannelMappingId,
   team_id: Team.TeamId,
-  subgroup_id: SubgroupModel.SubgroupId,
+  group_id: GroupModel.GroupId,
   discord_channel_id: Discord.Snowflake,
   discord_role_id: Schema.OptionFromNullOr(Discord.Snowflake),
 }) {}