@sideline/domain 0.1.2 → 0.2.0

package/src/api/RoleApi.ts

@@ -0,0 +1,130 @@
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from '@effect/platform';
+import { Schema } from 'effect';
+import { AuthMiddleware } from '~/api/Auth.js';
+import { Permission, RoleId } from '~/models/Role.js';
+import { TeamId } from '~/models/Team.js';
+import { TeamMemberId } from '~/models/TeamMember.js';
+
+export class RoleInfo extends Schema.Class<RoleInfo>('RoleInfo')({
+  roleId: RoleId,
+  teamId: TeamId,
+  name: Schema.String,
+  isBuiltIn: Schema.Boolean,
+  permissionCount: Schema.Number,
+}) {}
+
+export class RoleDetail extends Schema.Class<RoleDetail>('RoleDetail')({
+  roleId: RoleId,
+  teamId: TeamId,
+  name: Schema.String,
+  isBuiltIn: Schema.Boolean,
+  permissions: Schema.Array(Permission),
+}) {}
+
+export class CreateRoleRequest extends Schema.Class<CreateRoleRequest>('CreateRoleRequest')({
+  name: Schema.NonEmptyString,
+  permissions: Schema.Array(Permission),
+}) {}
+
+export class UpdateRoleRequest extends Schema.Class<UpdateRoleRequest>('UpdateRoleRequest')({
+  name: Schema.NullOr(Schema.NonEmptyString),
+  permissions: Schema.NullOr(Schema.Array(Permission)),
+}) {}
+
+export class RoleNotFound extends Schema.TaggedError<RoleNotFound>()(
+  'RoleNotFound',
+  {},
+  HttpApiSchema.annotations({ status: 404 }),
+) {}
+
+export class Forbidden extends Schema.TaggedError<Forbidden>()(
+  'RoleForbidden',
+  {},
+  HttpApiSchema.annotations({ status: 403 }),
+) {}
+
+export class CannotModifyBuiltIn extends Schema.TaggedError<CannotModifyBuiltIn>()(
+  'CannotModifyBuiltIn',
+  {},
+  HttpApiSchema.annotations({ status: 400 }),
+) {}
+
+export class AssignRoleRequest extends Schema.Class<AssignRoleRequest>('AssignRoleRequest')({
+  roleId: RoleId,
+}) {}
+
+export class MemberNotFound extends Schema.TaggedError<MemberNotFound>()(
+  'MemberNotFound',
+  {},
+  HttpApiSchema.annotations({ status: 404 }),
+) {}
+
+export class RoleInUse extends Schema.TaggedError<RoleInUse>()(
+  'RoleInUse',
+  {},
+  HttpApiSchema.annotations({ status: 409 }),
+) {}
+
+export class RoleApiGroup extends HttpApiGroup.make('role')
+  .add(
+    HttpApiEndpoint.get('listRoles', '/teams/:teamId/roles')
+      .addSuccess(Schema.Array(RoleInfo))
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('createRole', '/teams/:teamId/roles')
+      .addSuccess(RoleDetail, { status: 201 })
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .setPayload(CreateRoleRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.get('getRole', '/teams/:teamId/roles/:roleId')
+      .addSuccess(RoleDetail)
+      .addError(Forbidden, { status: 403 })
+      .addError(RoleNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, roleId: RoleId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.patch('updateRole', '/teams/:teamId/roles/:roleId')
+      .addSuccess(RoleDetail)
+      .addError(Forbidden, { status: 403 })
+      .addError(RoleNotFound, { status: 404 })
+      .addError(CannotModifyBuiltIn, { status: 400 })
+      .setPath(Schema.Struct({ teamId: TeamId, roleId: RoleId }))
+      .setPayload(UpdateRoleRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.del('deleteRole', '/teams/:teamId/roles/:roleId')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(RoleNotFound, { status: 404 })
+      .addError(CannotModifyBuiltIn, { status: 400 })
+      .addError(RoleInUse, { status: 409 })
+      .setPath(Schema.Struct({ teamId: TeamId, roleId: RoleId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('assignRole', '/teams/:teamId/members/:memberId/roles')
+      .addSuccess(Schema.Void, { status: 204 })
+      .addError(Forbidden, { status: 403 })
+      .addError(MemberNotFound, { status: 404 })
+      .addError(RoleNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, memberId: TeamMemberId }))
+      .setPayload(AssignRoleRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.del('unassignRole', '/teams/:teamId/members/:memberId/roles/:roleId')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(MemberNotFound, { status: 404 })
+      .addError(RoleNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, memberId: TeamMemberId, roleId: RoleId }))
+      .middleware(AuthMiddleware),
+  ) {}

package/src/api/Roster.ts

@@ -0,0 +1,176 @@
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from '@effect/platform';
+import { Schema } from 'effect';
+import { AuthMiddleware } from '~/api/Auth.js';
+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';
+
+export class RosterPlayer extends Schema.Class<RosterPlayer>('RosterPlayer')({
+  memberId: TeamMemberId,
+  userId: UserId,
+  roleNames: Schema.Array(Schema.String),
+  permissions: Schema.Array(Permission),
+  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),
+  discordUsername: Schema.String,
+  discordAvatar: Schema.NullOr(Schema.String),
+}) {}
+
+export class UpdatePlayerRequest extends Schema.Class<UpdatePlayerRequest>('UpdatePlayerRequest')({
+  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),
+}) {}
+
+export class PlayerNotFound extends Schema.TaggedError<PlayerNotFound>()(
+  'PlayerNotFound',
+  {},
+  HttpApiSchema.annotations({ status: 404 }),
+) {}
+
+export class Forbidden extends Schema.TaggedError<Forbidden>()(
+  'Forbidden',
+  {},
+  HttpApiSchema.annotations({ status: 403 }),
+) {}
+
+export class RosterNotFound extends Schema.TaggedError<RosterNotFound>()(
+  'RosterNotFound',
+  {},
+  HttpApiSchema.annotations({ status: 404 }),
+) {}
+
+export class RosterInfo extends Schema.Class<RosterInfo>('RosterInfo')({
+  rosterId: RosterId,
+  teamId: TeamId,
+  name: Schema.String,
+  active: Schema.Boolean,
+  memberCount: Schema.Number,
+  createdAt: Schema.String,
+}) {}
+
+export class RosterDetail extends Schema.Class<RosterDetail>('RosterDetail')({
+  rosterId: RosterId,
+  teamId: TeamId,
+  name: Schema.String,
+  active: Schema.Boolean,
+  createdAt: Schema.String,
+  members: Schema.Array(RosterPlayer),
+}) {}
+
+export class CreateRosterRequest extends Schema.Class<CreateRosterRequest>('CreateRosterRequest')({
+  name: Schema.String,
+}) {}
+
+export class UpdateRosterRequest extends Schema.Class<UpdateRosterRequest>('UpdateRosterRequest')({
+  name: Schema.NullOr(Schema.String),
+  active: Schema.NullOr(Schema.Boolean),
+}) {}
+
+export class AddRosterMemberRequest extends Schema.Class<AddRosterMemberRequest>(
+  'AddRosterMemberRequest',
+)({
+  memberId: TeamMemberId,
+}) {}
+
+export class RosterApiGroup extends HttpApiGroup.make('roster')
+  .add(
+    HttpApiEndpoint.get('listMembers', '/teams/:teamId/members')
+      .addSuccess(Schema.Array(RosterPlayer))
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.get('getMember', '/teams/:teamId/members/:memberId')
+      .addSuccess(RosterPlayer)
+      .addError(Forbidden, { status: 403 })
+      .addError(PlayerNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, memberId: TeamMemberId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.patch('updateMember', '/teams/:teamId/members/:memberId')
+      .addSuccess(RosterPlayer)
+      .addError(Forbidden, { status: 403 })
+      .addError(PlayerNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, memberId: TeamMemberId }))
+      .setPayload(UpdatePlayerRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.del('deactivateMember', '/teams/:teamId/members/:memberId')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(PlayerNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, memberId: TeamMemberId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.get('listRosters', '/teams/:teamId/rosters')
+      .addSuccess(Schema.Array(RosterInfo))
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('createRoster', '/teams/:teamId/rosters')
+      .addSuccess(RosterInfo, { status: 201 })
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .setPayload(CreateRosterRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.get('getRoster', '/teams/:teamId/rosters/:rosterId')
+      .addSuccess(RosterDetail)
+      .addError(Forbidden, { status: 403 })
+      .addError(RosterNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, rosterId: RosterId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.patch('updateRoster', '/teams/:teamId/rosters/:rosterId')
+      .addSuccess(RosterInfo)
+      .addError(Forbidden, { status: 403 })
+      .addError(RosterNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, rosterId: RosterId }))
+      .setPayload(UpdateRosterRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.del('deleteRoster', '/teams/:teamId/rosters/:rosterId')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(RosterNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, rosterId: RosterId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('addRosterMember', '/teams/:teamId/rosters/:rosterId/members')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(RosterNotFound, { status: 404 })
+      .addError(PlayerNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, rosterId: RosterId }))
+      .setPayload(AddRosterMemberRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.del('removeRosterMember', '/teams/:teamId/rosters/:rosterId/members/:memberId')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(RosterNotFound, { status: 404 })
+      .addError(PlayerNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, rosterId: RosterId, memberId: TeamMemberId }))
+      .middleware(AuthMiddleware),
+  ) {}

package/src/api/SubgroupApi.ts

@@ -0,0 +1,146 @@
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from '@effect/platform';
+import { Schema } from 'effect';
+import { AuthMiddleware } from '~/api/Auth.js';
+import { Permission } from '~/models/Role.js';
+import { SubgroupId } from '~/models/SubgroupModel.js';
+import { TeamId } from '~/models/Team.js';
+import { TeamMemberId } from '~/models/TeamMember.js';
+
+export class SubgroupInfo extends Schema.Class<SubgroupInfo>('SubgroupInfo')({
+  subgroupId: SubgroupId,
+  teamId: TeamId,
+  name: Schema.String,
+  memberCount: Schema.Number,
+}) {}
+
+export class SubgroupDetail extends Schema.Class<SubgroupDetail>('SubgroupDetail')({
+  subgroupId: SubgroupId,
+  teamId: TeamId,
+  name: Schema.String,
+  permissions: Schema.Array(Permission),
+  members: Schema.Array(
+    Schema.Struct({
+      memberId: TeamMemberId,
+      name: Schema.NullOr(Schema.String),
+      discordUsername: Schema.String,
+    }),
+  ),
+}) {}
+
+export class CreateSubgroupRequest extends Schema.Class<CreateSubgroupRequest>(
+  'CreateSubgroupRequest',
+)({
+  name: Schema.NonEmptyString,
+}) {}
+
+export class UpdateSubgroupRequest extends Schema.Class<UpdateSubgroupRequest>(
+  'UpdateSubgroupRequest',
+)({
+  name: Schema.NonEmptyString,
+}) {}
+
+export class AddSubgroupMemberRequest extends Schema.Class<AddSubgroupMemberRequest>(
+  'AddSubgroupMemberRequest',
+)({
+  memberId: TeamMemberId,
+}) {}
+
+export class SetSubgroupPermissionsRequest extends Schema.Class<SetSubgroupPermissionsRequest>(
+  'SetSubgroupPermissionsRequest',
+)({
+  permissions: Schema.Array(Permission),
+}) {}
+
+export class SubgroupNotFound extends Schema.TaggedError<SubgroupNotFound>()(
+  'SubgroupNotFound',
+  {},
+  HttpApiSchema.annotations({ status: 404 }),
+) {}
+
+export class Forbidden extends Schema.TaggedError<Forbidden>()(
+  'SubgroupForbidden',
+  {},
+  HttpApiSchema.annotations({ status: 403 }),
+) {}
+
+export class MemberNotFound extends Schema.TaggedError<MemberNotFound>()(
+  'SubgroupMemberNotFound',
+  {},
+  HttpApiSchema.annotations({ status: 404 }),
+) {}
+
+export class SubgroupApiGroup extends HttpApiGroup.make('subgroup')
+  .add(
+    HttpApiEndpoint.get('listSubgroups', '/teams/:teamId/subgroups')
+      .addSuccess(Schema.Array(SubgroupInfo))
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('createSubgroup', '/teams/:teamId/subgroups')
+      .addSuccess(SubgroupInfo, { status: 201 })
+      .addError(Forbidden, { status: 403 })
+      .setPath(Schema.Struct({ teamId: TeamId }))
+      .setPayload(CreateSubgroupRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.get('getSubgroup', '/teams/:teamId/subgroups/:subgroupId')
+      .addSuccess(SubgroupDetail)
+      .addError(Forbidden, { status: 403 })
+      .addError(SubgroupNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, subgroupId: SubgroupId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.patch('updateSubgroup', '/teams/:teamId/subgroups/:subgroupId')
+      .addSuccess(SubgroupInfo)
+      .addError(Forbidden, { status: 403 })
+      .addError(SubgroupNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, subgroupId: SubgroupId }))
+      .setPayload(UpdateSubgroupRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.del('deleteSubgroup', '/teams/:teamId/subgroups/:subgroupId')
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(SubgroupNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, subgroupId: SubgroupId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.post('addSubgroupMember', '/teams/:teamId/subgroups/:subgroupId/members')
+      .addSuccess(Schema.Void, { status: 204 })
+      .addError(Forbidden, { status: 403 })
+      .addError(SubgroupNotFound, { status: 404 })
+      .addError(MemberNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, subgroupId: SubgroupId }))
+      .setPayload(AddSubgroupMemberRequest)
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.del(
+      'removeSubgroupMember',
+      '/teams/:teamId/subgroups/:subgroupId/members/:memberId',
+    )
+      .addSuccess(Schema.Void)
+      .addError(Forbidden, { status: 403 })
+      .addError(SubgroupNotFound, { status: 404 })
+      .addError(MemberNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, subgroupId: SubgroupId, memberId: TeamMemberId }))
+      .middleware(AuthMiddleware),
+  )
+  .add(
+    HttpApiEndpoint.patch(
+      'setSubgroupPermissions',
+      '/teams/:teamId/subgroups/:subgroupId/permissions',
+    )
+      .addSuccess(SubgroupDetail)
+      .addError(Forbidden, { status: 403 })
+      .addError(SubgroupNotFound, { status: 404 })
+      .setPath(Schema.Struct({ teamId: TeamId, subgroupId: SubgroupId }))
+      .setPayload(SetSubgroupPermissionsRequest)
+      .middleware(AuthMiddleware),
+  ) {}

