@sideline/domain 0.4.0 → 0.6.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/Roster.ts

@@ -10,10 +10,11 @@ import { Gender, UserId } from '~/models/User.js';
 export class RosterPlayer extends Schema.Class<RosterPlayer>('RosterPlayer')({
   memberId: TeamMemberId,
   userId: UserId,
+  discordId: Schema.String,
   roleNames: Schema.Array(Schema.String),
   permissions: Schema.Array(Permission),
   name: Schema.NullOr(Schema.String),
-  birthYear: Schema.NullOr(Schema.Number),
+  birthDate: Schema.NullOr(Schema.String),
   gender: Schema.NullOr(Gender),
   jerseyNumber: Schema.NullOr(Schema.Number),
   discordUsername: Schema.String,
@@ -22,7 +23,7 @@ export class RosterPlayer extends Schema.Class<RosterPlayer>('RosterPlayer')({
 
 export class UpdatePlayerRequest extends Schema.Class<UpdatePlayerRequest>('UpdatePlayerRequest')({
   name: Schema.NullOr(Schema.String),
-  birthYear: Schema.NullOr(Schema.Number),
+  birthDate: Schema.OptionFromNullOr(Schema.String),
   gender: Schema.NullOr(Gender),
   jerseyNumber: Schema.NullOr(Schema.Number),
 }) {}

package/src/api/TeamSettingsApi.ts

@@ -0,0 +1,57 @@
+import { HttpApiEndpoint, HttpApiGroup } from '@effect/platform';
+import { Schema } from 'effect';
+import { AuthMiddleware } from '~/api/Auth.js';
+import { Forbidden } from '~/api/EventApi.js';
+import { TeamId } from '~/models/Team.js';
+
+export class TeamSettingsInfo extends Schema.Class<TeamSettingsInfo>('TeamSettingsInfo')({
+  teamId: TeamId,
+  eventHorizonDays: Schema.Int,
+  discordChannelTraining: Schema.NullOr(Schema.String),
+  discordChannelMatch: Schema.NullOr(Schema.String),
+  discordChannelTournament: Schema.NullOr(Schema.String),
+  discordChannelMeeting: Schema.NullOr(Schema.String),
+  discordChannelSocial: Schema.NullOr(Schema.String),
+  discordChannelOther: Schema.NullOr(Schema.String),
+}) {}
+
+export class UpdateTeamSettingsRequest extends Schema.Class<UpdateTeamSettingsRequest>(
+  'UpdateTeamSettingsRequest',
+)({
+  eventHorizonDays: Schema.Int.pipe(Schema.between(1, 365)),
+  discordChannelTraining: Schema.optionalWith(Schema.OptionFromNullOr(Schema.String), {
+    as: 'Option',
+  }),
+  discordChannelMatch: Schema.optionalWith(Schema.OptionFromNullOr(Schema.String), {
+    as: 'Option',
+  }),
+  discordChannelTournament: Schema.optionalWith(Schema.OptionFromNullOr(Schema.String), {
+    as: 'Option',
+  }),
+  discordChannelMeeting: Schema.optionalWith(Schema.OptionFromNullOr(Schema.String), {
+    as: 'Option',
+  }),
+  discordChannelSocial: Schema.optionalWith(Schema.OptionFromNullOr(Schema.String), {
+    as: 'Option',
+  }),
+  discordChannelOther: Schema.optionalWith(Schema.OptionFromNullOr(Schema.String), {
+    as: 'Option',
+  }),
+}) {}
+
+export class TeamSettingsApiGroup extends HttpApiGroup.make('teamSettings')
+  .add(
+    HttpApiEndpoint.get('getTeamSettings', '/teams/:teamId/settings')
+      .addSuccess(TeamSettingsInfo)
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.patch('updateTeamSettings', '/teams/:teamId/settings')
+      .addSuccess(TeamSettingsInfo)
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .setPayload(UpdateTeamSettingsRequest)
+      .middleware(AuthMiddleware),
+  ) {}

package/src/api/TrainingTypeApi.ts

@@ -1,29 +1,25 @@
 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),
+  discordChannelId: 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,18 +33,15 @@ export class CreateTrainingTypeRequest extends Schema.Class<CreateTrainingTypeRe
   'CreateTrainingTypeRequest',
 )({
   name: Schema.NonEmptyString,
+  groupId: Schema.NullOr(GroupId),
+  discordChannelId: Schema.NullOr(Schema.String),
 }) {}
 
 export class UpdateTrainingTypeRequest extends Schema.Class<UpdateTrainingTypeRequest>(
   'UpdateTrainingTypeRequest',
 )({
   name: Schema.NonEmptyString,
-}) {}
-
-export class AddTrainingTypeCoachRequest extends Schema.Class<AddTrainingTypeCoachRequest>(
-  'AddTrainingTypeCoachRequest',
-)({
-  memberId: TeamMemberId,
+  discordChannelId: Schema.optionalWith(Schema.OptionFromNullOr(Schema.String), { as: 'Option' }),
 }) {}
 
 export class TrainingTypeNotFound extends Schema.TaggedError<TrainingTypeNotFound>()(
@@ -63,12 +56,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 +96,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,14 @@ export * as AgeThresholdApi from './api/AgeThresholdApi.js';
 
 export * as Auth from './api/Auth.js';
 
+export * as EventApi from './api/EventApi.js';
+
+export * as EventRsvpApi from './api/EventRsvpApi.js';
+
+export * as EventSeriesApi from './api/EventSeriesApi.js';
+
+export * as GroupApi from './api/GroupApi.js';
+
 export * as Invite from './api/Invite.js';
 
 export * as NotificationApi from './api/NotificationApi.js';
@@ -12,7 +20,7 @@ export * as RoleApi from './api/RoleApi.js';
 
 export * as Roster from './api/Roster.js';
 
-export * as SubgroupApi from './api/SubgroupApi.js';
+export * as TeamSettingsApi from './api/TeamSettingsApi.js';
 
 export * as TrainingTypeApi from './api/TrainingTypeApi.js';
 
@@ -26,12 +34,22 @@ export * as DiscordChannelMapping from './models/DiscordChannelMapping.js';
 
 export * as DiscordRoleMapping from './models/DiscordRoleMapping.js';
 
+export * as Event from './models/Event.js';
+
+export * as EventRsvp from './models/EventRsvp.js';
+
+export * as EventSeries from './models/EventSeries.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,20 +58,24 @@ 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 TeamSettings from './models/TeamSettings.js';
+
 export * as TrainingType from './models/TrainingType.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 EventRpcEvents from './rpc/event/EventRpcEvents.js';
+export * as EventRpcGroup from './rpc/event/EventRpcGroup.js';
+export * as EventRpcModels from './rpc/event/EventRpcModels.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/Event.ts

@@ -0,0 +1,41 @@
+import { Model } from '@effect/sql';
+import * as Schemas from '@sideline/effect-lib/Schemas';
+import { Schema } from 'effect';
+import { EventSeriesId } from '~/models/EventSeries.js';
+import { TeamId } from '~/models/Team.js';
+import { TeamMemberId } from '~/models/TeamMember.js';
+import { TrainingTypeId } from '~/models/TrainingType.js';
+
+export const EventId = Schema.String.pipe(Schema.brand('EventId'));
+export type EventId = typeof EventId.Type;
+
+export const EventType = Schema.Literal(
+  'training',
+  'match',
+  'tournament',
+  'meeting',
+  'social',
+  'other',
+);
+export type EventType = typeof EventType.Type;
+
+export const EventStatus = Schema.Literal('active', 'cancelled');
+export type EventStatus = typeof EventStatus.Type;
+
+export class Event extends Model.Class<Event>('Event')({
+  id: Model.Generated(EventId),
+  team_id: TeamId,
+  training_type_id: Schema.NullOr(TrainingTypeId),
+  event_type: EventType,
+  title: Schema.String,
+  description: Schema.NullOr(Schema.String),
+  start_at: Schemas.DateTimeFromDate,
+  end_at: Schema.NullOr(Schemas.DateTimeFromDate),
+  location: Schema.NullOr(Schema.String),
+  series_id: Schema.NullOr(EventSeriesId),
+  series_modified: Schema.Boolean,
+  status: Model.FieldExcept('update')(EventStatus),
+  created_by: TeamMemberId,
+  created_at: Model.DateTimeInsertFromDate,
+  updated_at: Model.DateTimeUpdateFromDate,
+}) {}

package/src/models/EventRsvp.ts

@@ -0,0 +1,20 @@
+import { Model } from '@effect/sql';
+import { Schema } from 'effect';
+import { EventId } from '~/models/Event.js';
+import { TeamMemberId } from '~/models/TeamMember.js';
+
+export const EventRsvpId = Schema.String.pipe(Schema.brand('EventRsvpId'));
+export type EventRsvpId = typeof EventRsvpId.Type;
+
+export const RsvpResponse = Schema.Literal('yes', 'no', 'maybe');
+export type RsvpResponse = typeof RsvpResponse.Type;
+
+export class EventRsvp extends Model.Class<EventRsvp>('EventRsvp')({
+  id: Model.Generated(EventRsvpId),
+  event_id: EventId,
+  team_member_id: TeamMemberId,
+  response: RsvpResponse,
+  message: Schema.NullOr(Schema.String),
+  created_at: Model.DateTimeInsertFromDate,
+  updated_at: Model.DateTimeUpdateFromDate,
+}) {}

package/src/models/EventSeries.ts

@@ -0,0 +1,36 @@
+import { Model } from '@effect/sql';
+import { Schema } from 'effect';
+import { TeamId } from '~/models/Team.js';
+import { TeamMemberId } from '~/models/TeamMember.js';
+import { TrainingTypeId } from '~/models/TrainingType.js';
+
+export const EventSeriesId = Schema.String.pipe(Schema.brand('EventSeriesId'));
+export type EventSeriesId = typeof EventSeriesId.Type;
+
+export const RecurrenceFrequency = Schema.Literal('weekly', 'biweekly');
+export type RecurrenceFrequency = typeof RecurrenceFrequency.Type;
+
+export const DayOfWeek = Schema.Int.pipe(Schema.between(0, 6), Schema.brand('DayOfWeek'));
+export type DayOfWeek = typeof DayOfWeek.Type;
+
+export const EventSeriesStatus = Schema.Literal('active', 'cancelled');
+export type EventSeriesStatus = typeof EventSeriesStatus.Type;
+
+export class EventSeries extends Model.Class<EventSeries>('EventSeries')({
+  id: Model.Generated(EventSeriesId),
+  team_id: TeamId,
+  training_type_id: Schema.NullOr(TrainingTypeId),
+  title: Schema.String,
+  description: Schema.NullOr(Schema.String),
+  start_time: Schema.String,
+  end_time: Schema.NullOr(Schema.String),
+  location: Schema.NullOr(Schema.String),
+  frequency: RecurrenceFrequency,
+  day_of_week: DayOfWeek,
+  start_date: Schema.DateFromSelf,
+  end_date: Schema.NullOr(Schema.DateFromSelf),
+  status: Model.FieldExcept('update')(EventSeriesStatus),
+  created_by: TeamMemberId,
+  created_at: Model.DateTimeInsertFromDate,
+  updated_at: Model.DateTimeUpdateFromDate,
+}) {}

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