Files
clean-architecture-frontend…/tests/unit/realtime/fixture.ts
T
DongHyeonka 12f3bb7862 refactor(contracts)!: V2 API 행을 지우고 FE-REG-API를 HTTP descriptor에서 뽑는다
문제
기능 하나가 같은 HTTP API를 두 번 적는다. *-api-contract.ts의 V2 행
(defineRestOperation)은 check:registries(FE-REG-API)가 검사하는 선언이고,
contract contribution의 V3 descriptor가 실제로 실행된다. 둘이 어긋나지 않게
http-operation-v2-v3-parity 테스트를 따로 둔다. 048f490으로 V2 클라이언트가
없어져 V2 행을 읽는 실행 코드는 없고, 검사만 남은 두 번째 사본이다. V2 행을
위한 기능별 runtimeSchemas·mappers 레지스트리와 V2 보안 프로필 해석
(resolveRestSecurityProfiles)도 같이 남아 있다. 사용자 지시: 최신 경로 하나만
남기고, 레지스트리 기준선 재승인을 승인했다.

고른 방법
- src/contracts/api-operations.ts를 projectApiOperationRows 하나로 바꿨다.
  조립된 contribution의 descriptor마다 operationId, featureId, method, path,
  authProfileId, retrySemantics, requestBody, responseBody, responseEnvelope,
  request/response/problemSchema(검증기 schemaId) 행을 만든다. FE-REG-API는
  같은 export(API_OPERATIONS)를 읽고, governance 정의를 이 필드로 바꿨다.
  requestSchema·responseSchema는 그대로 FE-REG-SCHEMA를 참조한다.
- FeatureRuntime은 apiContract 대신 schemas(FE-REG-SCHEMA 행)만 받는다.
  installed-feature-runtime-registries는 schemas로 스키마 레지스트리를 만들고
  FE-REG-API 행을 descriptor에서 뽑는다. RUNTIME_SCHEMA_CODECS, MAPPER_REGISTRY,
  REST_PROFILE_BINDINGS_VALID, API_RUNTIME_BINDINGS_VALID를 지웠다.
- realtime snapshot 바인딩은 ApiOperationRow를 받고 method GET과
  retrySemantics SAFE·IDEMPOTENT를 본다(V2의 contractVersion·semantics·
  replayPolicy 대신).
- rest-profiles.ts에서 V2 행용 provider·CSRF 프로필 해석을 지웠다. V3는 조립
  때 auth profile을 검사하고 자격증명 헤더를 프로필로 거른다.
- 참조 기능: reference-api-contract.ts를 reference-schema-metadata.ts로
  바꾸고(스키마 행만), V2 runtime codec·operation mapper·레지스트리 mapper를
  지웠다. V3 descriptor가 쓰지 않는 NoRequest 스키마 행도 지웠다.
- create:feature: <base>-api-contract.ts 대신 <base>-schema-metadata.ts를
  만든다. codec·mapper 레지스트리 행과 그 테스트를 만들지 않는다.
- 레지스트리 기준선을 update:registry-baseline으로 다시 만들고 승인했다
  (digest 16f72742…, 승인자 DongHyeonka, 이유에 사용자 승인을 적음).
- 매뉴얼 01·02·reference, starter-experience, 계약 문서의 V2 설명을 지웠다.

버린 대안
- V2 행을 남기고 V3에서 생성하기: 생성 단계와 생성물이 하나 더 생긴다. 행은
  실행되지 않으므로 메모리에서 뽑아 검사하면 충분하다.
- 스키마 메타데이터(FE-REG-SCHEMA 행)도 검증기에서 뽑기: boundary·
  unknownFieldPolicy·owner는 검증기에 없고, 라우트 스키마도 같은 레지스트리를
  쓴다. 이 행은 V2가 아니라 스키마 레지스트리라 남겼다.

위험·한계
- BREAKING: FeatureRuntime 모양, contracts·rest-profiles·loaded-feature-runtimes
  의 이름이 바뀌거나 없어졌다. memento-frontend의 memento-web이 V2 행을 쓴다.
  옮기는 법은 CHANGELOG에 적는다.
- V2 보안 프로필 일관성 검사(auth "none"과 ANONYMOUS, 쿠키 프로필의 CSRF
  모드)가 사라졌다. V3 descriptor에는 그 칸이 없다.
- BoundedPollOperationContract(realtime polling recipe)는 contractVersion: 2
  필드를 갖지만 자체 계약이라 바꾸지 않았다.

검증
- check:types, lint, check:architecture, check:registries(11 registries PASS,
  compatibility=none), check:ci, check:diagnostics, check:adapter-inventory,
  verify:documentation 통과.
