refactor(blog): unify use-case I/O schemas + presenter + feature error map

Per Plan 9 (spec R1-R28):
- Use cases: input + output schemas (getArticles, createArticle,
  getArticleBySlug). Output validated via outputSchema.parse before
  return. status field uses articleStatusSchema (was loose `string`).
- Controllers: receive `unknown`; safeParse with use-case schema;
  identity presenter (R11) on every controller.
- New integrations/api/procedures.ts with blogProcedure
  ([InputParseError → BAD_REQUEST], [ArticleNotFoundError → NOT_FOUND]).
- Router uses blogProcedure + .input(xInputSchema) for all 3 procedures.
- src/index.ts: remove articleBySlugQuery/listArticlesQuery re-exports;
  export schemas + types + IUseCase/IController aliases.
- src/ui/index.ts (NEW): query builders moved here; package.json adds
  ./ui subpath.
- New tests: R25 output-validation per use case; R26 router error-
  mapping (NOT_FOUND on missing slug, BAD_REQUEST on schema fail).

Refactor log: §1, §2, §3.1, §3.2, §3.3, §5.1, §5.2, §6.1, §6.2
Spec: R1–R6, R8–R15, R18–R20, R22–R26

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

packages/blog/src/integrations/api/procedures.ts

@@ -0,0 +1,12 @@
+import { t } from "@repo/core-shared/trpc/init";
+import { defineErrorMiddleware } from "@repo/core-shared/trpc/define-error-middleware";
+
+import { ArticleNotFoundError } from "../../entities/errors/article";
+import { InputParseError } from "../../entities/errors/common";
+
+export const blogProcedure = t.procedure.use(
+  defineErrorMiddleware([
+    [InputParseError, "BAD_REQUEST"],
+    [ArticleNotFoundError, "NOT_FOUND"],
+  ]),
+);

packages/blog/src/integrations/api/router.test.ts

@@ -1,7 +1,8 @@
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { blogContainer } from "../../di/container";
-import { BlogModule } from "../../di/module";
-import { blogRouter } from "./router";
+import { TRPCError } from "@trpc/server";
+import { blogContainer } from "@/di/container";
+import { BlogModule } from "@/di/module";
+import { blogRouter } from "@/integrations/api/router";
 
 // The router resolves controllers from blogContainer (a singleton).
 // We reload the module between tests to get a fresh MockArticlesRepository.
@@ -24,7 +25,7 @@ describe("blogRouter", () => {
 
   it("listArticles returns empty array by default", async () => {
     const caller = blogRouter.createCaller({});
-    const result = await caller.listArticles();
+    const result = await caller.listArticles({});
     expect(result).toEqual([]);
   });
 
@@ -43,3 +44,36 @@ describe("blogRouter", () => {
     expect(fetched.id).toBe(created.id);
   });
 });
+
+describe("blogRouter (R26 error mapping)", () => {
+  beforeEach(() => {
+    blogContainer.unbindAll();
+    blogContainer.load(BlogModule);
+  });
+
+  afterEach(() => {
+    blogContainer.unbindAll();
+  });
+
+  it("translates ArticleNotFoundError → NOT_FOUND", async () => {
+    const caller = blogRouter.createCaller({});
+    try {
+      await caller.articleBySlug({ slug: "missing" });
+      throw new Error("expected throw");
+    } catch (e) {
+      expect(e).toBeInstanceOf(TRPCError);
+      expect((e as TRPCError).code).toBe("NOT_FOUND");
+    }
+  });
+
+  it("translates zod parse failure → BAD_REQUEST", async () => {
+    const caller = blogRouter.createCaller({});
+    try {
+      await caller.articleBySlug({} as unknown as { slug: string });
+      throw new Error("expected throw");
+    } catch (e) {
+      expect(e).toBeInstanceOf(TRPCError);
+      expect((e as TRPCError).code).toBe("BAD_REQUEST");
+    }
+  });
+});

packages/blog/src/integrations/api/router.ts

@@ -1,14 +1,21 @@
-import { z } from "zod";
-import { router, publicProcedure } from "@repo/core-shared/trpc/init";
+import { router } from "@repo/core-shared/trpc/init";
+
 import { blogContainer } from "../../di/container";
 import { BLOG_SYMBOLS } from "../../di/symbols";
+
+import { getArticlesInputSchema } from "../../application/use-cases/get-articles.use-case";
+import { createArticleInputSchema } from "../../application/use-cases/create-article.use-case";
+import { getArticleBySlugInputSchema } from "../../application/use-cases/get-article-by-slug.use-case";
+
 import type { IGetArticlesController } from "../../interface-adapters/controllers/get-articles.controller";
 import type { ICreateArticleController } from "../../interface-adapters/controllers/create-article.controller";
 import type { IGetArticleBySlugController } from "../../interface-adapters/controllers/get-article-by-slug.controller";
 
+import { blogProcedure } from "./procedures";
+
 export const blogRouter = router({
-  articleBySlug: publicProcedure
-    .input(z.object({ slug: z.string().min(1) }))
+  articleBySlug: blogProcedure
+    .input(getArticleBySlugInputSchema)
     .query(({ input }) => {
       const ctrl = blogContainer.get<IGetArticleBySlugController>(
         BLOG_SYMBOLS.IGetArticleBySlugController,
@@ -16,33 +23,17 @@ export const blogRouter = router({
       return ctrl(input);
     }),
 
-  listArticles: publicProcedure
-    .input(
-      z
-        .object({
-          status: z.string().optional(),
-          authorId: z.string().optional(),
-          limit: z.number().optional(),
-          offset: z.number().optional(),
-        })
-        .optional(),
-    )
+  listArticles: blogProcedure
+    .input(getArticlesInputSchema)
     .query(({ input }) => {
       const ctrl = blogContainer.get<IGetArticlesController>(
         BLOG_SYMBOLS.IGetArticlesController,
       );
-      return ctrl(input ?? {});
+      return ctrl(input);
     }),
 
-  createArticle: publicProcedure
-    .input(
-      z.object({
-        title: z.string().min(1).max(255),
-        content: z.unknown().optional(),
-        authorId: z.string(),
-        slug: z.string().optional(),
-      }),
-    )
+  createArticle: blogProcedure
+    .input(createArticleInputSchema)
     .mutation(({ input }) => {
       const ctrl = blogContainer.get<ICreateArticleController>(
         BLOG_SYMBOLS.ICreateArticleController,