refactor(marketing-pages): factory-style use cases + per-use-case controllers

- Use cases (get-page-by-slug, get-site-settings) → factory functions with I*UseCase aliases
- Controllers split: pages.controller.ts → 2 single-responsibility files
- DI module wires factories with .toDynamicValue()
- tRPC router resolves controllers via container

Refactor log: §2, §3, §4.1, §4.2, §5.1
Spec: §6.3

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

packages/marketing-pages/src/interface-adapters/controllers/get-page-by-slug.controller.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest";
+import { getPageBySlugController } from "@/interface-adapters/controllers/get-page-by-slug.controller";
+import { getPageBySlugUseCase } from "@/application/use-cases/get-page-by-slug.use-case";
+import { MockPagesRepository } from "@/infrastructure/repositories/pages.repository.mock";
+import { InputParseError } from "@/entities/errors/common";
+
+describe("getPageBySlugController", () => {
+  it("returns the page when found", async () => {
+    const repo = new MockPagesRepository();
+    const useCase = getPageBySlugUseCase(repo);
+    const controller = getPageBySlugController(useCase);
+
+    const result = await controller({ slug: "about" });
+    expect(result?.slug).toBe("about");
+  });
+
+  it("throws InputParseError on missing slug", async () => {
+    const repo = new MockPagesRepository();
+    const useCase = getPageBySlugUseCase(repo);
+    const controller = getPageBySlugController(useCase);
+
+    await expect(
+      controller({} as { slug: string }),
+    ).rejects.toBeInstanceOf(InputParseError);
+  });
+
+  it("returns undefined when slug not found", async () => {
+    const repo = new MockPagesRepository();
+    const useCase = getPageBySlugUseCase(repo);
+    const controller = getPageBySlugController(useCase);
+
+    const result = await controller({ slug: "nonexistent" });
+    expect(result).toBeUndefined();
+  });
+});

packages/marketing-pages/src/interface-adapters/controllers/get-page-by-slug.controller.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+
+import { InputParseError } from "../../entities/errors/common";
+import type { Page } from "../../entities/models/page";
+import type { IGetPageBySlugUseCase } from "../../application/use-cases/get-page-by-slug.use-case";
+
+const inputSchema = z.object({
+  slug: z.string().min(1),
+});
+
+export type IGetPageBySlugController = ReturnType<typeof getPageBySlugController>;
+
+export const getPageBySlugController =
+  (getPageBySlugUseCase: IGetPageBySlugUseCase) =>
+  async (input: Partial<z.infer<typeof inputSchema>>): Promise<Page | undefined> => {
+    const parsed = inputSchema.safeParse(input);
+    if (!parsed.success) {
+      throw new InputParseError("Invalid get-page-by-slug input", {
+        cause: parsed.error,
+      });
+    }
+    return getPageBySlugUseCase(parsed.data);
+  };

packages/marketing-pages/src/interface-adapters/controllers/get-site-settings.controller.test.ts

@@ -0,0 +1,15 @@
+import { describe, it, expect } from "vitest";
+import { getSiteSettingsController } from "@/interface-adapters/controllers/get-site-settings.controller";
+import { getSiteSettingsUseCase } from "@/application/use-cases/get-site-settings.use-case";
+import { MockSiteSettingsRepository } from "@/infrastructure/repositories/site-settings.repository.mock";
+
+describe("getSiteSettingsController", () => {
+  it("returns site settings", async () => {
+    const repo = new MockSiteSettingsRepository();
+    const useCase = getSiteSettingsUseCase(repo);
+    const controller = getSiteSettingsController(useCase);
+
+    const result = await controller();
+    expect(result.siteName).toBe("My App");
+  });
+});

packages/marketing-pages/src/interface-adapters/controllers/get-site-settings.controller.ts

@@ -0,0 +1,10 @@
+import type { SiteSettings } from "../../entities/models/site-settings";
+import type { IGetSiteSettingsUseCase } from "../../application/use-cases/get-site-settings.use-case";
+
+export type IGetSiteSettingsController = ReturnType<typeof getSiteSettingsController>;
+
+export const getSiteSettingsController =
+  (getSiteSettingsUseCase: IGetSiteSettingsUseCase) =>
+  async (): Promise<SiteSettings> => {
+    return getSiteSettingsUseCase();
+  };

packages/marketing-pages/src/interface-adapters/controllers/pages.controller.test.ts

@@ -1,49 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { marketingPagesContainer } from "@/di/container";
-import { MARKETING_PAGES_SYMBOLS } from "@/di/symbols";
-import { MockPagesRepository } from "@/infrastructure/repositories/pages.repository.mock";
-import { MockSiteSettingsRepository } from "@/infrastructure/repositories/site-settings.repository.mock";
-import type { IPagesRepository } from "@/application/repositories/pages.repository.interface";
-import type { ISiteSettingsRepository } from "@/application/repositories/site-settings.repository.interface";
-import { InputParseError } from "@/entities/errors/common";
-import {
-  getPageBySlugController,
-  getSiteSettingsController,
-} from "./pages.controller";
-
-describe("pages controller", () => {
-  beforeEach(() => {
-    if (marketingPagesContainer.isBound(MARKETING_PAGES_SYMBOLS.IPagesRepository)) {
-      marketingPagesContainer.unbind(MARKETING_PAGES_SYMBOLS.IPagesRepository);
-    }
-    if (marketingPagesContainer.isBound(MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository)) {
-      marketingPagesContainer.unbind(MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository);
-    }
-    marketingPagesContainer
-      .bind<IPagesRepository>(MARKETING_PAGES_SYMBOLS.IPagesRepository)
-      .toConstantValue(new MockPagesRepository());
-    marketingPagesContainer
-      .bind<ISiteSettingsRepository>(MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository)
-      .toConstantValue(new MockSiteSettingsRepository());
-  });
-
-  describe("getPageBySlugController", () => {
-    it("returns the page when found", async () => {
-      const result = await getPageBySlugController({ slug: "about" });
-      expect(result?.slug).toBe("about");
-    });
-
-    it("throws InputParseError on missing slug", async () => {
-      await expect(
-        getPageBySlugController({} as { slug: string }),
-      ).rejects.toBeInstanceOf(InputParseError);
-    });
-  });
-
-  describe("getSiteSettingsController", () => {
-    it("returns site settings", async () => {
-      const result = await getSiteSettingsController();
-      expect(result.siteName).toBe("My App");
-    });
-  });
-});

packages/marketing-pages/src/interface-adapters/controllers/pages.controller.ts

@@ -1,27 +0,0 @@
-import { z } from "zod";
-
-import { InputParseError } from "../../entities/errors/common";
-import type { Page } from "../../entities/models/page";
-import type { SiteSettings } from "../../entities/models/site-settings";
-import { getPageBySlugUseCase } from "../../application/use-cases/get-page-by-slug.use-case";
-import { getSiteSettingsUseCase } from "../../application/use-cases/get-site-settings.use-case";
-
-const getBySlugInputSchema = z.object({
-  slug: z.string().min(1),
-});
-
-export async function getPageBySlugController(input: {
-  slug: string;
-}): Promise<Page | undefined> {
-  const parsed = getBySlugInputSchema.safeParse(input);
-  if (!parsed.success) {
-    throw new InputParseError("Invalid get-page-by-slug input", {
-      cause: parsed.error,
-    });
-  }
-  return getPageBySlugUseCase(parsed.data.slug);
-}
-
-export async function getSiteSettingsController(): Promise<SiteSettings> {
-  return getSiteSettingsUseCase();
-}