From bcf8752f24a7c9d30d4beb58818281e12c8ba77a Mon Sep 17 00:00:00 2001 From: DongHyeonka Date: Fri, 25 Sep 2026 22:29:51 +0900 Subject: [PATCH] test(features): keep the two-feature fixture off the removable sample (09-01) The fixture relied on reference-feature and its context, so sample removal failed on it. It now installs two synthetic features in its own context, and the invalidation flatMaps get the same explicit element types as the other composers (frozen empty arrays exposed the same union inference failure). Co-Authored-By: Claude Opus 5.5 --- src/features/installed-feature-contracts.ts | 21 +++- .../two-feature-install-typecheck.test.ts | 99 ++++++++++++++++--- 2 files changed, 103 insertions(+), 17 deletions(-) diff --git a/src/features/installed-feature-contracts.ts b/src/features/installed-feature-contracts.ts index 6dec978b..dd736089 100644 --- a/src/features/installed-feature-contracts.ts +++ b/src/features/installed-feature-contracts.ts @@ -45,25 +45,38 @@ export const REST_PROFILE_BINDINGS_VALID = validateRestProfileBindings( API_OPERATIONS, Object.freeze({ PRIMARY_API: Object.freeze(["omit"] as const) }), ); +// 09-01. Element types are spelled out for the same reason as in +// installed-feature-adapters.ts: flatMap over the installed-contract union +// otherwise returns the member arrays unflattened. +type InstalledInvalidation = + (typeof INSTALLED_FEATURE_CONTRACTS)[number]["invalidation"]; +type InstalledTopicVersion = + (typeof INSTALLED_FEATURE_CONTRACTS)[number]["topicVersions"][number]; + export const INVALIDATION_REGISTRY = Object.freeze({ topics: Object.freeze( INSTALLED_FEATURE_CONTRACTS.flatMap( - (contract) => contract.invalidation.topics, + (contract): readonly InstalledInvalidation["topics"][number][] => + contract.invalidation.topics, ), ), namespaces: Object.freeze( INSTALLED_FEATURE_CONTRACTS.flatMap( - (contract) => contract.invalidation.namespaces, + (contract): readonly InstalledInvalidation["namespaces"][number][] => + contract.invalidation.namespaces, ), ), edges: Object.freeze( INSTALLED_FEATURE_CONTRACTS.flatMap( - (contract) => contract.invalidation.edges, + (contract): readonly InstalledInvalidation["edges"][number][] => + contract.invalidation.edges, ), ), }); export const INVALIDATION_TOPIC_VERSIONS = Object.freeze( - INSTALLED_FEATURE_CONTRACTS.flatMap((contract) => contract.topicVersions), + INSTALLED_FEATURE_CONTRACTS.flatMap( + (contract): readonly InstalledTopicVersion[] => contract.topicVersions, + ), ); export const SCHEMA_REGISTRY = composeSchemaRegistry([ PLATFORM_SCHEMA_REGISTRY, diff --git a/tests/unit/two-feature-install-typecheck.test.ts b/tests/unit/two-feature-install-typecheck.test.ts index 1ba94ec8..bc8bfaa7 100644 --- a/tests/unit/two-feature-install-typecheck.test.ts +++ b/tests/unit/two-feature-install-typecheck.test.ts @@ -8,11 +8,12 @@ import { afterAll, describe, expect, it } from "vitest"; /** * 09-01. The central composers (`src/features/installed-*`) are typed from the * generated feature index, so the repository's own typecheck only ever sees - * one installed feature. This installs a second feature whose shape differs - * from reference-feature on every composed axis (feature id, adapter needs, - * no routes, no runtimes, a different locale set) into a copy of `src`, - * regenerates the index with the production generator and runs the app - * typecheck over the copy. + * the features it ships. This installs two more into a copy of `src`, in a + * context of their own so the check survives the sample's removal: one with a + * route, a runtime and both locales but no adapter, and one shaped differently + * on every composed axis (an adapter that needs telemetry, no routes, no + * runtime, one locale). It regenerates the index + * with the production generator and runs the app typecheck over the copy. */ const SECOND_FEATURE_MODULE = `import { defineFeatureAdapterContribution } from "../feature-adapter-contribution.ts"; import { defineFeatureModule } from "../feature-module.ts"; @@ -26,7 +27,7 @@ declare module "../../application/ports/in/application-api.ts" { } export const FEATURE_MODULE_ID = "second-feature"; -export const FEATURE_CONTEXT_ID = "reference-context"; +export const FEATURE_CONTEXT_ID = "two-feature-context"; export const FEATURE_MODULE = defineFeatureModule({ id: FEATURE_MODULE_ID, @@ -35,8 +36,13 @@ export const FEATURE_MODULE = defineFeatureModule({ routes: {}, routeRuntimeContracts: {}, apiOperations: {}, - invalidation: { topics: [], namespaces: [], edges: [] }, - topicVersions: [], + // Frozen empty arrays type as \`readonly never[]\`, not \`readonly []\`. + invalidation: { + topics: Object.freeze([]), + namespaces: Object.freeze([]), + edges: Object.freeze([]), + }, + topicVersions: Object.freeze([]), schemas: {}, runtimeSchemas: {}, mappers: {}, @@ -64,6 +70,66 @@ const SECOND_FEATURE_ROUTES = `import type { RouteObject } from "react-router-do export const FEATURE_CONTEXT_ROUTES: readonly RouteObject[] = Object.freeze([]); `; +const ROUTED_FEATURE_MODULE = `import { defineFeatureModule } from "../feature-module.ts"; + +export const FEATURE_MODULE_ID = "routed-feature"; +export const FEATURE_CONTEXT_ID = "two-feature-context"; + +const ROUTES = { + ROUTED_ITEMS: { + routeId: "ROUTED_ITEMS", + path: "/two-feature/items", + paramsSchema: null, + searchSchema: null, + access: "public", + loadingSurface: "routed-items", + errorSurface: "feature-boundary", + chunkId: "route-routed-items", + title: "route.ROUTED_ITEMS.title", + navigationLabel: null, + navigationOrder: null, + }, +} as const; + +const MESSAGES = { + "route.ROUTED_ITEMS.title": "Routed items", + "route.ROUTED_ITEMS.navigation": "Routed items", +} as const; + +export const FEATURE_MODULE = defineFeatureModule({ + id: FEATURE_MODULE_ID, + contracts: { + featureId: FEATURE_MODULE_ID, + routes: ROUTES, + routeRuntimeContracts: { + ROUTED_ITEMS: { + routeId: "ROUTED_ITEMS", + moduleId: "routed-items-page", + paramsCodec: "none", + searchCodec: "none", + }, + }, + apiOperations: {}, + invalidation: { topics: [], namespaces: [], edges: [] }, + topicVersions: [], + schemas: {}, + runtimeSchemas: {}, + mappers: {}, + }, + routes: ROUTES, + adapters: [], + runtimes: [{ featureId: FEATURE_MODULE_ID, routeCodecs: {}, routeRuntime: {} }], + messages: { "ko-KR": MESSAGES, "en-US": MESSAGES }, + contractContributions: [], +} as const); +`; + +const CONTEXT_MODULE = `export const CONTEXT_MODULE_ID = "two-feature-context"; +export const CONTEXT_APP_ID = "template-app"; +export const CONTEXT_ROUTE_PATH = "two-feature/*"; +export const CONTEXT_MAX_FEATURES = 2; +`; + const roots: string[] = []; afterAll(async () => { @@ -79,10 +145,17 @@ describe("installing a second feature (09-01)", () => { await cp(path.resolve(config), path.join(root, config)); } await symlink(path.resolve("node_modules"), path.join(root, "node_modules"), "dir"); - const featureRoot = path.join(root, "src/features/second-feature"); - await mkdir(featureRoot, { recursive: true }); - await writeFile(path.join(featureRoot, "feature-module.ts"), SECOND_FEATURE_MODULE); - await writeFile(path.join(featureRoot, "context-routes.ts"), SECOND_FEATURE_ROUTES); + const files: Readonly> = { + "src/contexts/two-feature-context/context-module.ts": CONTEXT_MODULE, + "src/features/routed-feature/feature-module.ts": ROUTED_FEATURE_MODULE, + "src/features/routed-feature/context-routes.ts": SECOND_FEATURE_ROUTES, + "src/features/second-feature/feature-module.ts": SECOND_FEATURE_MODULE, + "src/features/second-feature/context-routes.ts": SECOND_FEATURE_ROUTES, + }; + for (const [file, content] of Object.entries(files)) { + await mkdir(path.dirname(path.join(root, file)), { recursive: true }); + await writeFile(path.join(root, file), content); + } const generated = spawnSync( process.execPath, @@ -93,7 +166,7 @@ describe("installing a second feature (09-01)", () => { expect(generated.status).toBe(0); const index = await readFile(path.join(root, "src/.generated/product-feature-index.ts"), "utf8"); expect(index).toContain("../features/second-feature/feature-module.ts"); - expect(index).toContain("../features/reference-feature/feature-module.ts"); + expect(index).toContain("../features/routed-feature/feature-module.ts"); const typecheck = spawnSync( path.resolve("node_modules/.bin/tsc"),