@sideline/domain 0.2.0 → 0.4.0

package/src/models/ChannelSyncEvent.ts

@@ -0,0 +1,30 @@
+import { Model } from '@effect/sql';
+import { Schema } from 'effect';
+import { SubgroupId } from '~/models/SubgroupModel.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,
+  subgroup_id: SubgroupId,
+  subgroup_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 { SubgroupId } from '~/models/SubgroupModel.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,
+  subgroup_id: SubgroupId,
+  discord_channel_id: Schema.String,
+  discord_role_id: Schema.OptionFromNullOr(Schema.String),
+  created_at: Model.DateTimeInsertFromDate,
+}) {}

package/src/models/DiscordRoleMapping.ts

@@ -0,0 +1,15 @@
+import { Model } from '@effect/sql';
+import { Schema } from 'effect';
+import { RoleId } from '~/models/Role.js';
+import { TeamId } from '~/models/Team.js';
+
+export const DiscordRoleMappingId = Schema.String.pipe(Schema.brand('DiscordRoleMappingId'));
+export type DiscordRoleMappingId = typeof DiscordRoleMappingId.Type;
+
+export class DiscordRoleMapping extends Model.Class<DiscordRoleMapping>('DiscordRoleMapping')({
+  id: Model.Generated(DiscordRoleMappingId),
+  team_id: TeamId,
+  role_id: RoleId,
+  discord_role_id: Schema.String,
+  created_at: Model.DateTimeInsertFromDate,
+}) {}

package/src/models/RoleSyncEvent.ts

@@ -0,0 +1,30 @@
+import { Model } from '@effect/sql';
+import { Schema } from 'effect';
+import { RoleId } from '~/models/Role.js';
+import { TeamId } from '~/models/Team.js';
+import { TeamMemberId } from '~/models/TeamMember.js';
+
+export const RoleSyncEventId = Schema.String.pipe(Schema.brand('RoleSyncEventId'));
+export type RoleSyncEventId = typeof RoleSyncEventId.Type;
+
+export const RoleSyncEventType = Schema.Literal(
+  'role_assigned',
+  'role_unassigned',
+  'role_created',
+  'role_deleted',
+);
+export type RoleSyncEventType = typeof RoleSyncEventType.Type;
+
+export class RoleSyncEvent extends Model.Class<RoleSyncEvent>('RoleSyncEvent')({
+  id: Model.Generated(RoleSyncEventId),
+  team_id: TeamId,
+  guild_id: Schema.String,
+  event_type: RoleSyncEventType,
+  role_id: RoleId,
+  role_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/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,
 }) {}

package/src/models/TrainingType.ts

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

package/src/models/User.ts

@@ -7,12 +7,6 @@ export type UserId = typeof UserId.Type;
 export const Gender = Schema.Literal('male', 'female', 'other');
 export type Gender = typeof Gender.Type;
 
-export const Position = Schema.Literal('goalkeeper', 'defender', 'midfielder', 'forward');
-export type Position = typeof Position.Type;
-
-export const Proficiency = Schema.Literal('beginner', 'intermediate', 'advanced', 'pro');
-export type Proficiency = typeof Proficiency.Type;
-
 export const Locale = Schema.Literal('en', 'cs');
 export type Locale = typeof Locale.Type;
 
