@sideline/domain 0.5.0 → 0.6.1

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

@@ -18,6 +18,7 @@ export class TrainingTypeDetail extends Schema.Class<TrainingTypeDetail>('Traini
   name: Schema.String,
   groupId: Schema.NullOr(GroupId),
   groupName: Schema.NullOr(Schema.String),
+  discordChannelId: Schema.NullOr(Schema.String),
   canAdmin: Schema.Boolean,
 }) {}
 
@@ -33,12 +34,14 @@ export class CreateTrainingTypeRequest extends Schema.Class<CreateTrainingTypeRe
 )({
   name: Schema.NonEmptyString,
   groupId: Schema.NullOr(GroupId),
+  discordChannelId: Schema.NullOr(Schema.String),
 }) {}
 
 export class UpdateTrainingTypeRequest extends Schema.Class<UpdateTrainingTypeRequest>(
   'UpdateTrainingTypeRequest',
 )({
   name: Schema.NonEmptyString,
+  discordChannelId: Schema.optionalWith(Schema.OptionFromNullOr(Schema.String), { as: 'Option' }),
 }) {}
 
 export class TrainingTypeNotFound extends Schema.TaggedError<TrainingTypeNotFound>()(

package/src/index.ts

@@ -4,6 +4,12 @@ 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';
@@ -14,6 +20,8 @@ export * as RoleApi from './api/RoleApi.js';
 
 export * as Roster from './api/Roster.js';
 
+export * as TeamSettingsApi from './api/TeamSettingsApi.js';
+
 export * as TrainingTypeApi from './api/TrainingTypeApi.js';
 
 export * as AgeThresholdRule from './models/AgeThresholdRule.js';
@@ -26,6 +34,12 @@ 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';
@@ -50,12 +64,17 @@ 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';

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

@@ -17,6 +17,9 @@ export const Permission = Schema.Literal(
   'role:manage',
   'training-type:create',
   'training-type:delete',
+  'event:create',
+  'event:edit',
+  'event:cancel',
 );
 export type Permission = typeof Permission.Type;
 
@@ -36,8 +39,20 @@ export const defaultPermissions: Record<string, ReadonlyArray<Permission>> = {
     'role:manage',
     'training-type:create',
     'training-type:delete',
+    'event:create',
+    'event:edit',
+    'event:cancel',
+  ],
+  Captain: [
+    'roster:view',
+    'roster:manage',
+    'member:view',
+    'member:edit',
+    'role:view',
+    'event:create',
+    'event:edit',
+    'event:cancel',
   ],
-  Captain: ['roster:view', 'roster:manage', 'member:view', 'member:edit', 'role:view'],
   Player: ['roster:view', 'member:view'],
 };
 

package/src/models/Session.ts

@@ -1,16 +1,12 @@
 import { Model } from '@effect/sql';
-import { DateTime, Schema } from 'effect';
+import * as Schemas from '@sideline/effect-lib/Schemas';
+import { Schema } from 'effect';
 import { UserId } from '~/models/User.js';
 
-const DateTimeFromDate = Schema.transform(Schema.DateFromSelf, Schema.DateTimeUtcFromSelf, {
-  decode: (date) => DateTime.unsafeFromDate(date),
-  encode: (dt) => new Date(DateTime.toEpochMillis(dt)),
-});
-
 export class Session extends Model.Class<Session>('Session')({
   id: Model.Generated(Schema.String),
   user_id: UserId,
   token: Schema.String,
-  expires_at: DateTimeFromDate,
+  expires_at: Schemas.DateTimeFromDate,
   created_at: Model.DateTimeInsertFromDate,
 }) {}

package/src/models/TeamInvite.ts

@@ -1,18 +1,12 @@
 import { Model } from '@effect/sql';
-import { DateTime, Schema } from 'effect';
+import * as Schemas from '@sideline/effect-lib/Schemas';
+import { Schema } from 'effect';
 import { TeamId } from '~/models/Team.js';
 import { UserId } from '~/models/User.js';
 
 export const TeamInviteId = Schema.String.pipe(Schema.brand('TeamInviteId'));
 export type TeamInviteId = typeof TeamInviteId.Type;
 