- test:unit 2,566(새 tests/unit/api-operation-rows.test.ts 3건 포함),
  test:integration 114, test:component 245, test:contract 23,
  test:runtime-schema 56, tests/features 99 통과.
- tests/unit/second-api-feature-registries.test.ts: V3 descriptor만 가진 두
  번째 기능을 복사본에 넣으면 기준선을 고치지 않고 check:registries가 통과한다.
- check:bundle 통과. 초기 JS 201,598 → 200,911 B.
- test:feature-scaffold 16개, test:sample-removal 23개 검사 통과.

BREAKING CHANGE: FeatureRuntime이 apiContract 대신 schemas를 받는다.
defineRestOperation, ApiOperation, RestOperationV2, composeApiOperations,
validateApiRuntimeBindings, getApiOperation, contracts의 API_OPERATIONS,
createRestProviderProfile, RestProviderProfile, resolveRestSecurityProfiles,
validateRestProfileBindings, REST_CSRF_PROFILES, RestCsrfProfile,
loaded-feature-runtimes의 RUNTIME_SCHEMA_CODECS, MAPPER_REGISTRY,
REST_PROFILE_BINDINGS_VALID, API_RUNTIME_BINDINGS_VALID가 없어졌다. 기능은
operation을 contract contribution에만 적고, schemas 행을 feature-runtime에
넘긴다.
2026-11-03 21:37:48 +09:00

239 lines
6.7 KiB
TypeScript

