From da0315e69ed7a85e2adfbbea532642d54188f381 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Wed, 30 Sep 2026 11:32:47 +0200 Subject: [PATCH] Test: TypeScript writes a record under an older schema id, C# declares it and rewrites it The C# interop note declares a compatible id and the peer gains a rewrite mode; the TypeScript cross-runtime test has TS write a record under that id and another schema name, C# open and rewrite it, and C#, TypeScript, Rust and Python open the result. Co-Authored-By: Claude Sonnet 5.5 --- packages/cultcache-ts/test/cult-cache.test.ts | 60 +++++++++++++++++++ tests/GameCult.Caching.InteropPeer/Program.cs | 18 +++++- 2 files changed, 76 insertions(+), 2 deletions(-) diff --git a/packages/cultcache-ts/test/cult-cache.test.ts b/packages/cultcache-ts/test/cult-cache.test.ts index c3bf0256..b4c75ee2 100644 --- a/packages/cultcache-ts/test/cult-cache.test.ts +++ b/packages/cultcache-ts/test/cult-cache.test.ts @@ -1219,6 +1219,66 @@ test("CultCache v1 stores stay readable across TS, Rust and Python when a schema } }); +// A record TS wrote under an older schema id and another schema name. The C# note type declares that id compatible, so C# opens the +// record, stamps it with its own id when it writes it back, and every runtime opens the result. +test("A C# type that declares a compatible schema id opens a TypeScript record under it and rewrites it under its own id", async () => { + await buildInteropPeers(); + const legacyId = "cultcache.interop-note.legacy-id"; + const file = join(await mkdtemp(join(tmpdir(), "cultcache-compat-interop-")), "legacy.msgpack"); + await new SingleFileMessagePackBackingStore(file).push({ + key: "note:ts-legacy", + type: "cultcache.interop-note.legacy", + schemaId: legacyId, + catalogEntry: { + schemaId: legacyId, + schemaName: "cultcache.interop-note.legacy", + schemaVersion: interopNoteDocument.schemaVersion!, + contentHash: "legacy", + canonicalSchemaJson: interopNoteDocument.canonicalSchemaJson!, + compatibleSchemaIds: [legacyId], + members: interopNoteDocument.members, + }, + storedAt: new Date().toISOString(), + payload: encode([ + "cultcache.interop_note.v1", + "note:ts-legacy", + "ts-legacy", + "ts wrote a note under an older schema id", + "The v1 store format is the contract.", + ["interop"], + ]), + }); + const before = decode(await readFile(file)) as unknown[][]; + assert.equal((before[2] as unknown[][])[0]![1], legacyId); + + const rewritten = await runJsonCommand("csharp-rewrite", dotnetCommand, [csharpInteropDll, "rewrite", "--file", file], cultLibRoot); + assert.equal(rewritten.documentId, "note:ts-legacy"); + const after = decode(await readFile(file)) as unknown[][]; + const stampedId = (after[2] as unknown[][])[0]![1] as string; + assert.notEqual(stampedId, legacyId, "the rewrite stamped the record with the registered id"); + const entry = (after[1] as unknown[][]).find((candidate) => candidate[0] === stampedId) as unknown[]; + assert.ok(entry, "the catalog publishes the id the record now carries"); + assert.ok((entry[5] as string[]).includes(legacyId), "the registered entry still lists the older id"); + + const readers = [ + { name: "csharp", read: async () => runJsonCommand("csharp-read", dotnetCommand, [csharpInteropDll, "read", "--file", file], cultLibRoot) }, + { name: "ts", read: async () => readTsInteropStore(file) }, + { name: "rust", read: async () => runJsonCommand("rust-read", rustInteropBinary, ["read", "--file", file], cultcacheRsRoot) }, + { + name: "python", + read: async () => + runJsonCommand("python-read", pythonCommand, ["-m", "cultcache_py.interop", "read", "--file", file], cultcachePyRoot, { + PYTHONPATH: cultcachePySrc, + }), + }, + ]; + for (const reader of readers) { + const read = await reader.read(); + assert.equal(read.documentId, "note:ts-legacy", `${reader.name} opened the rewritten store`); + assert.equal(read.body, "The v1 store format is the contract."); + } +}); + test("CultCache element ids cross C#, TypeScript, Python and Rust as ordinary members", async () => { await buildInteropPeers(); const tempDir = await mkdtemp(join(tmpdir(), "cultcache-deck-")); diff --git a/tests/GameCult.Caching.InteropPeer/Program.cs b/tests/GameCult.Caching.InteropPeer/Program.cs index d8e6cc6c..b8df4ff2 100644 --- a/tests/GameCult.Caching.InteropPeer/Program.cs +++ b/tests/GameCult.Caching.InteropPeer/Program.cs @@ -16,7 +16,7 @@ static async Task ProgramMainAsync(string[] args) { if (args.Length == 0) { - throw new InvalidOperationException("Expected mode: write | read | write-routed "); + throw new InvalidOperationException("Expected mode: write | read | rewrite | write-routed "); } var mode = args[0]; @@ -38,6 +38,9 @@ static async Task ProgramMainAsync(string[] args) case "read": await ReadAsync(file); return 0; + case "rewrite": + await RewriteAsync(file); + return 0; case "write-deck": await WriteDeckAsync(file); return 0; @@ -83,6 +86,17 @@ static async Task ReadAsync(string file) WriteJsonLine(note); } +// Puts the stored note back: the cache stamps it with the registered schema id, whatever id it was stored under. +static async Task RewriteAsync(string file) +{ + var cache = BuildCache(file); + await cache.PullAllBackingStoresAsync(); + var note = cache.AllEntries.OfType().Single(); + await cache.UpsertAsync(note, new CultRecordHandle(new CultRecordKey(note.DocumentId))); + cache.FlushAllBackingStores(); + WriteJsonLine(note); +} + // A record with an object list: the cache mints each mark's element id, and every runtime reads it as an ordinary member. static async Task WriteDeckAsync(string file) { @@ -186,7 +200,7 @@ static void WriteJsonLine(CultCacheInteropNote note) })); } -[CultDocument("cultcache.interop-note", "cultcache.interop_note.v1")] +[CultDocument("cultcache.interop-note", "cultcache.interop_note.v1", CompatibleSchemaIds = new[] { "cultcache.interop-note.legacy-id" })] [MessagePackObject] public sealed class CultCacheInteropNote {