package/src/index.ts

@@ -1,11 +1,35 @@
 export * as ApiGroup from './ApiGroup.js';
 
+export * as AgeThresholdApi from './api/AgeThresholdApi.js';
+
 export * as Auth from './api/Auth.js';
 
 export * as Invite from './api/Invite.js';
 
+export * as NotificationApi from './api/NotificationApi.js';
+
+export * as RoleApi from './api/RoleApi.js';
+
+export * as Roster from './api/Roster.js';
+
+export * as SubgroupApi from './api/SubgroupApi.js';
+
+export * as AgeThresholdRule from './models/AgeThresholdRule.js';
+
+export * as MemberRole from './models/MemberRole.js';
+
+export * as Notification from './models/Notification.js';
+
+export * as Role from './models/Role.js';
+
+export * as RosterMemberModel from './models/RosterMemberModel.js';
+
+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';

package/src/models/AgeThresholdRule.ts

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

package/src/models/MemberRole.ts

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

package/src/models/Notification.ts

@@ -0,0 +1,26 @@
+import { Model } from '@effect/sql';
+import { Schema } from 'effect';
+import { TeamId } from '~/models/Team.js';
+import { UserId } from '~/models/User.js';
+
+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',
+  'role_assigned',
+  'role_removed',
+);
+export type NotificationType = typeof NotificationType.Type;
+
+export class Notification extends Model.Class<Notification>('Notification')({
+  id: Model.Generated(NotificationId),
+  team_id: TeamId,
+  user_id: UserId,
+  type: NotificationType,
+  title: Schema.String,
+  body: Schema.String,
+  is_read: Schema.Boolean,
+  created_at: Model.DateTimeInsertFromDate,
+}) {}

