chore: initialize from frontend template 4dc033c

2026-08-13 18:23:26 +09:00
commit 40107eec84
897 changed files with 234824 additions and 0 deletions
@@ -0,0 +1,186 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  buildRouteUrl,
+  parseRouteInput,
+} from "../../../src/presentation/routes/route-codecs.ts";
+import {
+  mapReferenceOperation,
+  toReferenceView,
+} from "../../../src/features/reference-feature/contracts/reference-mapper.ts";
+import {
+  validateReferencePayload,
+  validateReferenceRequest,
+} from "../../../src/features/reference-feature/contracts/reference-schemas.ts";
+import {
+  REFERENCE_FEATURE_CONTRACT,
+  REFERENCE_FEATURE_ID,
+  REFERENCE_RESOURCE_INVALIDATION_TOPIC,
+} from "../../../src/features/reference-feature/contracts/reference-feature-contract.ts";
+import type { ReferenceFeatureInput } from "../../../src/features/reference-feature/application/reference-feature-api.ts";
+import { createTestApplication } from "../../helpers/create-test-application.ts";
+import { createReferenceFeatureInstalledInput } from "../../../src/features/reference-feature/adapters/create-reference-feature-input.ts";
+
+describe("reference feature boundary contracts", () => {
+  it("propagates uncertain command effect certainty into the application failure", async () => {
+    const execute = vi.fn(async () => ({
+      kind: "CONTRACT_VIOLATION" as const,
+      violation: {
+        kind: "SUCCESS_SCHEMA_INVALID" as const,
+        operation: "VALIDATION" as const,
+      },
+      effect: "MAYBE_APPLIED" as const,
+    }));
+    const installed = createReferenceFeatureInstalledInput({
+      contractOperations: { execute },
+    });
+
+    await expect(
+      installed.input.createResource({ name: "uncertain" }),
+    ).resolves.toMatchObject({
+      ok: false,
+      error: {
+        effect: "MAYBE_APPLIED",
+        retryable: false,
+        action: "contact-support",
+      },
+    });
+  });
+
+  it("round-trips one canonical filter through the URL codec", () => {
+    const filters = {
+      tags: ["open", "new"],
+      cursor: "a/b",
+      limit: 5,
+    };
+    const url = buildRouteUrl("REFERENCE_RESOURCE_LIST", { search: filters });
+    expect(url).toBe(
+      "/examples/reference-resources?cursor=a%2Fb&limit=5&tags=open&tags=new",
+    );
+    const parsed = parseRouteInput(
+      "REFERENCE_RESOURCE_LIST",
+      {},
+      new URL(url, "https://app.test").searchParams,
+    );
+    expect(parsed).toMatchObject({
+      success: true,
+      data: { search: filters },
+    });
+  });
+
+  it("rejects unknown search and malformed DTO before mapping", () => {
+    expect(
+      parseRouteInput(
+        "REFERENCE_RESOURCE_LIST",
+        {},
+        new URLSearchParams("unknown=value"),
+      ),
+    ).toEqual({ success: false, code: "ROUTE_SEARCH_INVALID" });
+    expect(
+      validateReferencePayload("ReferenceResourceListPayload", [
+        { id: "unsafe", name: 42 },
+      ]),
+    ).toMatchObject({ success: false });
+    expect(
+      mapReferenceOperation("LIST_REFERENCE_RESOURCES", [
+        { id: "unsafe", name: 42 },
+      ]),
+    ).toMatchObject({ ok: false });
+  });
+
+  it("normalizes request input and maps only owned domain fields", () => {
+    expect(
+      validateReferenceRequest("CreateReferenceResourceCommand", {
+        name: "  Example  ",
+      }),
+    ).toMatchObject({ success: true, data: { name: "Example" } });
+    const model = mapReferenceOperation("CREATE_REFERENCE_RESOURCE", {
+      id: "reference-1",
+      name: "Example",
+      createdAt: "2026-07-26T00:00:00.000Z",
+    });
+    if (!model.ok || !("id" in model.value)) {
+      throw new Error("expected one model");
+    }
+    expect(toReferenceView(model.value)).toEqual({
+      resourceId: "reference-1",
+      title: "Example",
+      createdAt: "2026-07-26T00:00:00.000Z",
+    });
+  });
+
+  it("owns route and operation contributions in one removable contract", () => {
+    expect(Object.keys(REFERENCE_FEATURE_CONTRACT.routes)).toEqual([
+      "REFERENCE_RESOURCE_LIST",
+      "REFERENCE_RESOURCE_DETAIL",
+      "REFERENCE_RESOURCE_FORM",
+      "REFERENCE_RESOURCE_STATUS",
+    ]);
+    expect(Object.keys(REFERENCE_FEATURE_CONTRACT.apiOperations)).toEqual([
+      "LIST_REFERENCE_RESOURCES",
+      "CREATE_REFERENCE_RESOURCE",
+      "GET_REFERENCE_RESOURCE",
+    ]);
+    expect(
+      REFERENCE_FEATURE_CONTRACT.apiOperations.GET_REFERENCE_RESOURCE,
+    ).toMatchObject({
+      pathSchema: "ReferenceResourceParams",
+      pathParameterNames: ["resourceId"],
+      providerId: "PRIMARY_API",
+      authProfileId: "REFERENCE_EXTERNAL_BEARER",
+      csrfProfileId: "NO_CSRF_BEARER",
+    });
+  });
+
+  it("contributes an identity-based invalidation graph and an explicit wire version", () => {
+    expect(REFERENCE_FEATURE_CONTRACT.invalidation).toEqual({
+      topics: [REFERENCE_RESOURCE_INVALIDATION_TOPIC],
+      namespaces: [
+        { namespaceId: "reference-resource", namespaceVersion: 1 },
+      ],
+      edges: [
+        {
+          topicId: REFERENCE_RESOURCE_INVALIDATION_TOPIC,
+          namespace: {
+            namespaceId: "reference-resource",
+            namespaceVersion: 1,
+          },
+        },
+      ],
+    });
+    expect(REFERENCE_FEATURE_CONTRACT.topicVersions).toEqual([
+      {
+        topicId: REFERENCE_RESOURCE_INVALIDATION_TOPIC,
+        topicVersion: 1,
+      },
+    ]);
+  });
+
+  it("returns the installed input through the typed application registry", () => {
+    const featureInput = {
+      listResources: async () => ({ ok: true as const, value: [] }),
+      createResource: async ({ name }) => ({
+        ok: true as const,
+        value: {
+          resourceId: "created",
+          title: name,
+          createdAt: null,
+        },
+      }),
+      getResource: async (resourceId) => ({
+        ok: true as const,
+        value: {
+          resourceId,
+          title: "Reference",
+          createdAt: null,
+        },
+      }),
+    } satisfies ReferenceFeatureInput;
+    const application = createTestApplication({
+      featureInputs: { [REFERENCE_FEATURE_ID]: featureInput },
+    });
+
+    expect(application.features.has(REFERENCE_FEATURE_ID)).toBe(true);
+    expect(application.features.get(REFERENCE_FEATURE_ID)).toBe(featureInput);
+  });
+});