@@ -26,9 +20,6 @@ export class User extends Model.Class<User>('User')({
   name: Schema.NullOr(Schema.String),
   birth_year: Schema.NullOr(Schema.Number),
   gender: Schema.NullOr(Gender),
-  jersey_number: Schema.NullOr(Schema.Number),
-  position: Schema.NullOr(Position),
-  proficiency: Schema.NullOr(Proficiency),
   locale: Locale,
   created_at: Model.DateTimeInsertFromDate,
   is_profile_complete: Schema.Boolean,

package/src/rpc/SyncRpcs.ts

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

package/src/rpc/channel/ChannelRpcEvents.ts

@@ -0,0 +1,57 @@
+import { Schema } from 'effect';
+import { ChannelSyncEvent, Discord, SubgroupModel, Team, TeamMember } from '~/index.js';
+
+export class ChannelCreatedEvent extends Schema.TaggedClass<ChannelCreatedEvent>()(
+  'channel_created',
+  {
+    id: ChannelSyncEvent.ChannelSyncEventId,
+    team_id: Team.TeamId,
+    guild_id: Discord.Snowflake,
+    subgroup_id: SubgroupModel.SubgroupId,
+    subgroup_name: Schema.String,
+  },
+) {}
+
+export class ChannelDeletedEvent extends Schema.TaggedClass<ChannelDeletedEvent>()(
+  'channel_deleted',
+  {
+    id: ChannelSyncEvent.ChannelSyncEventId,
+    team_id: Team.TeamId,
+    guild_id: Discord.Snowflake,
+    subgroup_id: SubgroupModel.SubgroupId,
+  },
+) {}
+
+export class ChannelMemberAddedEvent extends Schema.TaggedClass<ChannelMemberAddedEvent>()(
+  'channel_member_added',
+  {
+    id: ChannelSyncEvent.ChannelSyncEventId,
+    team_id: Team.TeamId,
+    guild_id: Discord.Snowflake,
+    subgroup_id: SubgroupModel.SubgroupId,
+    subgroup_name: Schema.String,
+    team_member_id: TeamMember.TeamMemberId,
+    discord_user_id: Discord.Snowflake,
+  },
+) {}
+
+export class ChannelMemberRemovedEvent extends Schema.TaggedClass<ChannelMemberRemovedEvent>()(
+  'channel_member_removed',
+  {
+    id: ChannelSyncEvent.ChannelSyncEventId,
+    team_id: Team.TeamId,
+    guild_id: Discord.Snowflake,
+    subgroup_id: SubgroupModel.SubgroupId,
+    team_member_id: TeamMember.TeamMemberId,
+    discord_user_id: Discord.Snowflake,
+  },
+) {}
+
+export const UnprocessedChannelEvent = Schema.Union(
+  ChannelCreatedEvent,
+  ChannelDeletedEvent,
+  ChannelMemberAddedEvent,
+  ChannelMemberRemovedEvent,
+);
+
+export type UnprocessedChannelEvent = Schema.Schema.Type<typeof UnprocessedChannelEvent>;

package/src/rpc/channel/ChannelRpcGroup.ts

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

package/src/rpc/channel/ChannelRpcModels.ts

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

package/src/rpc/role/RoleRpcEvents.ts

@@ -0,0 +1,48 @@
+import { Schema } from 'effect';
+import { Discord, Role, RoleSyncEvent, Team, TeamMember } from '~/index.js';
+
+export class RoleCreatedEvent extends Schema.TaggedClass<RoleCreatedEvent>()('role_created', {
+  id: RoleSyncEvent.RoleSyncEventId,
+  team_id: Team.TeamId,
+  guild_id: Discord.Snowflake,
+  role_id: Role.RoleId,
+  role_name: Schema.String,
+}) {}
+
+export class RoleDeletedEvent extends Schema.TaggedClass<RoleDeletedEvent>()('role_deleted', {
+  id: RoleSyncEvent.RoleSyncEventId,
+  team_id: Team.TeamId,
+  guild_id: Discord.Snowflake,
+  role_id: Role.RoleId,
+}) {}
+
+export class RoleAssignedEvent extends Schema.TaggedClass<RoleAssignedEvent>()('role_assigned', {
+  id: RoleSyncEvent.RoleSyncEventId,
+  team_id: Team.TeamId,
+  guild_id: Discord.Snowflake,
+  role_id: Role.RoleId,
+  role_name: Schema.String,
+  team_member_id: TeamMember.TeamMemberId,
+  discord_user_id: Discord.Snowflake,
+}) {}
+
+export class RoleUnassignedEvent extends Schema.TaggedClass<RoleUnassignedEvent>()(
+  'role_unassigned',
+  {
+    id: RoleSyncEvent.RoleSyncEventId,
+    team_id: Team.TeamId,
+    guild_id: Discord.Snowflake,
+    role_id: Role.RoleId,
+    team_member_id: TeamMember.TeamMemberId,
+    discord_user_id: Discord.Snowflake,
+  },
+) {}
+
+export const UnprocessedRoleEvent = Schema.Union(
+  RoleCreatedEvent,
+  RoleDeletedEvent,
+  RoleAssignedEvent,
+  RoleUnassignedEvent,
+);
+
+export type UnprocessedRoleEvent = Schema.Schema.Type<typeof UnprocessedRoleEvent>;

package/src/rpc/role/RoleRpcGroup.ts

@@ -0,0 +1,33 @@
+import { Rpc, RpcGroup } from '@effect/rpc';
+import { Schema } from 'effect';
+import { Discord, Role, RoleSyncEvent, Team } from '~/index.js';
+import { UnprocessedRoleEvent } from './RoleRpcEvents.js';
+import { RoleMapping } from './RoleRpcModels.js';
+
+export const RoleRpcGroup = RpcGroup.make(
+  Rpc.make('GetUnprocessedEvents', {
+    payload: { limit: Schema.Number },
+    success: Schema.Array(UnprocessedRoleEvent),
+  }),
+  Rpc.make('MarkEventProcessed', {
+    payload: { id: RoleSyncEvent.RoleSyncEventId },
+  }),
+  Rpc.make('MarkEventFailed', {
+    payload: { id: RoleSyncEvent.RoleSyncEventId, error: Schema.String },
+  }),
+  Rpc.make('GetMapping', {
+    payload: { team_id: Team.TeamId, role_id: Role.RoleId },
+    success: Schema.OptionFromNullOr(RoleMapping),
+  }),
+  Rpc.make('UpsertMapping', {
+    payload: {
+      team_id: Team.TeamId,
+      role_id: Role.RoleId,
+      discord_role_id: Discord.Snowflake,
+    },
+  }),
+
+  Rpc.make('DeleteMapping', {
+    payload: { team_id: Team.TeamId, role_id: Role.RoleId },
+  }),
+).prefix('Role/');

package/src/rpc/role/RoleRpcModels.ts

@@ -0,0 +1,9 @@
+import { Schema } from 'effect';
+import { Discord, DiscordRoleMapping, Role, Team } from '~/index.js';
+
+export class RoleMapping extends Schema.Class<RoleMapping>('RoleMapping')({
+  id: DiscordRoleMapping.DiscordRoleMappingId,
+  team_id: Team.TeamId,
+  role_id: Role.RoleId,
+  discord_role_id: Discord.Snowflake,
+}) {}