325 lines
20 KiB
TypeScript
325 lines
20 KiB
TypeScript
import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
|
|
import { tmpdir } from 'node:os'
|
|
import { dirname, join, resolve } from 'node:path'
|
|
import { afterEach, describe, expect, it } from 'vitest'
|
|
import { collectLogEvents } from './gen-persistence-catalog.ts'
|
|
import { extractPersistenceSchema } from './persistence-schema.ts'
|
|
import { canonicalizeSchema, isArbitraryJsonSchema, schemaDigest, type PersistenceSchemaInventory } from './persistence-schema-model.ts'
|
|
|
|
const roots: string[] = []
|
|
afterEach(() => {
|
|
for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true, maxRetries: 3 })
|
|
})
|
|
|
|
function put(root: string, file: string, source: string): void {
|
|
const path = join(root, file)
|
|
mkdirSync(dirname(path), { recursive: true })
|
|
writeFileSync(path, source)
|
|
}
|
|
|
|
function fixture(payload: string, options: { surface?: string; event?: string } = {}): string {
|
|
const root = mkdtempSync(join(tmpdir(), 'dsh-persistence-schema-'))
|
|
roots.push(root)
|
|
put(root, 'tsconfig.host.json', JSON.stringify({ compilerOptions: {
|
|
target: 'es2024', module: 'esnext', moduleResolution: 'bundler', strict: true, skipLibCheck: true,
|
|
types: [], paths: {
|
|
'@deepseek-ai/dsh-session/types': ['./packages/core/session/src/types.ts'],
|
|
'@fixture/payload': ['./packages/domain/payload/src/types.ts'],
|
|
},
|
|
}, include: ['packages/**/src/**/*.ts'] }))
|
|
put(root, 'packages/core/session/package.json', '{"name":"@deepseek-ai/dsh-session"}')
|
|
put(root, 'packages/domain/payload/package.json', '{"name":"@fixture/payload"}')
|
|
put(root, 'packages/session/session-persistence-jsonl/src/format.ts', "interface HeaderLine {type: 'session'; version: number; id: string; delegationDepth: number}\nexport {}\n")
|
|
put(root, 'packages/domain/payload/src/types.ts', payload)
|
|
put(root, 'packages/core/session/src/types.ts', `
|
|
import type { Payload } from '@fixture/payload'
|
|
export interface SessionHeader { version: 3; id: string; createdAt: number }
|
|
export interface SessionEventMap {
|
|
/** One recorded payload. */
|
|
'test/record': Payload
|
|
${options.event ?? ''}
|
|
}
|
|
export type SurfaceEventType = ${options.surface ?? 'never'}
|
|
export type SessionEvent<T extends keyof SessionEventMap = keyof SessionEventMap> = {
|
|
[K in keyof SessionEventMap]: { type: K; seq: number; time: number; data: SessionEventMap[K] }
|
|
& (K extends SurfaceEventType ? { surfaceOp: 'append' | { replace: number } } : { surfaceOp?: never })
|
|
}[T]
|
|
`)
|
|
return root
|
|
}
|
|
|
|
function event(inventory: PersistenceSchemaInventory, name = 'test/record'): string {
|
|
const root = inventory.roots.find(root => root.event === name)
|
|
if (root === undefined) throw new Error(`missing test event ${name}`)
|
|
return root.digest
|
|
}
|
|
|
|
describe('persistent source type extraction', () => {
|
|
it('ignores alias names, files, documentation, readonly, brands and property order', () => {
|
|
const left = fixture('declare const brand: unique symbol; type Id = string & {readonly [brand]: "Id"}; export interface Payload { readonly id: Id; value?: number }')
|
|
const right = fixture('type Renamed = string; /** Different documentation. */ export type Payload = {value?: number; id: Renamed}')
|
|
expect(event(extractPersistenceSchema(left))).toBe(event(extractPersistenceSchema(right)))
|
|
})
|
|
|
|
it.each([
|
|
['nested field order',
|
|
'export interface Payload {\n id: string\n detail: {\n label: string\n count?: number\n }\n}',
|
|
'export interface Payload {\n detail: {\n count?: number\n label: string\n }\n id: string\n}'],
|
|
['anonymous union order',
|
|
'export type Payload =\n { a: string }\n | { b: number }\n | { c?: boolean }',
|
|
'export type Payload =\n { c?: boolean }\n | { b: number }\n | { a: string }'],
|
|
['recursive union order',
|
|
'export type Payload =\n { a: string; next?: Payload }\n | { b: number; next?: Payload }\n | null',
|
|
'export type Payload =\n null\n | { next?: Payload; b: number }\n | { next?: Payload; a: string }'],
|
|
['intersection and distributed union order',
|
|
'type A = { a: string } | { b: number }; type B = { c: boolean }; export type Payload = A & B',
|
|
'type A = { b: number } | { a: string }; type B = { c: boolean }; export type Payload = B & A'],
|
|
['index signature order',
|
|
'export interface Payload { [key: string]: string | number; [key: number]: number }',
|
|
'export interface Payload { [key: number]: number; [key: string]: number | string }'],
|
|
['type declaration order',
|
|
'interface A { a: string }\ninterface B { b: number }\nexport type Payload = A | B',
|
|
'interface B { b: number }\ninterface A { a: string }\nexport type Payload = B | A'],
|
|
['merged declaration order',
|
|
'export interface Payload { a: string }\nexport interface Payload { b: number }',
|
|
'export interface Payload { b: number }\nexport interface Payload { a: string }'],
|
|
['mapped key order',
|
|
'export type Payload = { [K in "a" | "b" | "c"]: string }',
|
|
'export type Payload = { [K in "c" | "b" | "a"]: string }'],
|
|
['explicit enum member order',
|
|
'enum Value {\n A = "a",\n B = "b",\n}\nexport interface Payload { value: Value }',
|
|
'enum Value {\n B = "b",\n A = "a",\n}\nexport interface Payload { value: Value }'],
|
|
])('keeps every root and type digest unchanged by %s', (_name, before, after) => {
|
|
const root = fixture(before)
|
|
const inventory = extractPersistenceSchema(root)
|
|
put(root, 'packages/domain/payload/src/types.ts', after)
|
|
const reordered = extractPersistenceSchema(root)
|
|
expect(reordered.roots).toEqual(inventory.roots)
|
|
expect(reordered.types.map(({ digest, schema }) => ({ digest, schema })))
|
|
.toEqual(inventory.types.map(({ digest, schema }) => ({ digest, schema })))
|
|
})
|
|
|
|
it.each([
|
|
['tuple positions', 'export type Payload = [string, number]', 'export type Payload = [number, string]'],
|
|
['implicit enum values', 'enum Value { A, B }; export interface Payload { value: Value.A }', 'enum Value { B, A }; export interface Payload { value: Value.A }'],
|
|
])('changes the digest when reordering changes %s', (_name, before, after) => {
|
|
const root = fixture(before)
|
|
const digest = event(extractPersistenceSchema(root))
|
|
put(root, 'packages/domain/payload/src/types.ts', after)
|
|
expect(event(extractPersistenceSchema(root))).not.toBe(digest)
|
|
})
|
|
|
|
it('keeps header, envelope and event digests unchanged when root declarations are reordered', () => {
|
|
const record = " /** One recorded payload. */\n 'test/record': Payload"
|
|
const other = "/** Another recorded payload. */\n 'test/other': { value: number }"
|
|
const root = fixture('export interface Payload { id: string }', {
|
|
surface: "'test/record' | 'test/other'",
|
|
event: other,
|
|
})
|
|
const inventory = extractPersistenceSchema(root)
|
|
const source = readFileSync(join(root, 'packages/core/session/src/types.ts'), 'utf8')
|
|
const reordered = source
|
|
.replace(`${record}\n ${other}`, ` ${other}\n${record}`)
|
|
.replace('version: 3; id: string; createdAt: number', 'createdAt: number; id: string; version: 3')
|
|
.replace("'test/record' | 'test/other'", "'test/other' | 'test/record'")
|
|
.replace('type: K; seq: number; time: number; data: SessionEventMap[K]', 'data: SessionEventMap[K]; time: number; seq: number; type: K')
|
|
expect(reordered.indexOf("'test/other':")).toBeLessThan(reordered.indexOf("'test/record':"))
|
|
put(root, 'packages/core/session/src/types.ts', reordered)
|
|
put(root, 'packages/session/session-persistence-jsonl/src/format.ts', "interface HeaderLine {delegationDepth: number; id: string; version: number; type: 'session'}\nexport {}\n")
|
|
const result = extractPersistenceSchema(root)
|
|
expect(result.roots).toEqual(inventory.roots)
|
|
expect(result.types.map(({ digest, schema }) => ({ digest, schema })))
|
|
.toEqual(inventory.types.map(({ digest, schema }) => ({ digest, schema })))
|
|
})
|
|
|
|
it('materializes generic, conditional and mapped aliases into their concrete properties', () => {
|
|
const generic = fixture('type Box<T> = { [K in keyof T]: T[K] extends string ? string[] : T[K] }; export type Payload = Box<{label: string; count?: number}>')
|
|
const concrete = fixture('export interface Payload {count?: number; label: string[]}')
|
|
expect(event(extractPersistenceSchema(generic))).toBe(event(extractPersistenceSchema(concrete)))
|
|
})
|
|
|
|
it('retains transitive recursion without depending on alias factoring', () => {
|
|
const self = fixture('export interface Payload { value: string; next?: Payload }')
|
|
const mutual = fixture('interface Other {next?: Payload; value: string} export interface Payload {value: string; next?: Other}')
|
|
const changed = fixture('interface Other {next?: Payload; value: number} export interface Payload {value: string; next?: Other}')
|
|
const digest = event(extractPersistenceSchema(self))
|
|
expect(event(extractPersistenceSchema(mutual))).toBe(digest)
|
|
expect(event(extractPersistenceSchema(changed))).not.toBe(digest)
|
|
})
|
|
|
|
it('includes independent Host modules that augment nested payload maps without event declarations', () => {
|
|
const root = fixture('export interface NestedMap {first: {value: string}}; export type Payload = NestedMap[keyof NestedMap]')
|
|
const before = extractPersistenceSchema(root)
|
|
put(root, 'packages/domain/extension/src/index.ts', "import '@fixture/payload'; declare module '@fixture/payload' {interface NestedMap {second: {value: number}}}")
|
|
const after = extractPersistenceSchema(root)
|
|
expect(collectLogEvents(root)).toHaveLength(1)
|
|
expect(event(after)).not.toBe(event(before))
|
|
const data = after.types.find(item => item.schema.nodes[0]?.kind === 'union' && item.schema.nodes.some(node => node.kind === 'primitive' && node.type === 'number'))
|
|
expect(data).toBeDefined()
|
|
})
|
|
|
|
it('discovers plugin event merges and keeps ordinary event additions out of the envelope digest', () => {
|
|
const root = fixture('export interface Payload {id: string}')
|
|
const before = extractPersistenceSchema(root)
|
|
put(root, 'packages/domain/extension/src/index.ts', `import '@deepseek-ai/dsh-session/types'; declare module '@deepseek-ai/dsh-session/types' {
|
|
interface SessionEventMap {
|
|
/** A plugin event. */
|
|
'plugin/new': { optional?: boolean }
|
|
}}
|
|
`)
|
|
const after = extractPersistenceSchema(root)
|
|
expect(after.roots.some(root => root.event === 'plugin/new')).toBe(true)
|
|
expect(after.roots.find(root => root.kind === 'envelope')?.digest).toBe(before.roots.find(root => root.kind === 'envelope')?.digest)
|
|
expect(event(after)).toBe(event(before))
|
|
})
|
|
|
|
it('includes JSX-module events and rejects unsupported inherited declarations there', () => {
|
|
const root = fixture('export interface Payload {id: string}')
|
|
put(root, 'packages/domain/extension/src/index.tsx', `import '@deepseek-ai/dsh-session/types'; declare module '@deepseek-ai/dsh-session/types' {
|
|
interface SessionEventMap {
|
|
/** A JSX-module event. */
|
|
'plugin/tsx': { value: number }
|
|
}}
|
|
`)
|
|
const config = join(root, 'tsconfig.host.json')
|
|
const settings = JSON.parse(readFileSync(config, 'utf8')) as { include: string[] }
|
|
settings.include.push('packages/**/src/**/*.tsx')
|
|
writeFileSync(config, JSON.stringify(settings))
|
|
expect(extractPersistenceSchema(root).roots.some(root => root.event === 'plugin/tsx')).toBe(true)
|
|
put(root, 'packages/domain/extension/src/index.tsx', `import '@deepseek-ai/dsh-session/types';
|
|
interface Extra { 'plugin/inherited': {value: number} }
|
|
declare module '@deepseek-ai/dsh-session/types' { interface SessionEventMap extends Extra {} }
|
|
`)
|
|
expect(() => extractPersistenceSchema(root)).toThrow('uses extends')
|
|
})
|
|
|
|
it('rejects an event map whose compiler vocabulary exceeds the discovered source corpus', () => {
|
|
const root = fixture("import '../../../../vendor/events.ts'; export interface Payload {id: string}")
|
|
put(root, 'vendor/events.ts', `import '@deepseek-ai/dsh-session/types'; declare module '@deepseek-ai/dsh-session/types' {
|
|
interface SessionEventMap {
|
|
/** A contribution outside the package source corpus. */
|
|
'outside/event': { value: number }
|
|
}}
|
|
`)
|
|
expect(() => extractPersistenceSchema(root)).toThrow('omitted: outside/event')
|
|
})
|
|
|
|
it('keeps surface metadata strict and optional field additions visible', () => {
|
|
const old = extractPersistenceSchema(fixture('export interface Payload {id: string}'))
|
|
const optional = extractPersistenceSchema(fixture('export interface Payload {id: string; detail?: string}'))
|
|
const surface = extractPersistenceSchema(fixture('export interface Payload {id: string}', { surface: "'test/record'" }))
|
|
expect(event(old)).not.toBe(event(optional))
|
|
expect(event(old)).not.toBe(event(surface))
|
|
expect(surface.roots.find(root => root.event === 'test/record')?.surface).toBe(true)
|
|
expect(surface.roots.find(root => root.kind === 'envelope')?.digest).not.toBe(old.roots.find(root => root.kind === 'envelope')?.digest)
|
|
})
|
|
|
|
it('tracks the physical JSONL header independently of the logical Session header', () => {
|
|
const root = fixture('export interface Payload {id: string}')
|
|
const before = extractPersistenceSchema(root)
|
|
put(root, 'packages/session/session-persistence-jsonl/src/format.ts', "interface HeaderLine {type: 'session'; version: number; id: string; delegationDepth: number; marker?: string}\nexport {}\n")
|
|
const after = extractPersistenceSchema(root)
|
|
expect(after.roots.find(root => root.key === 'JsonlHeaderLine')?.digest).not.toBe(before.roots.find(root => root.key === 'JsonlHeaderLine')?.digest)
|
|
expect(after.roots.find(root => root.key === 'SessionHeader')?.digest).toBe(before.roots.find(root => root.key === 'SessionHeader')?.digest)
|
|
})
|
|
|
|
it('keeps arbitrary JSON structural while explicitly identifying unknown and any', () => {
|
|
const root = fixture('type Arbitrary = null | boolean | number | string | Arbitrary[] | {[key: string]: Arbitrary}; export interface Payload {json: Arbitrary; opaque: unknown; unsafe: any}')
|
|
const model = extractPersistenceSchema(root)
|
|
expect(model.types.some(item => isArbitraryJsonSchema(item.schema))).toBe(true)
|
|
expect(model.types.filter(item => item.schema.nodes[0]?.kind === 'opaque').map(item => item.schema.nodes[0]))
|
|
.toEqual(expect.arrayContaining([{ kind: 'opaque', reason: 'unknown' }, { kind: 'opaque', reason: 'any' }]))
|
|
put(root, 'packages/domain/payload/src/types.ts', 'type Arbitrary = null | boolean | number | string | Arbitrary[]; export interface Payload {json: Arbitrary; opaque: unknown; unsafe: any}')
|
|
const changed = extractPersistenceSchema(root)
|
|
expect(event(changed)).not.toBe(event(model))
|
|
expect(changed.types.some(item => isArbitraryJsonSchema(item.schema))).toBe(false)
|
|
})
|
|
|
|
it('rejects invalid reachable declaration files despite inherited skipLibCheck', () => {
|
|
const root = fixture("export type { Payload } from './declared.js'")
|
|
put(root, 'packages/domain/payload/src/declared.d.ts', 'type Bad = ReturnType<42>; export interface Payload {value: Bad}')
|
|
expect(() => extractPersistenceSchema(root)).toThrow('TS2344')
|
|
})
|
|
|
|
it('preserves authored declaration-file any without checking unrelated declarations', () => {
|
|
const root = fixture("export type { Payload } from './declared.js'")
|
|
put(root, 'packages/domain/payload/src/declared.d.ts', 'type Declared = any; export interface Payload {value: Declared}; type Unrelated = ReturnType<42>')
|
|
const model = extractPersistenceSchema(root)
|
|
expect(model.types.some(item => item.schema.nodes[0]?.kind === 'opaque' && item.schema.nodes[0].reason === 'any')).toBe(true)
|
|
})
|
|
|
|
it('locates named transitive definitions at their declarations instead of their references', () => {
|
|
const root = fixture("import type { Detail as ImportedDetail } from './detail.js'\nexport interface Payload { first: ImportedDetail; second: ImportedDetail }")
|
|
put(root, 'packages/domain/payload/src/detail.ts', '/** Detailed payload. */\nexport interface Detail { code: string; done: true }\n')
|
|
const model = extractPersistenceSchema(root)
|
|
const detail = model.types.find(item => item.names.includes('packages/domain/payload/src/detail.ts#Detail'))
|
|
expect(detail?.sources).toEqual(['packages/domain/payload/src/detail.ts:2'])
|
|
})
|
|
|
|
it('keeps shared scalar declaration metadata at real aliases and omits plain property references', () => {
|
|
const root = fixture([
|
|
'type Label = string',
|
|
"type Done = 'done'",
|
|
'export interface Payload {',
|
|
' label: Label',
|
|
' other: string',
|
|
' state: Done',
|
|
" fallback: 'done'",
|
|
' count: number',
|
|
'}',
|
|
].join('\n'))
|
|
const model = extractPersistenceSchema(root)
|
|
const string = model.types.find(item => item.schema.nodes[0]?.kind === 'primitive' && item.schema.nodes[0].type === 'string')
|
|
const literal = model.types.find(item => item.schema.nodes[0]?.kind === 'literal' && item.schema.nodes[0].value === 'done')
|
|
const number = model.types.find(item => item.schema.nodes[0]?.kind === 'primitive' && item.schema.nodes[0].type === 'number')
|
|
expect(string?.names).toEqual(['packages/domain/payload/src/types.ts#Label'])
|
|
expect(string?.sources).toEqual(['packages/domain/payload/src/types.ts:1'])
|
|
expect(literal?.names).toEqual(['packages/domain/payload/src/types.ts#Done'])
|
|
expect(literal?.sources).toEqual(['packages/domain/payload/src/types.ts:2'])
|
|
expect(number?.names).toEqual([])
|
|
expect(number?.sources).toEqual([])
|
|
})
|
|
|
|
it('uses the declaration of an anonymous object literal and never its containing property', () => {
|
|
const root = fixture('export interface Payload {\n detail:\n { code: string }\n}')
|
|
const model = extractPersistenceSchema(root)
|
|
const detail = model.types.find((item) => {
|
|
const node = item.schema.nodes[0]
|
|
return node?.kind === 'object' && node.properties.length === 1 && node.properties[0]?.name === 'code'
|
|
})
|
|
expect(detail?.sources).toEqual(['packages/domain/payload/src/types.ts:3'])
|
|
})
|
|
|
|
it.each([
|
|
['missing type', 'export interface Payload {value: Missing}', 'TS2304'],
|
|
['callable value', 'export interface Payload {value: () => void}', 'callable data'],
|
|
['class instance', 'export class Instance {value: string = ""}; export interface Payload {value: Instance}', 'class instances'],
|
|
['required undefined', 'export interface Payload {value: string | undefined}', 'no supported JSON'],
|
|
['unresolved template', 'export interface Payload {value: `prefix-${string}`}', 'no supported JSON'],
|
|
['empty object type', 'export type Payload = {}', 'unconstrained empty object'],
|
|
['symbol property', 'declare const key: unique symbol; export interface Payload {[key]: string; value: number}', 'symbol-keyed data'],
|
|
['conflicting merged property', 'export interface Payload {value: string}; export interface Payload {value: number}', 'TS2717'],
|
|
['class intersection', 'class Instance {value: string = ""}; export type Payload = Instance & {extra: string}', 'class instances'],
|
|
['invalid generic alias', 'type Bad = ReturnType<42>; export interface Payload {value: Bad}', 'TS2344'],
|
|
])('rejects %s rather than weakening the schema', (_name, source, error) => {
|
|
expect(() => extractPersistenceSchema(fixture(source))).toThrow(error)
|
|
})
|
|
|
|
// Repository-wide TypeScript extraction and reachable-node hashing use the Windows coverage test budget.
|
|
it('includes every real repository event and fingerprints every reachable node', { timeout: 90_000 }, () => {
|
|
const root = resolve(import.meta.dirname, '..')
|
|
const model = extractPersistenceSchema(root)
|
|
expect(model.roots.filter(root => root.kind === 'event').map(root => root.event).sort())
|
|
.toEqual(collectLogEvents(root).map(event => event.name).sort())
|
|
expect(model.roots.some(root => root.kind === 'header')).toBe(true)
|
|
expect(model.roots.some(root => root.kind === 'envelope')).toBe(true)
|
|
const digests = new Set(model.types.map(type => type.digest))
|
|
for (const root of model.roots) {
|
|
expect(schemaDigest(root.schema)).toBe(root.digest)
|
|
for (let node = 0; node < root.schema.nodes.length; node++) {
|
|
expect(digests.has(schemaDigest(canonicalizeSchema(root.schema.nodes, node)))).toBe(true)
|
|
}
|
|
}
|
|
})
|
|
})
|