refactor(auth): factory-style use cases + controllers + real Payload impls

- Use cases (sign-in, sign-up, sign-out) → factory functions with I*UseCase aliases
- Controllers → factory functions with I*Controller aliases
- DI symbols + module updated with .toDynamicValue() bindings for factories
- New: real UsersRepository (Payload-backed, SanitizedConfig, contract-tested)
- New: real AuthenticationService (node:crypto hashing/UUIDs; createSession/
  validateSession/invalidateSession deferred — see refactor log §7)
- bindProductionAuth swaps both mocks for real impls (was a no-op before)
- Tests refactored to construct mocks and inject directly (no container rebinding)
- Feature test constructs full chain via direct factory injection

Refactor log: §2, §4.1, §4.2, §5.1, §5.2, §6.1, §7
Spec: §6.1, §7

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

packages/auth/src/interface-adapters/controllers/sign-up.controller.test.ts

@@ -1,36 +1,19 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { authContainer } from "@/di/container";
-import { AUTH_SYMBOLS } from "@/di/symbols";
+import { describe, it, expect } from "vitest";
+import { signUpController } from "@/interface-adapters/controllers/sign-up.controller";
 import { MockUsersRepository } from "@/infrastructure/repositories/users.repository.mock";
 import { MockAuthenticationService } from "@/infrastructure/services/authentication.service.mock";
-import type { IUsersRepository } from "@/application/repositories/users.repository.interface";
-import type { IAuthenticationService } from "@/application/services/authentication.service.interface";
+import { signUpUseCase } from "@/application/use-cases/sign-up.use-case";
 import { InputParseError } from "@/entities/errors/common";
-import { signUpController } from "./sign-up.controller";
+import { userFactory } from "@/__factories__/user.factory";
 
 describe("signUpController", () => {
-  let usersRepo: MockUsersRepository;
-  let authService: MockAuthenticationService;
-
-  beforeEach(() => {
-    if (authContainer.isBound(AUTH_SYMBOLS.IUsersRepository)) {
-      authContainer.unbind(AUTH_SYMBOLS.IUsersRepository);
-    }
-    if (authContainer.isBound(AUTH_SYMBOLS.IAuthenticationService)) {
-      authContainer.unbind(AUTH_SYMBOLS.IAuthenticationService);
-    }
-    usersRepo = new MockUsersRepository();
-    authService = new MockAuthenticationService(usersRepo);
-    authContainer
-      .bind<IUsersRepository>(AUTH_SYMBOLS.IUsersRepository)
-      .toConstantValue(usersRepo);
-    authContainer
-      .bind<IAuthenticationService>(AUTH_SYMBOLS.IAuthenticationService)
-      .toConstantValue(authService);
-  });
-
   it("creates a new user when passwords match", async () => {
-    const result = await signUpController({
+    const users = new MockUsersRepository([]);
+    const auth = new MockAuthenticationService(users);
+    const useCase = signUpUseCase(users, auth);
+    const controller = signUpController(useCase);
+
+    const result = await controller({
       username: "carol",
       password: "secret_password",
       confirmPassword: "secret_password",
@@ -39,12 +22,30 @@ describe("signUpController", () => {
   });
 
   it("throws InputParseError when passwords do not match", async () => {
+    const users = new MockUsersRepository([]);
+    const auth = new MockAuthenticationService(users);
+    const useCase = signUpUseCase(users, auth);
+    const controller = signUpController(useCase);
+
     await expect(
-      signUpController({
+      controller({
         username: "dave",
         password: "secret_password",
         confirmPassword: "different_password",
       }),
     ).rejects.toBeInstanceOf(InputParseError);
   });
+
+  it("throws InputParseError when username is too short", async () => {
+    const users = new MockUsersRepository([]);
+    const auth = new MockAuthenticationService(users);
+    // Pre-seed so we don't hit the taken-username error
+    await users.createUser(userFactory.build({ username: "alice" }));
+    const useCase = signUpUseCase(users, auth);
+    const controller = signUpController(useCase);
+
+    await expect(
+      controller({ username: "ab", password: "secret_password", confirmPassword: "secret_password" }),
+    ).rejects.toBeInstanceOf(InputParseError);
+  });
 });