package/src/models/Role.ts

@@ -0,0 +1,53 @@
+import { Model } from '@effect/sql';
+import { Schema } from 'effect';
+import { TeamId } from '~/models/Team.js';
+
+export const RoleId = Schema.String.pipe(Schema.brand('RoleId'));
+export type RoleId = typeof RoleId.Type;
+
+export const Permission = Schema.Literal(
+  'team:manage',
+  'team:invite',
+  'roster:view',
+  'roster:manage',
+  'member:view',
+  'member:edit',
+  'member:remove',
+  'role:view',
+  'role:manage',
+);
+export type Permission = typeof Permission.Type;
+
+export const allPermissions: ReadonlyArray<Permission> =
+  Permission.literals as ReadonlyArray<Permission>;
+
+export const defaultPermissions: Record<string, ReadonlyArray<Permission>> = {
+  Admin: [
+    'team:manage',
+    'team:invite',
+    'roster:view',
+    'roster:manage',
+    'member:view',
+    'member:edit',
+    'member:remove',
+    'role:view',
+    'role:manage',
+  ],
+  Captain: ['roster:view', 'roster:manage', 'member:view', 'member:edit', 'role:view'],
+  Player: ['roster:view', 'member:view'],
+};
+
+export const builtInRoleNames = ['Admin', 'Captain', 'Player'] as const;
+
+export class Role extends Model.Class<Role>('Role')({
+  id: Model.Generated(RoleId),
+  team_id: TeamId,
+  name: Schema.String,
+  is_built_in: Schema.Boolean,
+  created_at: Model.DateTimeInsertFromDate,
+}) {}
+
+export class RolePermission extends Schema.Class<RolePermission>('RolePermission')({
+  role_id: RoleId,
+  permission: Permission,
+}) {}

