refactor: 프론트 템플릿 리펙토링

tests/features/reference-feature/reference-diagnostics.test.ts

@@ -1,61 +1,68 @@
 import { describe, expect, it, vi } from "vitest";
 
-import { createHttpClient } from "../../../src/adapters/http/client.ts";
-import { createDemoSessionAdapter } from "../../../src/adapters/auth/external-session-adapter.ts";
-import {
-  createReferenceHttpGateway,
-} from "../../../src/features/reference-feature/adapters/reference-http-gateway.ts";
-import { createReferenceFeatureInput } from "../../../src/features/reference-feature/application/reference-feature-api.ts";
-import { REFERENCE_FEATURE_CONTRACT } from "../../../src/features/reference-feature/contracts/reference-feature-contract.ts";
-import { mapReferenceOperation } from "../../../src/features/reference-feature/contracts/reference-mapper.ts";
-import {
-  validateReferencePayload,
-  validateReferenceRequest,
-} from "../../../src/features/reference-feature/contracts/reference-schemas.ts";
+import { createContractHttpExecutor } from "../../../src/adapters/http/index.ts";
+import { createHttpObservationProjector } from "../../../src/bootstrap/runtime-adapters.ts";
+import { createReferenceFeatureInstalledInput } from "../../../src/features/reference-feature/adapters/create-reference-feature-input.ts";
+import { REFERENCE_FEATURE_TEMPLATE_CONTRIBUTION } from "../../../src/features/reference-feature/contracts/reference-feature-contract-contribution.ts";
 
-describe("reference feature diagnostics correlation", () => {
-  it("preserves route, operation and request correlation through the vertical path", async () => {
+function scopeSnapshot() {
+  return Object.freeze({
+    generation: 1,
+    fingerprint: "reference-scope",
+    identities: Object.freeze({}) as never,
+    signal: new AbortController().signal,
+    isCurrent: () => true,
+  });
+}
+
+describe("reference feature HTTP diagnostics", () => {
+  it("preserves route and operation identity through the installed V3 path", async () => {
     const record = vi.fn();
-    const operations =
-      REFERENCE_FEATURE_CONTRACT.apiOperations as Readonly<
-        Record<
-          string,
-          ReturnType<
-            NonNullable<Parameters<typeof createHttpClient>[0]["getOperation"]>
-          >
-        >
-      >;
-    const client = createHttpClient({
+    const contractHttp = createContractHttpExecutor({
       baseUrl: "https://api.test",
-      authSession: createDemoSessionAdapter("authenticated"),
-      fetcher: async () =>
-        Response.json({
-          success: true,
-          data: [{ id: "reference-1", name: "Reference" }],
-          meta: { requestId: "safe-request", traceId: "safe-trace" },
-        }),
-      getOperation(operationId) {
-        const operation = operations[operationId];
-        if (!operation) throw new Error("Unregistered reference operation");
-        return operation;
-      },
-      validatePayload: validateReferencePayload,
-      validateRequest: validateReferenceRequest,
-      mapPayload: mapReferenceOperation,
-      correlationIdFactory: () => "reference-correlation",
-      diagnostics: { record },
-      scheduler: {
-        setTimeout: () => 1,
-        clearTimeout: () => {},
-      },
+      maxRetryAttempts: 0,
+      attachCredentials: () => ({
+        kind: "READY" as const,
+        headers: { authorization: "Bearer diagnostics-test-token" },
+      }),
+      fetcher: (async () =>
+        Response.json([
+          { id: "reference-1", name: "Reference" },
+        ])) as unknown as typeof fetch,
+      observe: createHttpObservationProjector({
+        diagnostics: { record },
+        telemetry: { emit: vi.fn() },
+      }),
     });
-    const application = createReferenceFeatureInput(
-      createReferenceHttpGateway(client),
+    const operations = new Map(
+      REFERENCE_FEATURE_TEMPLATE_CONTRIBUTION.http.map((operation) => [
+        operation.contract.operationId,
+        operation,
+      ]),
     );
+    const installed = createReferenceFeatureInstalledInput({
+      contractOperations: Object.freeze({
+        async execute(operationId, input, context) {
+          const operation = operations.get(operationId);
+          if (!operation) throw new Error("Unregistered reference operation");
+          return contractHttp.execute(operation, input, {
+            routeId: context.routeId,
+            scope: scopeSnapshot(),
+            ...(context.signal === undefined
+              ? {}
+              : { signal: context.signal }),
+            ...(context.intent === undefined
+              ? {}
+              : { intent: context.intent }),
+          });
+        },
+      }),
+    });
 
     await expect(
-      application.listResources({ limit: 20 }),
+      installed.input.listResources({ limit: 20 }),
     ).resolves.toMatchObject({ ok: true });
+
     expect(record).toHaveBeenCalledOnce();
     expect(record).toHaveBeenCalledWith({
       level: "info",
@@ -63,8 +70,7 @@ describe("reference feature diagnostics correlation", () => {
       context: expect.objectContaining({
         route_id: "REFERENCE_RESOURCE_LIST",
         operation_id: "LIST_REFERENCE_RESOURCES",
-        correlation_id: "reference-correlation",
-        outcome: "success",
+        outcome: "SUCCESS",
       }),
     });
   });