@orkestrel/scaffold 0.0.48 → 0.0.50

package/dist/host/tests/config.test.ts

@@ -15,7 +15,7 @@ import {
 import { createRequire } from 'node:module'
 import { dirname, join, resolve } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
-import { build, loadConfigFromFile } from 'vite'
+import { build, createServer, loadConfigFromFile } from 'vite'
 import { RuleTester } from 'oxlint/plugins-dev'
 import * as configHelpers from '../configs/helpers.js'
 import { MOCKING_RULE, NESTED_RULE, PRIVACY_RULE } from '../configs/policy.js'
@@ -152,11 +152,10 @@ describe('root configuration', () => {
 			pool: 'threads',
 			setup: ['./tests/setup.ts'],
 		})
-		// A row that is a configuration rather than a factory. A workspace with a
-		// browser application emits one, because that factory refuses overrides and
-		// so is not a value Vitest may call. It is required here, in a workspace that
-		// has no browser application, so this proof exercises that resolution
-		// wherever it runs instead of only where the shape happens to occur.
+		// A row that is a configuration rather than a factory. Every generated
+		// workspace registers the factory itself, so this shape is required here
+		// rather than observed: the proof exercises that resolution wherever it runs
+		// instead of only where a hand-written configuration happens to produce it.
 		expected.set('concrete', { include: 'tests/concrete.test.ts', setup: ['./tests/setup.ts'] })
 
 		const projects = configuration.test?.projects
@@ -297,6 +296,28 @@ describe('root configuration', () => {
 		}).toThrow(/strictly equal/u)
 	})
 
+	it('emits every project as a factory so the release mode reaches its proof', () => {
+		const projects = configuration.test?.projects
+		if (!Array.isArray(projects)) throw new Error('The root configuration carries no projects')
+		if (projects.length === 0) throw new Error('The root configuration registers no project')
+		// Measured: with `--mode release` on the command line, `import.meta.env.MODE` reads
+		// `release` inside a project Vitest calls and `test` inside an inline project
+		// configuration. `prepublishOnly` runs the distribution proof with `--mode release`, and
+		// that proof fails rather than skips only when it reads `release`, so converting these
+		// entries to inline configurations turns the publish gate into a skip while every suite
+		// stays green. The control is that conversion applied to one entry.
+		const inline = {
+			test: {
+				name: { label: 'inline' },
+				include: ['tests/inline.test.ts'],
+				setupFiles: ['./tests/setup.ts'],
+			},
+		}
+		const callable = projects.concat(inline).filter((entry) => typeof entry === 'function')
+		for (const entry of projects) expect(callable).toContain(entry)
+		expect(callable).not.toContain(inline)
+	})
+
 	it('requires and validates every selected target wrapper', async () => {
 		const required: string[] = []
 		for (const axis of ['src', 'app']) {
@@ -513,6 +534,108 @@ describe('root configuration', () => {
 		)
 	})
 
+	it('keeps the committed host inventory aligned with the vendored checkout bytes', async () => {
+		// Run this gate against a quiescent checkout. It compares two reads and cannot
+		// distinguish stale committed data from a source edit made while it runs.
+		const packageValue: unknown = JSON.parse(readFileSync(resolve(root, 'package.json'), 'utf8'))
+		if (typeof packageValue !== 'object' || packageValue === null) {
+			throw new Error('The package manifest is not a record')
+		}
+		const scripts: unknown = Object.getOwnPropertyDescriptor(packageValue, 'scripts')?.value
+		if (typeof scripts !== 'object' || scripts === null) {
+			throw new Error('The package manifest carries no scripts')
+		}
+		const generator: unknown = Object.getOwnPropertyDescriptor(scripts, 'build:inventory')?.value
+		expect(generator === undefined || typeof generator === 'string').toBe(true)
+		if (generator === undefined) {
+			if (existsSync(resolve(root, 'host.json'))) {
+				throw new Error('A committed host inventory exists without a generator')
+			}
+			return
+		}
+		if (typeof generator !== 'string') {
+			throw new Error('The host inventory generator is not a script')
+		}
+		const committed = resolve(root, 'host.json')
+		if (!existsSync(committed)) {
+			throw new Error('The committed host inventory is absent at host.json')
+		}
+		const helper = resolve(root, 'src/server/helpers.ts')
+		if (!existsSync(helper)) {
+			throw new Error('The committed host inventory has no server stager')
+		}
+		const server = await createServer({
+			configFile: false,
+			root,
+			...(configuration.resolve === undefined ? {} : { resolve: configuration.resolve }),
+			server: { middlewareMode: true },
+		})
+		try {
+			const loaded: unknown = await server.ssrLoadModule(helper)
+			if (typeof loaded !== 'object' || loaded === null) {
+				throw new Error('The server helper module did not load')
+			}
+			const stage: unknown = Reflect.get(loaded, 'stageInventory')
+			if (typeof stage !== 'function') {
+				throw new Error('The server helper module exports no stageInventory function')
+			}
+			const workspace = mkdtempSync(join(root, 'host-inventory-'))
+			try {
+				const generated = join(workspace, 'host.json')
+				Reflect.apply(stage, undefined, [root, generated])
+				const generatedText = readFileSync(generated, 'utf8')
+				const committedText = readFileSync(committed, 'utf8')
+				const values: readonly unknown[] = [JSON.parse(generatedText), JSON.parse(committedText)]
+				const indexes: Array<Map<string, string>> = []
+				for (const value of values) {
+					if (typeof value !== 'object' || value === null) {
+						throw new Error('A host inventory is not a record')
+					}
+					const entries: unknown = Object.getOwnPropertyDescriptor(value, 'entries')?.value
+					if (!Array.isArray(entries)) throw new Error('A host inventory carries no entry list')
+					const index = new Map<string, string>()
+					for (const entry of entries) {
+						if (typeof entry !== 'object' || entry === null) {
+							throw new Error('A host inventory carries a malformed entry')
+						}
+						const destination: unknown = Object.getOwnPropertyDescriptor(
+							entry,
+							'destination',
+						)?.value
+						const digest: unknown = Object.getOwnPropertyDescriptor(entry, 'digest')?.value
+						if (typeof destination !== 'string' || typeof digest !== 'string') {
+							throw new Error('A host inventory entry carries no destination digest')
+						}
+						index.set(destination, digest)
+					}
+					indexes.push(index)
+				}
+				const generatedIndex = indexes[0]
+				const committedIndex = indexes[1]
+				if (generatedIndex === undefined || committedIndex === undefined) {
+					throw new Error('The host inventories were not indexed')
+				}
+				if (generatedText !== committedText) {
+					const stale: string[] = []
+					for (const [destination, digest] of generatedIndex) {
+						if (committedIndex.get(destination) !== digest) stale.push(destination)
+					}
+					for (const destination of committedIndex.keys()) {
+						if (!generatedIndex.has(destination)) stale.push(destination)
+					}
+					throw new Error(
+						`The committed host inventory is stale at ${stale.length > 0 ? stale.sort().join(', ') : 'host.json'}`,
+					)
+				}
+				console.info(`host-inventory: entries=${generatedIndex.size}`)
+			} finally {
+				rmSync(workspace, { recursive: true, force: true })
+			}
+		} finally {
+			await server.close()
+		}
+	})
+
 	it('keeps policy rules active across every linted workspace path', () => {
 		const parsed: unknown = JSON.parse(readFileSync(resolve(root, '.oxlintrc.json'), 'utf8'))
 		expect(inspectPolicyConfiguration(parsed)).toEqual([])