Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

Merge pull request #12550 from atomantic/claim/issue-12503

[._.]/c507120182b3
diff --cc server/services/catalogCanonProjection.js
index 7e89f14670,8bcc995f9e..50eb05efc1
--- a/server/services/catalogCanonProjection.js
+++ b/server/services/catalogCanonProjection.js
@@@ -157,13 -171,14 +157,15 @@@ export async function projectToCanon(in
* objects }` subset) read straight after the write.
* guardToken — when set (a projectToCanon-originated write), the entry whose
* ingredientId equals it is skipped (loop break).
+ * guardIdentityIds — aliases captured by that originating operation, also skipped.
*
* LWW: writes the catalog row only when the embedded entry's `updatedAt` is
- * newer-or-equal to the stored row's. Best-effort per entry (logged on
- * failure); returns `{ written, skipped }`.
+ * newer-or-equal to the stored row's, re-checked under the row lock at write
+ * time. Best-effort per entry (logged on failure); a write refused because the
+ * row changed after the batched lookup counts as skipped. Returns
+ * `{ written, skipped }`.
*/
-export async function projectToCatalog(universeId, canonArrays, { guardToken = null } = {}) {
+export async function projectToCatalog(universeId, canonArrays, { guardToken = null, guardIdentityIds = [] } = {}) {
const stats = { written: 0, skipped: 0 };
if (!canonArrays || typeof canonArrays !== 'object') return stats;
diff --cc server/services/catalogCanonProjection.test.js
index 85fe5f328f,2432023e76..2cc4c2b31d
--- a/server/services/catalogCanonProjection.test.js
+++ b/server/services/catalogCanonProjection.test.js
@@@ -18,10 -18,10 +18,10 @@@
*/
import { describe, it, expect, afterAll, vi } from 'vitest';
- import { checkHealth, ensureSchema, close } from '../lib/db.js';
+ import { checkHealth, ensureSchema, close, query } from '../lib/db.js';
import { requireDbOrSkip } from '../lib/dbTestGate.js';
import * as catalogDB from './catalogDB.js';
-import { projectToCanon, projectToCatalog, _inFlightSize } from './catalogCanonProjection.js';
+import { projectToCanon, projectToCatalog } from './catalogCanonProjection.js';
let dbReady = false;
let skipReason = '';
@@@ -171,6 -183,91 +183,90 @@@ describe.skipIf(!runDb)('catalogCanonPr
expect(updSpy.mock.calls.length).toBe(writesAfterPrimary);
// Canon side written exactly once.
expect(updateUniverse).toHaveBeenCalledTimes(1);
- expect(_inFlightSize()).toBe(0);
updSpy.mockRestore();
+ condSpy.mockRestore();
+ });
+
+ it('a catalog edit committed after the batched lookup survives a pending projection (#12503)', async () => {
+ const uId = `u-proj-${Date.now()}-f`;
+ const a = await makeLinkedCharacter(uId, { name: 'Race A' });
+ const b = await makeLinkedCharacter(uId, { name: 'Race B' });
+ await pinClock(a.id);
+ await pinClock(b.id);
+ const realWrite = catalogDB.updateIngredientIfFresh;
+ // While A's write is pending, an explicit catalog PATCH commits B.
+ const spy = vi.spyOn(catalogDB, 'updateIngredientIfFresh').mockImplementation(async (id, ...rest) => {
+ if (id === a.id) await catalogDB.updateIngredient(b.id, { name: 'New catalog edit' });
+ return realWrite(id, ...rest);
+ });
+ try {
+ const stats = await projectToCatalog(uId, {
+ characters: [canonEntry(a.id, 'Canon edit A', AFTER_PIN), canonEntry(b.id, 'Older canon edit', AFTER_PIN)],
+ });
+ expect(stats).toEqual({ written: 1, skipped: 1 });
+ } finally {
+ spy.mockRestore();
+ }
+ expect((await catalogDB.getIngredient(a.id)).name).toBe('Canon edit A');
+ expect((await catalogDB.getIngredient(b.id)).name).toBe('New catalog edit');
+ const { items } = await catalogDB.listIngredientRevisions(b.id);
+ expect(items.filter((r) => r.actor === 'canon-projection')).toEqual([]);
+ });
+
+ it('two universe saves of one identity honor the same locked check', async () => {
+ const ing = await makeLinkedCharacter(`u-proj-${Date.now()}-g`, { name: 'Shared' });
+ await pinClock(ing.id);
+ const realLookup = catalogDB.getIngredientTimestamps;
+ let newerStats;
+ // The older save takes its snapshot, then the newer save commits first.
+ const spy = vi.spyOn(catalogDB, 'getIngredientTimestamps').mockImplementationOnce(async (...args) => {
+ const snapshot = await realLookup(...args);
+ newerStats = await projectToCatalog('u-newer', { characters: [canonEntry(ing.id, 'Newer universe save', LATER_AFTER_PIN)] });
+ return snapshot;
+ });
+ try {
+ const olderStats = await projectToCatalog('u-older', { characters: [canonEntry(ing.id, 'Older universe save', AFTER_PIN)] });
+ expect(olderStats).toEqual({ written: 0, skipped: 1 });
+ } finally {
+ spy.mockRestore();
+ }
+ expect(newerStats).toEqual({ written: 1, skipped: 0 });
+ expect((await catalogDB.getIngredient(ing.id)).name).toBe('Newer universe save');
+ });
+
+ it('a newer duplicate in the same save supersedes the write made earlier in that save (#4006)', async () => {
+ const uId = `u-proj-${Date.now()}-i`;
+ const ing = await makeLinkedCharacter(uId, { name: 'Duplicate' });
+ await pinClock(ing.id);
+ const stats = await projectToCatalog(uId, {
+ characters: [canonEntry(ing.id, 'First copy', AFTER_PIN)],
+ places: [canonEntry(ing.id, 'Newer copy', LATER_AFTER_PIN)],
+ });
+ expect(stats).toEqual({ written: 2, skipped: 0 });
+ expect((await catalogDB.getIngredient(ing.id)).name).toBe('Newer copy');
+ });
+
+ it('an equal-clock entry still writes; a row deleted after the lookup is skipped', async () => {
+ const uId = `u-proj-${Date.now()}-h`;
+ const equal = await makeLinkedCharacter(uId, { name: 'Equal' });
+ const gone = await makeLinkedCharacter(uId, { name: 'Gone' });
+ await pinClock(equal.id);
+ await pinClock(gone.id);
+ const realLookup = catalogDB.getIngredientTimestamps;
+ const spy = vi.spyOn(catalogDB, 'getIngredientTimestamps').mockImplementationOnce(async (...args) => {
+ const snapshot = await realLookup(...args);
+ await catalogDB.deleteIngredient(gone.id);
+ return snapshot;
+ });
+ try {
+ const stats = await projectToCatalog(uId, {
+ characters: [canonEntry(equal.id, 'Equal clock edit', PINNED_AT), canonEntry(gone.id, 'Revived?', AFTER_PIN)],
+ });
+ expect(stats).toEqual({ written: 1, skipped: 1 });
+ } finally {
+ spy.mockRestore();
+ }
+ expect((await catalogDB.getIngredient(equal.id)).name).toBe('Equal clock edit');
+ expect(await catalogDB.getIngredient(gone.id)).toBeNull();
});
});