Refactor 4 with bugfixes

server/src/cqrs/commands/handlers/createJoinRequest.ts

@@ -0,0 +1,19 @@
+import { DataSource } from 'typeorm';
+import { JoinRequestEntity } from '../../../entities';
+import { CreateJoinRequestCommand } from '../../types';
+
+export async function handleCreateJoinRequest(command: CreateJoinRequestCommand, dataSource: DataSource): Promise<void> {
+  const repo = dataSource.getRepository(JoinRequestEntity);
+  const { request } = command.payload;
+  const entity = repo.create({
+    id: request.id,
+    serverId: request.serverId,
+    userId: request.userId,
+    userPublicKey: request.userPublicKey,
+    displayName: request.displayName,
+    status: request.status,
+    createdAt: request.createdAt
+  });
+
+  await repo.save(entity);
+}

server/src/cqrs/commands/handlers/deleteServer.ts

@@ -0,0 +1,10 @@
+import { DataSource } from 'typeorm';
+import { ServerEntity, JoinRequestEntity } from '../../../entities';
+import { DeleteServerCommand } from '../../types';
+
+export async function handleDeleteServer(command: DeleteServerCommand, dataSource: DataSource): Promise<void> {
+  const { serverId } = command.payload;
+
+  await dataSource.getRepository(JoinRequestEntity).delete({ serverId });
+  await dataSource.getRepository(ServerEntity).delete(serverId);
+}

server/src/cqrs/commands/handlers/deleteStaleJoinRequests.ts

@@ -0,0 +1,10 @@
+import { DataSource, LessThan } from 'typeorm';
+import { JoinRequestEntity } from '../../../entities';
+import { DeleteStaleJoinRequestsCommand } from '../../types';
+
+export async function handleDeleteStaleJoinRequests(command: DeleteStaleJoinRequestsCommand, dataSource: DataSource): Promise<void> {
+  const repo = dataSource.getRepository(JoinRequestEntity);
+  const cutoff = Date.now() - command.payload.maxAgeMs;
+
+  await repo.delete({ createdAt: LessThan(cutoff) });
+}

server/src/cqrs/commands/handlers/registerUser.ts

@@ -0,0 +1,17 @@
+import { DataSource } from 'typeorm';
+import { AuthUserEntity } from '../../../entities';
+import { RegisterUserCommand } from '../../types';
+
+export async function handleRegisterUser(command: RegisterUserCommand, dataSource: DataSource): Promise<void> {
+  const repo = dataSource.getRepository(AuthUserEntity);
+  const { user } = command.payload;
+  const entity = repo.create({
+    id: user.id,
+    username: user.username,
+    passwordHash: user.passwordHash,
+    displayName: user.displayName,
+    createdAt: user.createdAt
+  });
+
+  await repo.save(entity);
+}

server/src/cqrs/commands/handlers/updateJoinRequestStatus.ts

@@ -0,0 +1,10 @@
+import { DataSource } from 'typeorm';
+import { JoinRequestEntity } from '../../../entities';
+import { UpdateJoinRequestStatusCommand } from '../../types';
+
+export async function handleUpdateJoinRequestStatus(command: UpdateJoinRequestStatusCommand, dataSource: DataSource): Promise<void> {
+  const repo = dataSource.getRepository(JoinRequestEntity);
+  const { requestId, status } = command.payload;
+
+  await repo.update(requestId, { status });
+}

server/src/cqrs/commands/handlers/upsertServer.ts

@@ -0,0 +1,23 @@
+import { DataSource } from 'typeorm';
+import { ServerEntity } from '../../../entities';
+import { UpsertServerCommand } from '../../types';
+
+export async function handleUpsertServer(command: UpsertServerCommand, dataSource: DataSource): Promise<void> {
+  const repo = dataSource.getRepository(ServerEntity);
+  const { server } = command.payload;
+  const entity = repo.create({
+    id: server.id,
+    name: server.name,
+    description: server.description ?? null,
+    ownerId: server.ownerId,
+    ownerPublicKey: server.ownerPublicKey,
+    isPrivate: server.isPrivate ? 1 : 0,
+    maxUsers: server.maxUsers,
+    currentUsers: server.currentUsers,
+    tags: JSON.stringify(server.tags),
+    createdAt: server.createdAt,
+    lastSeen: server.lastSeen
+  });
+
+  await repo.save(entity);
+}

server/src/cqrs/commands/index.ts

@@ -0,0 +1,27 @@
+import { DataSource } from 'typeorm';
+import {
+  CommandType,
+  CommandTypeKey,
+  Command,
+  RegisterUserCommand,
+  UpsertServerCommand,
+  DeleteServerCommand,
+  CreateJoinRequestCommand,
+  UpdateJoinRequestStatusCommand,
+  DeleteStaleJoinRequestsCommand
+} from '../types';
+import { handleRegisterUser } from './handlers/registerUser';
+import { handleUpsertServer } from './handlers/upsertServer';
+import { handleDeleteServer } from './handlers/deleteServer';
+import { handleCreateJoinRequest } from './handlers/createJoinRequest';
+import { handleUpdateJoinRequestStatus } from './handlers/updateJoinRequestStatus';
+import { handleDeleteStaleJoinRequests } from './handlers/deleteStaleJoinRequests';
+
+export const buildCommandHandlers = (dataSource: DataSource): Record<CommandTypeKey, (command: Command) => Promise<unknown>> => ({
+  [CommandType.RegisterUser]:            (cmd) => handleRegisterUser(cmd as RegisterUserCommand, dataSource),
+  [CommandType.UpsertServer]:            (cmd) => handleUpsertServer(cmd as UpsertServerCommand, dataSource),
+  [CommandType.DeleteServer]:            (cmd) => handleDeleteServer(cmd as DeleteServerCommand, dataSource),
+  [CommandType.CreateJoinRequest]:       (cmd) => handleCreateJoinRequest(cmd as CreateJoinRequestCommand, dataSource),
+  [CommandType.UpdateJoinRequestStatus]: (cmd) => handleUpdateJoinRequestStatus(cmd as UpdateJoinRequestStatusCommand, dataSource),
+  [CommandType.DeleteStaleJoinRequests]: (cmd) => handleDeleteStaleJoinRequests(cmd as DeleteStaleJoinRequestsCommand, dataSource)
+});