-const NullableDateTimeFromDate = Schema.NullOr(
-  Schema.transform(Schema.DateFromSelf, Schema.DateTimeUtcFromSelf, {
-    decode: (date) => DateTime.unsafeFromDate(date),
-    encode: (dt) => new Date(DateTime.toEpochMillis(dt)),
-  }),
-);
-
 export class TeamInvite extends Model.Class<TeamInvite>('TeamInvite')({
   id: Model.Generated(TeamInviteId),
   team_id: TeamId,
@@ -20,5 +14,5 @@ export class TeamInvite extends Model.Class<TeamInvite>('TeamInvite')({
   active: Schema.Boolean,
   created_by: UserId,
   created_at: Model.DateTimeInsertFromDate,
-  expires_at: NullableDateTimeFromDate,
+  expires_at: Schema.NullOr(Schemas.DateTimeFromDate),
 }) {}

package/src/models/TeamSettings.ts

@@ -0,0 +1,10 @@
+import { Model } from '@effect/sql';
+import { Schema } from 'effect';
+import { TeamId } from '~/models/Team.js';
+
+export class TeamSettings extends Model.Class<TeamSettings>('TeamSettings')({
+  team_id: TeamId,
+  event_horizon_days: Schema.Int,
+  created_at: Model.DateTimeInsertFromDate,
+  updated_at: Model.DateTimeUpdateFromDate,
+}) {}

package/src/models/User.ts

@@ -1,4 +1,5 @@
 import { Model } from '@effect/sql';
+import * as Schemas from '@sideline/effect-lib/Schemas';
 import { Schema } from 'effect';
 
 export const UserId = Schema.String.pipe(Schema.brand('UserId'));
@@ -18,7 +19,7 @@ export class User extends Model.Class<User>('User')({
   discord_access_token: Model.Sensitive(Schema.String),
   discord_refresh_token: Model.Sensitive(Schema.NullOr(Schema.String)),
   name: Schema.NullOr(Schema.String),
-  birth_year: Schema.NullOr(Schema.Number),
+  birth_date: Schema.OptionFromNullOr(Schemas.DateTimeFromDate),
   gender: Schema.NullOr(Gender),
   locale: Locale,
   created_at: Model.DateTimeInsertFromDate,

package/src/rpc/SyncRpcs.ts

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

package/src/rpc/event/EventRpcEvents.ts

@@ -0,0 +1,48 @@
+import { Schema } from 'effect';
+import { Discord, Event, Team } from '~/index.js';
+
+export class EventCreatedEvent extends Schema.TaggedClass<EventCreatedEvent>()('event_created', {
+  id: Schema.String,
+  team_id: Team.TeamId,
+  guild_id: Discord.Snowflake,
+  event_id: Event.EventId,
+  title: Schema.String,
+  description: Schema.NullOr(Schema.String),
+  start_at: Schema.String,
+  end_at: Schema.NullOr(Schema.String),
+  location: Schema.NullOr(Schema.String),
+  event_type: Schema.String,
+  discord_channel_id: Schema.NullOr(Schema.String),
+}) {}
+
+export class EventUpdatedEvent extends Schema.TaggedClass<EventUpdatedEvent>()('event_updated', {
+  id: Schema.String,
+  team_id: Team.TeamId,
+  guild_id: Discord.Snowflake,
+  event_id: Event.EventId,
+  title: Schema.String,
+  description: Schema.NullOr(Schema.String),
+  start_at: Schema.String,
+  end_at: Schema.NullOr(Schema.String),
+  location: Schema.NullOr(Schema.String),
+  event_type: Schema.String,
+  discord_channel_id: Schema.NullOr(Schema.String),
+}) {}
+
+export class EventCancelledEvent extends Schema.TaggedClass<EventCancelledEvent>()(
+  'event_cancelled',
+  {
+    id: Schema.String,
+    team_id: Team.TeamId,
+    guild_id: Discord.Snowflake,
+    event_id: Event.EventId,
+  },
+) {}
+
+export const UnprocessedEventSyncEvent = Schema.Union(
+  EventCreatedEvent,
+  EventUpdatedEvent,
+  EventCancelledEvent,
+);
+
+export type UnprocessedEventSyncEvent = Schema.Schema.Type<typeof UnprocessedEventSyncEvent>;

package/src/rpc/event/EventRpcGroup.ts

@@ -0,0 +1,60 @@
+import { Rpc, RpcGroup } from '@effect/rpc';
+import { Schema } from 'effect';
+import { Discord, Event, EventRsvp, Team } from '~/index.js';
+import { UnprocessedEventSyncEvent } from './EventRpcEvents.js';
+import {
+  EventDiscordMessage,
+  EventEmbedInfo,
+  RsvpAttendeesResult,
+  RsvpCountsResult,
+  RsvpDeadlinePassed,
+  RsvpEventNotFound,
+  RsvpMemberNotFound,
+} from './EventRpcModels.js';
+
+export const EventRpcGroup = RpcGroup.make(
+  Rpc.make('GetUnprocessedEvents', {
+    payload: { limit: Schema.Number },
+    success: Schema.Array(UnprocessedEventSyncEvent),
+  }),
+  Rpc.make('MarkEventProcessed', {
+    payload: { id: Schema.String },
+  }),
+  Rpc.make('MarkEventFailed', {
+    payload: { id: Schema.String, error: Schema.String },
+  }),
+  Rpc.make('SaveDiscordMessageId', {
+    payload: {
+      event_id: Event.EventId,
+      discord_channel_id: Schema.String,
+      discord_message_id: Schema.String,
+    },
+  }),
+  Rpc.make('GetDiscordMessageId', {
+    payload: { event_id: Event.EventId },
+    success: Schema.OptionFromNullOr(EventDiscordMessage),
+  }),
+  Rpc.make('SubmitRsvp', {
+    payload: {
+      event_id: Event.EventId,
+      team_id: Team.TeamId,
+      discord_user_id: Discord.Snowflake,
+      response: EventRsvp.RsvpResponse,
+      message: Schema.NullOr(Schema.String),
+    },
+    success: RsvpCountsResult,
+    error: Schema.Union(RsvpMemberNotFound, RsvpDeadlinePassed, RsvpEventNotFound),
+  }),
+  Rpc.make('GetRsvpCounts', {
+    payload: { event_id: Event.EventId },
+    success: RsvpCountsResult,
+  }),
+  Rpc.make('GetEventEmbedInfo', {
+    payload: { event_id: Event.EventId },
+    success: Schema.OptionFromNullOr(EventEmbedInfo),
+  }),
+  Rpc.make('GetRsvpAttendees', {
+    payload: { event_id: Event.EventId, offset: Schema.Number, limit: Schema.Number },
+    success: RsvpAttendeesResult,
+  }),
+).prefix('Event/');

package/src/rpc/event/EventRpcModels.ts

@@ -0,0 +1,49 @@
+import { Schema } from 'effect';
+
+export class EventDiscordMessage extends Schema.Class<EventDiscordMessage>('EventDiscordMessage')({
+  discord_channel_id: Schema.String,
+  discord_message_id: Schema.String,
+}) {}
+
+export class RsvpCountsResult extends Schema.Class<RsvpCountsResult>('RsvpCountsResult')({
+  yesCount: Schema.Number,
+  noCount: Schema.Number,
+  maybeCount: Schema.Number,
+  canRsvp: Schema.Boolean,
+}) {}
+
+export class EventEmbedInfo extends Schema.Class<EventEmbedInfo>('EventEmbedInfo')({
+  title: Schema.String,
+  description: Schema.OptionFromNullOr(Schema.String),
+  start_at: Schema.String,
+  end_at: Schema.OptionFromNullOr(Schema.String),
+  location: Schema.OptionFromNullOr(Schema.String),
+  event_type: Schema.String,
+}) {}
+
+export class RsvpMemberNotFound extends Schema.TaggedError<RsvpMemberNotFound>()(
+  'RsvpMemberNotFound',
+  {},
+) {}
+
+export class RsvpDeadlinePassed extends Schema.TaggedError<RsvpDeadlinePassed>()(
+  'RsvpDeadlinePassed',
+  {},
+) {}
+
+export class RsvpEventNotFound extends Schema.TaggedError<RsvpEventNotFound>()(
+  'RsvpEventNotFound',
+  {},
+) {}
+
+export class RsvpAttendeeEntry extends Schema.Class<RsvpAttendeeEntry>('RsvpAttendeeEntry')({
+  discord_id: Schema.NullOr(Schema.String),
+  name: Schema.NullOr(Schema.String),
+  response: Schema.Literal('yes', 'no', 'maybe'),
+  message: Schema.NullOr(Schema.String),
+}) {}
+
+export class RsvpAttendeesResult extends Schema.Class<RsvpAttendeesResult>('RsvpAttendeesResult')({
+  attendees: Schema.Array(RsvpAttendeeEntry),
+  total: Schema.Number,
+}) {}