diff --git a/src/bootstrap/runtime-adapters.ts b/src/bootstrap/runtime-adapters.ts index 2e507e05..7603e0c6 100644 --- a/src/bootstrap/runtime-adapters.ts +++ b/src/bootstrap/runtime-adapters.ts @@ -502,6 +502,16 @@ export async function createRuntimeAdapters( if (serverStateScope.getPhase() !== "READY") { return Object.freeze({ kind: "SCOPE_FENCED" as const }); } + // 09-01. The operation's installed profile decides first, the session + // second. An ANONYMOUS profile admits no credential header at all, so it + // goes out bare in every session state and never reaches the owner. Every + // other profile still needs a session and never downgrades to anonymous. + if ( + INSTALLED_REST_AUTH_PROFILES.get(operation.authProfileId)?.transport === + "ANONYMOUS" + ) { + return Object.freeze({ kind: "READY" as const, headers: {} }); + } const state = authSession.getState(); if (state === "integration-failed") { return Object.freeze({ kind: "UNAVAILABLE" as const }); diff --git a/tests/unit/runtime-adapters-auth-profile.test.ts b/tests/unit/runtime-adapters-auth-profile.test.ts new file mode 100644 index 00000000..616f7702 --- /dev/null +++ b/tests/unit/runtime-adapters-auth-profile.test.ts @@ -0,0 +1,349 @@ +import { afterEach, describe, expect, it, vi } from "vitest"; + +import { DEMO_AUTHORIZATION_MARKER } from "../../src/adapters/auth/index.ts"; +import type { InstalledHttpOperationExecutor } from "../../src/adapters/http/index.ts"; +import { createRuntimeAdapters } from "../../src/bootstrap/runtime-adapters.ts"; +import { CREDENTIAL_HEADER_NAMES } from "../../src/contracts/rest-profiles.ts"; +import { TEST_LIST_HTTP_CONTRACT } from "../helpers/external-contract-fixture.ts"; + +/** + * 09-01. The composition root decides credentials for every V3 operation. An + * `ANONYMOUS` operation must go out exactly once with no credential header in + * every session state, and a profile that needs a credential must keep failing + * closed. This runs the real `createRuntimeAdapters`; only the installed + * contract set (adds the fixture) and the feature-input composer (to reach the + * `http` capability a feature would receive) are replaced. + */ + +const fixture = vi.hoisted(() => ({ + http: undefined as InstalledHttpOperationExecutor | undefined, + /** The fixture list operation under another id and auth profile. */ + withProfile( + contract: T, + operationId: string, + authProfileId: string, + ): T { + return { + ...contract, + contract: { ...contract.contract, operationId }, + frontend: { ...contract.frontend, authProfileId }, + }; + }, +})); + +vi.mock("../../src/features/installed-contract-contributions.ts", async (importOriginal) => { + const original = + await importOriginal(); + const { composeContractContributions } = await import( + "../../src/contracts/external-contract-runtime.ts" + ); + const { TEST_CONTRACT_CONTRIBUTION, TEST_LIST_HTTP_CONTRACT: list } = + await import("../helpers/external-contract-fixture.ts"); + return { + ...original, + COMPOSED_CONTRACT_CONTRIBUTIONS: composeContractContributions([ + { + ...TEST_CONTRACT_CONTRIBUTION, + http: [ + list, + fixture.withProfile(list, "TEST_LIST_ENTITIES_BEARER", "REFERENCE_EXTERNAL_BEARER"), + ] as typeof TEST_CONTRACT_CONTRIBUTION.http, + }, + ]), + }; +}); + +vi.mock("../../src/features/installed-feature-adapters.ts", async (importOriginal) => { + const original = + await importOriginal(); + return { + ...original, + createInstalledFeatureInputs: ( + ...args: Parameters + ) => { + fixture.http = args[0].http; + return original.createInstalledFeatureInputs(...args); + }, + }; +}); + +type Runtime = Parameters[0]["runtime"]; +type Release = Parameters[0]["release"]; +type Adapters = Awaited>; + +function runtimeFor(authMode: "demo" | "external"): Runtime { + return { + config: { + APP_ENV: "local", + API_BASE_URL: "http://localhost:8080", + TELEMETRY_ENABLED: false, + AUTH_MODE: authMode, + REQUEST_TIMEOUT_MS: 10_000, + MAX_RETRY_ATTEMPTS: 0, + RELEASE_MANIFEST_URL: "/release-manifest.json", + CONFIG_SCHEMA_VERSION: "2.0", + CAPABILITY_OVERRIDES: { + REALTIME: "DEFAULT", + WEB_WORKER: "DEFAULT", + SERVICE_WORKER: "DEFAULT", + OFFLINE_COMMANDS: "DEFAULT", + }, + FEATURE_OVERRIDES: {}, + }, + configSchema: "V2", + build: { + buildId: "build-a", + commitSha: "abc123", + routerBasePath: "/", + runtimeConfigUrl: "/config.json", + }, + validationDurationMs: 0, + }; +} + +const release: Release = { + schemaVersion: 2, + appVersion: "0.1.0", + buildId: "build-a", + commitSha: "abc123", + configSchemaVersion: "2.0", + contractSet: { + setAlgorithm: "CA_CONTRACT_SET_V1", + setDigest: `sha256:${"0".repeat(64)}`, + packages: [], + }, + assetManifestHash: "hash-a", + releaseId: "release-a", + builtAt: "2026-07-25T00:00:00Z", + routeChunks: { "route-home": "assets/home.js" }, +}; + +const ANONYMOUS_OPERATION = TEST_LIST_HTTP_CONTRACT; +const BEARER_OPERATION = fixture.withProfile( + TEST_LIST_HTTP_CONTRACT, + "TEST_LIST_ENTITIES_BEARER", + "REFERENCE_EXTERNAL_BEARER", +); + +function externalOwner( + attachCredential: () => Promise = async () => ({ + headers: { authorization: "Bearer owner-token" }, + }), +) { + const listeners = new Set<() => void>(); + let subject = "user-a"; + return { + readState: () => "authenticated", + readSubject: () => subject, + subscribe(listener: () => void) { + listeners.add(listener); + return () => listeners.delete(listener); + }, + beginSignIn: async () => {}, + signOut: async () => {}, + attachCredential: vi.fn(attachCredential), + recoverSession: async () => "no-session", + notifyUnauthenticated: () => {}, + /** Another user signs in on this owner: the scope fences. */ + switchUser() { + subject = "user-b"; + for (const listener of listeners) listener(); + }, + }; +} + +let current: Adapters | undefined; +afterEach(() => { + current?.infrastructure.dispose(); + current = undefined; + fixture.http = undefined; +}); + +async function compose( + authMode: "demo" | "external", + host: Record = {}, +) { + const fetcher = vi.fn(async (_input: RequestInfo | URL, _init?: RequestInit) => + Response.json([{ id: "entity-1", name: "Entity" }]), + ); + current = await createRuntimeAdapters({ + runtime: runtimeFor(authMode), + release, + host, + fetcher: fetcher as unknown as typeof fetch, + }); + const http = fixture.http; + if (!http) throw new Error("The http capability was not composed"); + return { adapters: current, http, fetcher }; +} + +async function signInDemo(adapters: Adapters) { + await adapters.outputPorts.session.beginSignIn(); + await vi.waitFor(() => { + expect(adapters.infrastructure.serverStateScope.getPhase()).toBe("READY"); + }); +} + +function sentCredentialHeaders(init: RequestInit | undefined): string[] { + return [...new Headers(init?.headers).keys()].filter((name) => + (CREDENTIAL_HEADER_NAMES as readonly string[]).includes(name), + ); +} + +describe("09-01 ANONYMOUS operations through the composition root", () => { + it.each([ + { + state: "demo signed out", + setup: () => compose("demo"), + }, + { + state: "demo signed in", + setup: async () => { + const composed = await compose("demo"); + await signInDemo(composed.adapters); + return composed; + }, + }, + { + state: "external owner signed in", + setup: () => + compose("external", { __CA_FRONTEND_AUTH_OWNER__: externalOwner() }), + }, + { + state: "external mode without an owner", + setup: () => compose("external"), + }, + ])("sends once with no credential header ($state)", async ({ setup }) => { + const { http, fetcher } = await setup(); + + const outcome = await http.execute( + ANONYMOUS_OPERATION, + { limit: 1 }, + { routeId: "TEST_ROUTE" }, + ); + + expect(outcome.kind).toBe("SUCCESS"); + expect(fetcher).toHaveBeenCalledOnce(); + const [url, init] = fetcher.mock.calls[0] ?? []; + expect(String(url)).toBe("http://localhost:8080/api/test-entities?limit=1"); + expect(init?.credentials).toBe("omit"); + expect(sentCredentialHeaders(init)).toEqual([]); + }); + + it("does not hand an ANONYMOUS operation to the external owner", async () => { + const owner = externalOwner(); + const { http } = await compose("external", { + __CA_FRONTEND_AUTH_OWNER__: owner, + }); + + await http.execute(ANONYMOUS_OPERATION, { limit: 1 }, { routeId: "TEST_ROUTE" }); + + expect(owner.attachCredential).not.toHaveBeenCalled(); + }); + + it("still holds an ANONYMOUS operation while the scope is fenced", async () => { + const { http, fetcher, adapters } = await compose("demo"); + // The session change fences the scope synchronously; READY comes later. + void adapters.outputPorts.session.beginSignIn(); + + const outcome = await http.execute( + ANONYMOUS_OPERATION, + { limit: 1 }, + { routeId: "TEST_ROUTE" }, + ); + + expect(outcome).toMatchObject({ + kind: "CONTRACT_VIOLATION", + violation: { kind: "SCOPE_FENCED" }, + }); + expect(fetcher).not.toHaveBeenCalled(); + }); +}); + +describe("09-01 credentialed operations keep failing closed", () => { + it("refuses without a session instead of downgrading to anonymous", async () => { + const { http, fetcher } = await compose("demo"); + + const outcome = await http.execute( + BEARER_OPERATION, + { limit: 1 }, + { routeId: "TEST_ROUTE" }, + ); + + expect(outcome).toEqual({ + kind: "UNAUTHENTICATED", + effect: "NOT_APPLICABLE", + }); + expect(fetcher).not.toHaveBeenCalled(); + }); + + it.each([ + { + state: "external mode without an owner", + host: () => ({}), + }, + { + state: "an owner that fails to attach", + host: () => ({ + __CA_FRONTEND_AUTH_OWNER__: externalOwner(async () => { + throw new Error("owner down"); + }), + }), + }, + ])("reports the credential owner unavailable ($state)", async ({ host }) => { + const { http, fetcher } = await compose("external", host()); + + const outcome = await http.execute( + BEARER_OPERATION, + { limit: 1 }, + { routeId: "TEST_ROUTE" }, + ); + + expect(outcome).toMatchObject({ + kind: "AUTH_INTEGRATION_FAILURE", + reason: "CREDENTIAL_OWNER_UNAVAILABLE", + }); + expect(fetcher).not.toHaveBeenCalled(); + }); + + it("abandons the request when the session changes while the owner attaches", async () => { + const owner = externalOwner(async () => { + owner.switchUser(); + return { headers: { authorization: "Bearer owner-token" } }; + }); + const { http, fetcher } = await compose("external", { + __CA_FRONTEND_AUTH_OWNER__: owner, + }); + + const outcome = await http.execute( + BEARER_OPERATION, + { limit: 1 }, + { routeId: "TEST_ROUTE" }, + ); + + // A fence during the credential wait aborts the transport (Q-6.3-6). + expect(outcome).toMatchObject({ + kind: "TRANSPORT_FAILURE", + failure: { kind: "ABORTED_BY_SCOPE" }, + }); + expect(fetcher).not.toHaveBeenCalled(); + }); + + it("sends the session credential once signed in", async () => { + const { http, fetcher, adapters } = await compose("demo"); + await signInDemo(adapters); + + const outcome = await http.execute( + BEARER_OPERATION, + { limit: 1 }, + { routeId: "TEST_ROUTE" }, + ); + + expect(outcome.kind).toBe("SUCCESS"); + expect(fetcher).toHaveBeenCalledOnce(); + const init = fetcher.mock.calls[0]?.[1]; + expect(new Headers(init?.headers).get("authorization")).toBe( + DEMO_AUTHORIZATION_MARKER, + ); + }); +});