package/src/models/RosterMemberModel.ts

@@ -0,0 +1,14 @@
+import { Model } from '@effect/sql';
+import { Schema } from 'effect';
+import { RosterId } from '~/models/RosterModel.js';
+import { TeamMemberId } from '~/models/TeamMember.js';
+
+export const RosterMemberId = Schema.String.pipe(Schema.brand('RosterMemberId'));
+export type RosterMemberId = typeof RosterMemberId.Type;
+
+export class RosterMember extends Model.Class<RosterMember>('RosterMember')({
+  id: Model.Generated(RosterMemberId),
+  roster_id: RosterId,
+  team_member_id: TeamMemberId,
+  created_at: Model.DateTimeInsertFromDate,
+}) {}

package/src/models/RosterModel.ts

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

package/src/models/SubgroupModel.ts

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

package/src/models/TeamMember.ts

@@ -6,13 +6,10 @@ import { UserId } from '~/models/User.js';
 export const TeamMemberId = Schema.String.pipe(Schema.brand('TeamMemberId'));
 export type TeamMemberId = typeof TeamMemberId.Type;
 
-export const TeamRole = Schema.Literal('admin', 'member');
-export type TeamRole = typeof TeamRole.Type;
-
 export class TeamMember extends Model.Class<TeamMember>('TeamMember')({
   id: Model.Generated(TeamMemberId),
   team_id: TeamId,
   user_id: UserId,
-  role: TeamRole,
+  active: Schema.Boolean,
   joined_at: Model.DateTimeInsertFromDate,
 }) {}