import {
mappingSuccess,
type InstalledBoundaryMapper,
} from "../../../src/contracts/boundary-mapper.ts";
import type { ApiOperationRow } from "../../../src/contracts/api-operations.ts";
import {
createRealtimePolicyRegistry,
defineEventTypeId,
defineExternalEventEffectProfileId,
defineRealtimeEndpointId,
defineRealtimeKillSwitchId,
defineStreamRegistrationId,
type RealtimeEventTypeRegistration,
type RealtimeLimits,
type RealtimePolicyRegistry,
type RealtimeRecoveryProfile,
type RealtimeStreamRegistration,
} from "../../../src/contracts/realtime-streams.ts";
import type { RuntimeSchemaCodec } from "../../../src/contracts/schema-registry.ts";
import {
createRealtimeEventCodec,
type RealtimeEventCodec,
} from "../../../src/adapters/realtime/event-codec.ts";
export const STREAM_ID = defineStreamRegistrationId("REFERENCE_STREAM");
export const EVENT_TYPE = defineEventTypeId("REFERENCE_CHANGED");
export const ENDPOINT_ID = defineRealtimeEndpointId("REFERENCE_ENDPOINT");
export const EFFECT_PROFILE_ID =
defineExternalEventEffectProfileId("REFERENCE_INVALIDATE");
export const KILL_SWITCH_ID =
defineRealtimeKillSwitchId("REFERENCE_KILL_SWITCH");
export const TEST_LIMITS: RealtimeLimits = Object.freeze({
maxEventBytes: 4_096,
maxPayloadDepth: 8,
maxPayloadNodes: 128,
maxQueueEvents: 8,
maxQueueBytes: 32_768,
maxDedupeEntries: 16,
maxDedupeBytes: 32_768,
dedupeTtlMs: 60_000,
});
const eventPayloadCodec: RuntimeSchemaCodec = Object.freeze({
schemaId: "ReferenceRealtimePayload",
parse(value) {
if (
!value ||
typeof value !== "object" ||
Array.isArray(value) ||
Object.keys(value).length !== 1 ||
typeof (value as Readonly<Record<string, unknown>>).value !== "string"
) {
return {
success: false,
issues: [{ path: "value", code: "INVALID_TYPE" }],
};
}
return {
success: true,
data: {
value: (value as Readonly<Record<string, string>>).value,
},
};
},
});
const checkpointCodec: RuntimeSchemaCodec = Object.freeze({
schemaId: "ReferenceRealtimeCheckpoint",
parse: (value) => ({ success: true, data: value }),
});
export const TEST_SCHEMA_CODECS = Object.freeze({
ReferenceRealtimePayload: eventPayloadCodec,
ReferenceRealtimeCheckpoint: checkpointCodec,
});
export const TEST_MAPPER: InstalledBoundaryMapper = Object.freeze({
mapperId: "ReferenceRealtimeMapper",
mapperVersion: 1,
inputSchemaId: "ReferenceRealtimePayload",
outputContractId: "ReferenceRealtimeEvent",
owner: "sample-owner",
maxOutputItems: 1,
map(input) {
if (
!input ||
typeof input !== "object" ||
typeof (input as Readonly<Record<string, unknown>>).value !== "string"
) {
return { ok: false, code: "MAPPING_INVARIANT_REJECTED" };
}
return mappingSuccess(
Object.freeze({
value: (input as Readonly<Record<string, string>>).value,
}),
);
},
});
export const TEST_MAPPERS = Object.freeze({
ReferenceRealtimeMapper: TEST_MAPPER,
});
const snapshotOperation: ApiOperationRow = Object.freeze({
operationId: "GET_REFERENCE_REALTIME_SNAPSHOT",
featureId: "sample-feature",
method: "GET",
path: "/api/reference-snapshot",
authProfileId: "EXTERNAL_BEARER",
retrySemantics: "SAFE",
requestBody: "NONE",
responseBody: "REQUIRED_JSON",
responseEnvelope: "NONE",
requestSchema: "NoRequest",
responseSchema: "ReferenceRealtimeCheckpoint",
problemSchema: "ReferenceRealtimeProblem",
});
export const TEST_API_OPERATIONS = Object.freeze({
GET_REFERENCE_REALTIME_SNAPSHOT: snapshotOperation,
});
export type TestRegistryOptions = Readonly<{
recovery?: RealtimeRecoveryProfile;
delivery?: RealtimeStreamRegistration["delivery"];
stateBearing?: boolean;
limits?: RealtimeLimits;
streamMutator?: (
stream: RealtimeStreamRegistration,
) => RealtimeStreamRegistration;
eventTypeMutator?: (
eventType: RealtimeEventTypeRegistration,
) => RealtimeEventTypeRegistration;
}>;
export function createTestRealtimeRegistry(
options: TestRegistryOptions = {},
): RealtimePolicyRegistry {
const recovery =
options.recovery ??
({
mode: "CURSOR",
snapshotOperationId: "GET_REFERENCE_REALTIME_SNAPSHOT",
checkpointCodecId: "ReferenceRealtimeCheckpoint",
barrier: "REPLAY",
} as const);
const eventType: RealtimeEventTypeRegistration = {
id: EVENT_TYPE,
owner: "sample-owner",
payloadSchemaId: "ReferenceRealtimePayload",
mapperId: "ReferenceRealtimeMapper",
effectProfileId: EFFECT_PROFILE_ID,
stateBearing: options.stateBearing ?? true,
};
const stream: RealtimeStreamRegistration = {
id: STREAM_ID,
protocol: "REALTIME_EVENT_V1",
owner: "sample-owner",
scope: "ACCOUNT_BOUND",
primaryTransport: "SSE",
endpointId: ENDPOINT_ID,
eventTypeIds: [EVENT_TYPE],
delivery: options.delivery ?? "AUTHORITATIVE_DELTA",
recovery,
fallback:
recovery.mode === "SESSION_REBUILD"
? "EXPLICITLY_STALE"
: "BOUNDED_POLLING",
hiddenPolicy: "CLOSE",
limits: options.limits ?? TEST_LIMITS,
killSwitchId: KILL_SWITCH_ID,
};
return createRealtimePolicyRegistry({
streams: [options.streamMutator?.(stream) ?? stream],
eventTypes: [
options.eventTypeMutator?.(eventType) ?? eventType,
],
bindings: {
schemaCodecs: TEST_SCHEMA_CODECS,
mappers: TEST_MAPPERS,
apiOperations: TEST_API_OPERATIONS,
endpointIds: [ENDPOINT_ID],
effectProfileIds: [EFFECT_PROFILE_ID],
killSwitchIds: [KILL_SWITCH_ID],
rebuildInputIds: ["referenceRealtimeRebuild"],
},
});
}
export function createTestRealtimeCodec(
registry = createTestRealtimeRegistry(),
): RealtimeEventCodec {
return createRealtimeEventCodec({
registry,
schemaCodecs: TEST_SCHEMA_CODECS,
});
}
export type EventOverrides = Readonly<{
protocol?: unknown;
streamId?: unknown;
streamEpoch?: unknown;
eventType?: unknown;
eventId?: unknown;
sequence?: unknown;
recoveryMode?: unknown;
resumeCursor?: unknown;
occurredAt?: unknown;
scopeBinding?: unknown;
payload?: unknown;
}>;
export function realtimeEventValue(
overrides: EventOverrides = {},
): Readonly<Record<string, unknown>> {
return {
protocol: "REALTIME_EVENT_V1",
streamId: STREAM_ID,
streamEpoch: "stream-epoch-0001",
eventType: EVENT_TYPE,
eventId: "event-00000001",
sequence: "1",
recoveryMode: "CURSOR",
resumeCursor: "cursor-00000001",
occurredAt: "2026-07-28T01:02:03.123Z",
scopeBinding: "scope-binding-0001",
payload: { value: "changed" },
...overrides,
};
}
export function realtimeEventJson(
overrides: EventOverrides = {},
): string {
return JSON.stringify(realtimeEventValue(overrides));
}