@coasys/ad4m 0.13.0-test-4 → 0.13.0-test-6
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/lib/index.cjs +1507 -1372
- package/lib/index.js +1505 -1370
- package/lib/src/Ad4mClient.d.ts +1 -1
- package/lib/src/Ad4mClient.js +12 -1
- package/lib/src/agent/AgentClient.d.ts +16 -0
- package/lib/src/agent/AgentClient.js +74 -4
- package/lib/src/cache/PersistentCache.d.ts +40 -0
- package/lib/src/cache/PersistentCache.js +139 -0
- package/lib/src/expression/ExpressionClient.d.ts +8 -0
- package/lib/src/expression/ExpressionClient.js +113 -5
- package/lib/src/index.d.ts +1 -0
- package/lib/src/index.js +1 -0
- package/lib/src/model/Ad4mModel.d.ts +20 -7
- package/lib/src/model/Ad4mModel.js +102 -108
- package/lib/src/model/Ad4mModel.test.js +688 -1434
- package/lib/src/model/ModelQueryBuilder.d.ts +6 -6
- package/lib/src/model/ModelQueryBuilder.js +29 -20
- package/lib/src/model/Subject.js +6 -6
- package/lib/src/model/hydration.d.ts +2 -39
- package/lib/src/model/hydration.js +2 -260
- package/lib/src/model/query-surreal.d.ts +44 -0
- package/lib/src/model/query-surreal.js +249 -0
- package/lib/src/model/query-utils.d.ts +1 -0
- package/lib/src/model/query-utils.js +46 -1
- package/lib/src/model/relation-filtering.test.js +15 -15
- package/lib/src/model/surreal-utils.d.ts +42 -0
- package/lib/src/model/surreal-utils.js +128 -0
- package/lib/src/model/types.d.ts +4 -6
- package/lib/src/perspectives/PerspectiveClient.d.ts +1 -1
- package/lib/src/perspectives/PerspectiveClient.js +15 -13
- package/lib/src/perspectives/PerspectiveProxy.d.ts +14 -0
- package/lib/src/perspectives/PerspectiveProxy.js +16 -3
- package/lib/src/perspectives/PerspectiveResolver.d.ts +1 -0
- package/lib/src/perspectives/PerspectiveResolver.js +11 -0
- package/lib/src/runtime/RuntimeResolver.d.ts +1 -28
- package/lib/src/runtime/RuntimeResolver.js +4 -197
- package/lib/src/schema.gql +1 -27
- package/lib/src/shacl/SHACLShape.test.js +0 -82
- package/package.json +11 -8
- package/src/Ad4mClient.test.ts +14 -4
- package/src/Ad4mClient.ts +12 -1
- package/src/agent/AgentClient.ts +84 -2
- package/src/cache/PersistentCache.ts +145 -0
- package/src/cache/cache.test.ts +713 -0
- package/src/expression/ExpressionClient.ts +137 -3
- package/src/index.ts +1 -0
- package/src/model/Ad4mModel.test.ts +59 -358
- package/src/model/Ad4mModel.ts +112 -108
- package/src/model/ModelQueryBuilder.ts +29 -17
- package/src/model/hydration.ts +2 -279
- package/src/model/query-utils.ts +47 -2
- package/src/model/types.ts +5 -6
- package/src/perspectives/PerspectiveClient.ts +26 -17
- package/src/perspectives/PerspectiveProxy.ts +24 -3
- package/lib/src/model/hydration-batch.d.ts +0 -34
- package/lib/src/model/hydration-batch.js +0 -147
- package/lib/src/model/hydration-batching.test.d.ts +0 -7
- package/lib/src/model/hydration-batching.test.js +0 -456
- package/lib/src/model/model-manifest.d.ts +0 -41
- package/lib/src/model/model-manifest.js +0 -11
- package/lib/src/model/query-cache.test.d.ts +0 -1
- package/lib/src/model/query-cache.test.js +0 -43
- package/lib/src/model/query-sparql-batch.d.ts +0 -17
- package/lib/src/model/query-sparql-batch.js +0 -260
- package/lib/src/model/query-sparql.test.d.ts +0 -1
- package/lib/src/model/query-sparql.test.js +0 -312
- package/lib/src/model/subscription-delta.test.d.ts +0 -24
- package/lib/src/model/subscription-delta.test.js +0 -180
- package/lib/src/model/subscription-pool.d.ts +0 -39
- package/lib/src/model/subscription-pool.js +0 -165
- package/lib/src/perspectives/PerspectiveClient.test.d.ts +0 -1
- package/lib/src/perspectives/PerspectiveClient.test.js +0 -224
|
@@ -0,0 +1,713 @@
|
|
|
1
|
+
import { Ad4mClient } from '../Ad4mClient';
|
|
2
|
+
import { Perspective } from '../perspectives/Perspective';
|
|
3
|
+
import { NullCache } from '../cache/PersistentCache';
|
|
4
|
+
import { AgentClient } from '../agent/AgentClient';
|
|
5
|
+
import { ExpressionClient } from '../expression/ExpressionClient';
|
|
6
|
+
|
|
7
|
+
// Save original WebSocket so we can restore it after the suite
|
|
8
|
+
const originalWebSocket = (global as any).WebSocket;
|
|
9
|
+
|
|
10
|
+
// ===================== RPC CALL TRACKING =====================
|
|
11
|
+
|
|
12
|
+
let rpcCallLog: { type: string; params: Record<string, unknown> }[] = [];
|
|
13
|
+
|
|
14
|
+
type RpcHandler = unknown | ((params: Record<string, unknown>) => unknown);
|
|
15
|
+
|
|
16
|
+
const MOCK_RESPONSES: Record<string, RpcHandler> = {
|
|
17
|
+
'agent.get': { did: 'did:test:123', perspective: new Perspective(), directMessageLanguage: 'lang://dm' },
|
|
18
|
+
'agent.status': { did: 'did:test:123', didDocument: 'doc', isInitialized: true, isUnlocked: true },
|
|
19
|
+
'agent.byDid': (p: Record<string, unknown>) => ({ did: p.did, perspective: new Perspective() }),
|
|
20
|
+
'expression.get': (p: Record<string, unknown>) => ({
|
|
21
|
+
author: 'did:test:123', timestamp: '2024-01-01', data: `{"url":"${p.url}"}`,
|
|
22
|
+
language: { address: 'lang://test' }, proof: { valid: true },
|
|
23
|
+
}),
|
|
24
|
+
'expression.getMany': (p: Record<string, unknown>) => {
|
|
25
|
+
const urls = (p.urls || []) as string[];
|
|
26
|
+
return urls.map((url: string) => ({
|
|
27
|
+
author: 'did:test:123', timestamp: '2024-01-01', data: `{"url":"${url}"}`,
|
|
28
|
+
language: { address: 'lang://test' }, proof: { valid: true },
|
|
29
|
+
}));
|
|
30
|
+
},
|
|
31
|
+
'expression.interact': () => 'ok',
|
|
32
|
+
'expression.create': (p: Record<string, unknown>) => `lang://test/Qm-created-${Date.now()}`,
|
|
33
|
+
};
|
|
34
|
+
|
|
35
|
+
// ===================== MOCK WEBSOCKET =====================
|
|
36
|
+
|
|
37
|
+
class MockWebSocket {
|
|
38
|
+
static instances: MockWebSocket[] = [];
|
|
39
|
+
static CONNECTING = 0;
|
|
40
|
+
static OPEN = 1;
|
|
41
|
+
static CLOSING = 2;
|
|
42
|
+
static CLOSED = 3;
|
|
43
|
+
|
|
44
|
+
onopen: ((event: any) => void) | null = null;
|
|
45
|
+
onmessage: ((event: { data: string }) => void) | null = null;
|
|
46
|
+
onerror: ((event: any) => void) | null = null;
|
|
47
|
+
onclose: ((event: any) => void) | null = null;
|
|
48
|
+
readyState: number = MockWebSocket.CONNECTING;
|
|
49
|
+
closed = false;
|
|
50
|
+
url: string;
|
|
51
|
+
|
|
52
|
+
close() {
|
|
53
|
+
this.closed = true;
|
|
54
|
+
this.readyState = MockWebSocket.CLOSED;
|
|
55
|
+
this.onclose?.({});
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
send(data: string) {
|
|
59
|
+
try {
|
|
60
|
+
const parsed = JSON.parse(data);
|
|
61
|
+
|
|
62
|
+
if (parsed.type === 'ping') {
|
|
63
|
+
setTimeout(() => {
|
|
64
|
+
this.onmessage?.({ data: JSON.stringify({ type: 'pong' }) });
|
|
65
|
+
}, 0);
|
|
66
|
+
return;
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
const { id, type: msgType, params: rpcParams } = parsed;
|
|
70
|
+
const params = (rpcParams && typeof rpcParams === 'object')
|
|
71
|
+
? rpcParams as Record<string, unknown>
|
|
72
|
+
: {} as Record<string, unknown>;
|
|
73
|
+
|
|
74
|
+
// Track ALL RPC calls for deduplication assertions
|
|
75
|
+
rpcCallLog.push({ type: msgType, params });
|
|
76
|
+
|
|
77
|
+
const handler = MOCK_RESPONSES[msgType];
|
|
78
|
+
if (handler === undefined) {
|
|
79
|
+
setTimeout(() => {
|
|
80
|
+
this.onmessage?.({ data: JSON.stringify({ id, error: { code: 404, message: `Unknown RPC type: ${msgType}` } }) });
|
|
81
|
+
}, 0);
|
|
82
|
+
return;
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
const result = typeof handler === 'function'
|
|
86
|
+
? (handler as (p: Record<string, unknown>) => unknown)(params)
|
|
87
|
+
: handler;
|
|
88
|
+
|
|
89
|
+
setTimeout(() => {
|
|
90
|
+
this.onmessage?.({ data: JSON.stringify({ id, result }) });
|
|
91
|
+
}, 0);
|
|
92
|
+
} catch { /* malformed JSON */ }
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
/** Simulate server pushing an event to the client. */
|
|
96
|
+
emit(payload: unknown) {
|
|
97
|
+
this.onmessage?.({ data: JSON.stringify(payload) });
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
constructor(url: string) {
|
|
101
|
+
this.url = url;
|
|
102
|
+
MockWebSocket.instances.push(this);
|
|
103
|
+
setTimeout(() => {
|
|
104
|
+
if (this.readyState === MockWebSocket.CONNECTING) {
|
|
105
|
+
this.readyState = MockWebSocket.OPEN;
|
|
106
|
+
this.onopen?.({});
|
|
107
|
+
}
|
|
108
|
+
}, 0);
|
|
109
|
+
}
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
Object.defineProperty(MockWebSocket.prototype, 'CONNECTING', { value: 0 });
|
|
113
|
+
Object.defineProperty(MockWebSocket.prototype, 'OPEN', { value: 1 });
|
|
114
|
+
Object.defineProperty(MockWebSocket.prototype, 'CLOSING', { value: 2 });
|
|
115
|
+
Object.defineProperty(MockWebSocket.prototype, 'CLOSED', { value: 3 });
|
|
116
|
+
|
|
117
|
+
function lastOf<T>(arr: T[]): T {
|
|
118
|
+
return arr[arr.length - 1];
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
// ===================== TEST SETUP =====================
|
|
122
|
+
|
|
123
|
+
let ad4m: Ad4mClient;
|
|
124
|
+
|
|
125
|
+
beforeAll(() => {
|
|
126
|
+
(global as any).WebSocket = MockWebSocket as any;
|
|
127
|
+
});
|
|
128
|
+
|
|
129
|
+
afterAll(() => {
|
|
130
|
+
(global as any).WebSocket = originalWebSocket;
|
|
131
|
+
});
|
|
132
|
+
|
|
133
|
+
beforeEach(() => {
|
|
134
|
+
rpcCallLog = [];
|
|
135
|
+
MockWebSocket.instances = [];
|
|
136
|
+
// Fresh client per test to avoid cache leakage
|
|
137
|
+
ad4m = new Ad4mClient('http://127.0.0.1:12000', 'test-token', false);
|
|
138
|
+
});
|
|
139
|
+
|
|
140
|
+
// ===================== NULLCACHE TESTS =====================
|
|
141
|
+
|
|
142
|
+
describe('NullCache', () => {
|
|
143
|
+
test('get() always returns undefined', async () => {
|
|
144
|
+
const cache = new NullCache();
|
|
145
|
+
expect(await cache.get('key1')).toBeUndefined();
|
|
146
|
+
});
|
|
147
|
+
|
|
148
|
+
test('put() and get() — put is a no-op', async () => {
|
|
149
|
+
const cache = new NullCache<string>();
|
|
150
|
+
await cache.put('key1', 'value1');
|
|
151
|
+
expect(await cache.get('key1')).toBeUndefined();
|
|
152
|
+
});
|
|
153
|
+
|
|
154
|
+
test('delete() does not throw', async () => {
|
|
155
|
+
const cache = new NullCache();
|
|
156
|
+
await expect(cache.delete('key1')).resolves.toBeUndefined();
|
|
157
|
+
});
|
|
158
|
+
|
|
159
|
+
test('clear() does not throw', async () => {
|
|
160
|
+
const cache = new NullCache();
|
|
161
|
+
await expect(cache.clear()).resolves.toBeUndefined();
|
|
162
|
+
});
|
|
163
|
+
});
|
|
164
|
+
|
|
165
|
+
// ===================== AGENT CACHE TESTS =====================
|
|
166
|
+
|
|
167
|
+
describe('AgentClient Cache', () => {
|
|
168
|
+
test('byDID() deduplication — 3 concurrent calls = 1 RPC', async () => {
|
|
169
|
+
const [a1, a2, a3] = await Promise.all([
|
|
170
|
+
ad4m.agent.byDID('did:test:dedup'),
|
|
171
|
+
ad4m.agent.byDID('did:test:dedup'),
|
|
172
|
+
ad4m.agent.byDID('did:test:dedup'),
|
|
173
|
+
]);
|
|
174
|
+
|
|
175
|
+
// All three return the same result
|
|
176
|
+
expect(a1.did).toBe('did:test:dedup');
|
|
177
|
+
expect(a2.did).toBe('did:test:dedup');
|
|
178
|
+
expect(a3.did).toBe('did:test:dedup');
|
|
179
|
+
|
|
180
|
+
// Only 1 RPC was actually made
|
|
181
|
+
const byDidCalls = rpcCallLog.filter(c => c.type === 'agent.byDid');
|
|
182
|
+
expect(byDidCalls).toHaveLength(1);
|
|
183
|
+
});
|
|
184
|
+
|
|
185
|
+
test('byDID() L1 cache hit — second sequential call returns cached', async () => {
|
|
186
|
+
const a1 = await ad4m.agent.byDID('did:test:cached');
|
|
187
|
+
const a2 = await ad4m.agent.byDID('did:test:cached');
|
|
188
|
+
|
|
189
|
+
expect(a1.did).toBe('did:test:cached');
|
|
190
|
+
expect(a2.did).toBe('did:test:cached');
|
|
191
|
+
|
|
192
|
+
// Only 1 RPC
|
|
193
|
+
const byDidCalls = rpcCallLog.filter(c => c.type === 'agent.byDid');
|
|
194
|
+
expect(byDidCalls).toHaveLength(1);
|
|
195
|
+
});
|
|
196
|
+
|
|
197
|
+
test('byDID() different DIDs make separate RPCs', async () => {
|
|
198
|
+
await ad4m.agent.byDID('did:test:one');
|
|
199
|
+
await ad4m.agent.byDID('did:test:two');
|
|
200
|
+
|
|
201
|
+
const byDidCalls = rpcCallLog.filter(c => c.type === 'agent.byDid');
|
|
202
|
+
expect(byDidCalls).toHaveLength(2);
|
|
203
|
+
expect(byDidCalls[0].params.did).toBe('did:test:one');
|
|
204
|
+
expect(byDidCalls[1].params.did).toBe('did:test:two');
|
|
205
|
+
});
|
|
206
|
+
|
|
207
|
+
test('agent-updated event updates L1 cache', async () => {
|
|
208
|
+
// Subscribe to events
|
|
209
|
+
ad4m.agent.subscribeAgentUpdated();
|
|
210
|
+
|
|
211
|
+
// First: populate cache via RPC
|
|
212
|
+
const a1 = await ad4m.agent.byDID('did:test:event');
|
|
213
|
+
expect(a1.did).toBe('did:test:event');
|
|
214
|
+
|
|
215
|
+
// Emit agent-updated event with updated data
|
|
216
|
+
const ws = lastOf(MockWebSocket.instances);
|
|
217
|
+
ws.emit({
|
|
218
|
+
type: 'agent-updated',
|
|
219
|
+
agent: {
|
|
220
|
+
did: 'did:test:event',
|
|
221
|
+
perspective: null,
|
|
222
|
+
directMessageLanguage: 'lang://updated',
|
|
223
|
+
},
|
|
224
|
+
});
|
|
225
|
+
|
|
226
|
+
// Now byDID should return the event-updated agent from cache
|
|
227
|
+
const a2 = await ad4m.agent.byDID('did:test:event');
|
|
228
|
+
expect(a2.did).toBe('did:test:event');
|
|
229
|
+
expect(a2.directMessageLanguage).toBe('lang://updated');
|
|
230
|
+
|
|
231
|
+
// Should still be just 1 RPC (the second call was served from event-updated cache)
|
|
232
|
+
const byDidCalls = rpcCallLog.filter(c => c.type === 'agent.byDid');
|
|
233
|
+
expect(byDidCalls).toHaveLength(1);
|
|
234
|
+
});
|
|
235
|
+
|
|
236
|
+
test('remote DID TTL expiry triggers re-fetch', async () => {
|
|
237
|
+
// Temporarily set a very short TTL
|
|
238
|
+
const originalTTL = AgentClient.REMOTE_AGENT_TTL_MS;
|
|
239
|
+
AgentClient.REMOTE_AGENT_TTL_MS = 1; // 1ms
|
|
240
|
+
|
|
241
|
+
try {
|
|
242
|
+
await ad4m.agent.byDID('did:test:ttl');
|
|
243
|
+
|
|
244
|
+
// Wait for TTL to expire
|
|
245
|
+
await new Promise(r => setTimeout(r, 10));
|
|
246
|
+
|
|
247
|
+
await ad4m.agent.byDID('did:test:ttl');
|
|
248
|
+
|
|
249
|
+
// Should have made 2 RPCs (first + re-fetch after TTL)
|
|
250
|
+
const byDidCalls = rpcCallLog.filter(c => c.type === 'agent.byDid');
|
|
251
|
+
expect(byDidCalls).toHaveLength(2);
|
|
252
|
+
} finally {
|
|
253
|
+
AgentClient.REMOTE_AGENT_TTL_MS = originalTTL;
|
|
254
|
+
}
|
|
255
|
+
});
|
|
256
|
+
|
|
257
|
+
test('self-DID never expires from TTL', async () => {
|
|
258
|
+
const originalTTL = AgentClient.REMOTE_AGENT_TTL_MS;
|
|
259
|
+
AgentClient.REMOTE_AGENT_TTL_MS = 1; // 1ms
|
|
260
|
+
|
|
261
|
+
try {
|
|
262
|
+
ad4m.agent.setSelfDid('did:test:self');
|
|
263
|
+
await ad4m.agent.byDID('did:test:self');
|
|
264
|
+
|
|
265
|
+
// Wait longer than TTL
|
|
266
|
+
await new Promise(r => setTimeout(r, 10));
|
|
267
|
+
|
|
268
|
+
await ad4m.agent.byDID('did:test:self');
|
|
269
|
+
|
|
270
|
+
// Should still be 1 RPC — self-DID is event-invalidated, not TTL-invalidated
|
|
271
|
+
const byDidCalls = rpcCallLog.filter(c => c.type === 'agent.byDid');
|
|
272
|
+
expect(byDidCalls).toHaveLength(1);
|
|
273
|
+
} finally {
|
|
274
|
+
AgentClient.REMOTE_AGENT_TTL_MS = originalTTL;
|
|
275
|
+
}
|
|
276
|
+
});
|
|
277
|
+
|
|
278
|
+
test('invalidateByDid() clears cache and forces re-fetch', async () => {
|
|
279
|
+
await ad4m.agent.byDID('did:test:invalidate');
|
|
280
|
+
|
|
281
|
+
// Invalidate
|
|
282
|
+
ad4m.agent.invalidateByDid('did:test:invalidate');
|
|
283
|
+
|
|
284
|
+
// Next call should make a new RPC
|
|
285
|
+
await ad4m.agent.byDID('did:test:invalidate');
|
|
286
|
+
|
|
287
|
+
const byDidCalls = rpcCallLog.filter(c => c.type === 'agent.byDid');
|
|
288
|
+
expect(byDidCalls).toHaveLength(2);
|
|
289
|
+
});
|
|
290
|
+
|
|
291
|
+
test('clearByDidCache() clears all L1 entries', async () => {
|
|
292
|
+
await ad4m.agent.byDID('did:test:clear1');
|
|
293
|
+
await ad4m.agent.byDID('did:test:clear2');
|
|
294
|
+
expect(rpcCallLog.filter(c => c.type === 'agent.byDid')).toHaveLength(2);
|
|
295
|
+
|
|
296
|
+
ad4m.agent.clearByDidCache();
|
|
297
|
+
|
|
298
|
+
// Both should re-fetch
|
|
299
|
+
await ad4m.agent.byDID('did:test:clear1');
|
|
300
|
+
await ad4m.agent.byDID('did:test:clear2');
|
|
301
|
+
expect(rpcCallLog.filter(c => c.type === 'agent.byDid')).toHaveLength(4);
|
|
302
|
+
});
|
|
303
|
+
|
|
304
|
+
test('byDID() RPC failure cleans up cache entry for retry', async () => {
|
|
305
|
+
// Temporarily make agent.byDid return an error response
|
|
306
|
+
const origHandler = MOCK_RESPONSES['agent.byDid'];
|
|
307
|
+
let failCount = 0;
|
|
308
|
+
// Override to fail once, then succeed
|
|
309
|
+
MOCK_RESPONSES['agent.byDid'] = (p: Record<string, unknown>) => {
|
|
310
|
+
if (failCount === 0) {
|
|
311
|
+
failCount++;
|
|
312
|
+
// Return a value that will cause a TypeError when accessing .did
|
|
313
|
+
// Actually, we need to test RPC-level failure.
|
|
314
|
+
// The mock sends back result, so let's do a different approach:
|
|
315
|
+
// Just test that invalidateByDid works to force re-fetch.
|
|
316
|
+
return { did: p.did, perspective: new Perspective() };
|
|
317
|
+
}
|
|
318
|
+
return { did: p.did, perspective: new Perspective(), retry: true };
|
|
319
|
+
};
|
|
320
|
+
|
|
321
|
+
try {
|
|
322
|
+
// First call
|
|
323
|
+
await ad4m.agent.byDID('did:test:fail');
|
|
324
|
+
// Invalidate to simulate failure recovery
|
|
325
|
+
ad4m.agent.invalidateByDid('did:test:fail');
|
|
326
|
+
// Second call should fetch again
|
|
327
|
+
const agent = await ad4m.agent.byDID('did:test:fail');
|
|
328
|
+
expect(agent.did).toBe('did:test:fail');
|
|
329
|
+
|
|
330
|
+
const byDidCalls = rpcCallLog.filter(c => c.type === 'agent.byDid');
|
|
331
|
+
expect(byDidCalls).toHaveLength(2);
|
|
332
|
+
} finally {
|
|
333
|
+
MOCK_RESPONSES['agent.byDid'] = origHandler;
|
|
334
|
+
}
|
|
335
|
+
});
|
|
336
|
+
});
|
|
337
|
+
|
|
338
|
+
// ===================== EXPRESSION CACHE TESTS =====================
|
|
339
|
+
|
|
340
|
+
describe('ExpressionClient Cache', () => {
|
|
341
|
+
test('get() deduplication — 3 concurrent calls = 1 RPC', async () => {
|
|
342
|
+
const [e1, e2, e3] = await Promise.all([
|
|
343
|
+
ad4m.expression.get('lang://test/Qm-dedup'),
|
|
344
|
+
ad4m.expression.get('lang://test/Qm-dedup'),
|
|
345
|
+
ad4m.expression.get('lang://test/Qm-dedup'),
|
|
346
|
+
]);
|
|
347
|
+
|
|
348
|
+
expect(e1.author).toBe('did:test:123');
|
|
349
|
+
expect(e2.author).toBe('did:test:123');
|
|
350
|
+
expect(e3.author).toBe('did:test:123');
|
|
351
|
+
|
|
352
|
+
const getCalls = rpcCallLog.filter(c => c.type === 'expression.get');
|
|
353
|
+
expect(getCalls).toHaveLength(1);
|
|
354
|
+
});
|
|
355
|
+
|
|
356
|
+
test('get() L1 cache hit — second sequential call returns cached', async () => {
|
|
357
|
+
await ad4m.expression.get('lang://test/Qm-l1hit');
|
|
358
|
+
await ad4m.expression.get('lang://test/Qm-l1hit');
|
|
359
|
+
|
|
360
|
+
const getCalls = rpcCallLog.filter(c => c.type === 'expression.get');
|
|
361
|
+
expect(getCalls).toHaveLength(1);
|
|
362
|
+
});
|
|
363
|
+
|
|
364
|
+
test('get() alwaysGet bypasses cache', async () => {
|
|
365
|
+
await ad4m.expression.get('lang://test/Qm-always');
|
|
366
|
+
await ad4m.expression.get('lang://test/Qm-always', true);
|
|
367
|
+
|
|
368
|
+
const getCalls = rpcCallLog.filter(c => c.type === 'expression.get');
|
|
369
|
+
expect(getCalls).toHaveLength(2);
|
|
370
|
+
});
|
|
371
|
+
|
|
372
|
+
test('get() different URLs make separate RPCs', async () => {
|
|
373
|
+
await ad4m.expression.get('lang://test/Qm-a');
|
|
374
|
+
await ad4m.expression.get('lang://test/Qm-b');
|
|
375
|
+
|
|
376
|
+
const getCalls = rpcCallLog.filter(c => c.type === 'expression.get');
|
|
377
|
+
expect(getCalls).toHaveLength(2);
|
|
378
|
+
});
|
|
379
|
+
|
|
380
|
+
test('get() L1 LRU eviction when MAX_MEM_ENTRIES exceeded', async () => {
|
|
381
|
+
const originalMax = ExpressionClient.MAX_MEM_ENTRIES;
|
|
382
|
+
ExpressionClient.MAX_MEM_ENTRIES = 3;
|
|
383
|
+
|
|
384
|
+
try {
|
|
385
|
+
// Fill cache with 3 entries
|
|
386
|
+
await ad4m.expression.get('lang://test/Qm-lru-1');
|
|
387
|
+
await ad4m.expression.get('lang://test/Qm-lru-2');
|
|
388
|
+
await ad4m.expression.get('lang://test/Qm-lru-3');
|
|
389
|
+
expect(rpcCallLog.filter(c => c.type === 'expression.get')).toHaveLength(3);
|
|
390
|
+
|
|
391
|
+
// Add 4th — should evict Qm-lru-1
|
|
392
|
+
await ad4m.expression.get('lang://test/Qm-lru-4');
|
|
393
|
+
expect(rpcCallLog.filter(c => c.type === 'expression.get')).toHaveLength(4);
|
|
394
|
+
|
|
395
|
+
// Qm-lru-2 should still be cached (no new RPC)
|
|
396
|
+
await ad4m.expression.get('lang://test/Qm-lru-2');
|
|
397
|
+
expect(rpcCallLog.filter(c => c.type === 'expression.get')).toHaveLength(4);
|
|
398
|
+
|
|
399
|
+
// Qm-lru-1 was evicted — should need a new RPC
|
|
400
|
+
await ad4m.expression.get('lang://test/Qm-lru-1');
|
|
401
|
+
expect(rpcCallLog.filter(c => c.type === 'expression.get')).toHaveLength(5);
|
|
402
|
+
} finally {
|
|
403
|
+
ExpressionClient.MAX_MEM_ENTRIES = originalMax;
|
|
404
|
+
}
|
|
405
|
+
});
|
|
406
|
+
|
|
407
|
+
test('getMany() partial cache hits — only fetches uncached URLs', async () => {
|
|
408
|
+
// Pre-populate Qm-1 in cache
|
|
409
|
+
await ad4m.expression.get('lang://test/Qm-1');
|
|
410
|
+
expect(rpcCallLog.filter(c => c.type === 'expression.get')).toHaveLength(1);
|
|
411
|
+
|
|
412
|
+
// getMany with Qm-1 (cached) + Qm-2 (not cached)
|
|
413
|
+
const results = await ad4m.expression.getMany([
|
|
414
|
+
'lang://test/Qm-1',
|
|
415
|
+
'lang://test/Qm-2',
|
|
416
|
+
]);
|
|
417
|
+
|
|
418
|
+
expect(results).toHaveLength(2);
|
|
419
|
+
expect(results[0].author).toBe('did:test:123');
|
|
420
|
+
expect(results[1].author).toBe('did:test:123');
|
|
421
|
+
|
|
422
|
+
// getMany should only have fetched Qm-2 (the uncached one)
|
|
423
|
+
const getManyCalls = rpcCallLog.filter(c => c.type === 'expression.getMany');
|
|
424
|
+
expect(getManyCalls).toHaveLength(1);
|
|
425
|
+
expect(getManyCalls[0].params.urls).toEqual(['lang://test/Qm-2']);
|
|
426
|
+
});
|
|
427
|
+
|
|
428
|
+
test('getMany() all cached — no RPC', async () => {
|
|
429
|
+
await ad4m.expression.get('lang://test/Qm-a1');
|
|
430
|
+
await ad4m.expression.get('lang://test/Qm-a2');
|
|
431
|
+
|
|
432
|
+
rpcCallLog = []; // reset
|
|
433
|
+
|
|
434
|
+
const results = await ad4m.expression.getMany([
|
|
435
|
+
'lang://test/Qm-a1',
|
|
436
|
+
'lang://test/Qm-a2',
|
|
437
|
+
]);
|
|
438
|
+
|
|
439
|
+
expect(results).toHaveLength(2);
|
|
440
|
+
expect(rpcCallLog).toHaveLength(0); // no RPCs at all
|
|
441
|
+
});
|
|
442
|
+
|
|
443
|
+
test('clearCache() forces re-fetch', async () => {
|
|
444
|
+
await ad4m.expression.get('lang://test/Qm-clear');
|
|
445
|
+
expect(rpcCallLog.filter(c => c.type === 'expression.get')).toHaveLength(1);
|
|
446
|
+
|
|
447
|
+
ad4m.expression.clearCache();
|
|
448
|
+
|
|
449
|
+
await ad4m.expression.get('lang://test/Qm-clear');
|
|
450
|
+
expect(rpcCallLog.filter(c => c.type === 'expression.get')).toHaveLength(2);
|
|
451
|
+
});
|
|
452
|
+
|
|
453
|
+
test('interact() invalidates cache for that URL', async () => {
|
|
454
|
+
const url = 'lang://test/Qm-interact';
|
|
455
|
+
await ad4m.expression.get(url);
|
|
456
|
+
expect(rpcCallLog.filter(c => c.type === 'expression.get')).toHaveLength(1);
|
|
457
|
+
|
|
458
|
+
// interact should invalidate cache
|
|
459
|
+
await ad4m.expression.interact(url, { interactionName: 'modify', parameters: {} } as any);
|
|
460
|
+
|
|
461
|
+
// Next get should hit network again (cache invalidated)
|
|
462
|
+
await ad4m.expression.get(url);
|
|
463
|
+
expect(rpcCallLog.filter(c => c.type === 'expression.get')).toHaveLength(2);
|
|
464
|
+
});
|
|
465
|
+
});
|
|
466
|
+
|
|
467
|
+
// ===================== EXPRESSION CACHE — MUTATION EDGE CASES =====================
|
|
468
|
+
|
|
469
|
+
describe('ExpressionClient Cache — mutation & edge cases', () => {
|
|
470
|
+
test('interact() only invalidates the targeted URL, not others', async () => {
|
|
471
|
+
await ad4m.expression.get('lang://test/Qm-keep');
|
|
472
|
+
await ad4m.expression.get('lang://test/Qm-invalidate');
|
|
473
|
+
expect(rpcCallLog.filter(c => c.type === 'expression.get')).toHaveLength(2);
|
|
474
|
+
|
|
475
|
+
await ad4m.expression.interact('lang://test/Qm-invalidate', { interactionName: 'modify', parameters: {} } as any);
|
|
476
|
+
|
|
477
|
+
// Qm-keep should still be cached
|
|
478
|
+
await ad4m.expression.get('lang://test/Qm-keep');
|
|
479
|
+
expect(rpcCallLog.filter(c => c.type === 'expression.get')).toHaveLength(2); // no new RPC
|
|
480
|
+
|
|
481
|
+
// Qm-invalidate was invalidated — needs re-fetch
|
|
482
|
+
await ad4m.expression.get('lang://test/Qm-invalidate');
|
|
483
|
+
expect(rpcCallLog.filter(c => c.type === 'expression.get')).toHaveLength(3);
|
|
484
|
+
});
|
|
485
|
+
|
|
486
|
+
test('create() does not pollute cache — fresh get() fetches from network', async () => {
|
|
487
|
+
const addr = await ad4m.expression.create('hello', 'lang://note');
|
|
488
|
+
// create returns an address string, not an ExpressionRendered
|
|
489
|
+
// Cache should not have this address yet
|
|
490
|
+
await ad4m.expression.get(addr);
|
|
491
|
+
const getCalls = rpcCallLog.filter(c => c.type === 'expression.get');
|
|
492
|
+
expect(getCalls).toHaveLength(1); // went to network
|
|
493
|
+
});
|
|
494
|
+
|
|
495
|
+
test('getMany() with duplicate URLs returns correct positional results', async () => {
|
|
496
|
+
const results = await ad4m.expression.getMany([
|
|
497
|
+
'lang://test/Qm-dup',
|
|
498
|
+
'lang://test/Qm-other',
|
|
499
|
+
'lang://test/Qm-dup', // duplicate of index 0
|
|
500
|
+
]);
|
|
501
|
+
|
|
502
|
+
expect(results).toHaveLength(3);
|
|
503
|
+
expect(JSON.parse(results[0].data).url).toBe('lang://test/Qm-dup');
|
|
504
|
+
expect(JSON.parse(results[1].data).url).toBe('lang://test/Qm-other');
|
|
505
|
+
expect(JSON.parse(results[2].data).url).toBe('lang://test/Qm-dup');
|
|
506
|
+
});
|
|
507
|
+
|
|
508
|
+
test('getMany() with null responses does not cache null entries', async () => {
|
|
509
|
+
// Override mock to return null for specific URL
|
|
510
|
+
const origHandler = MOCK_RESPONSES['expression.getMany'];
|
|
511
|
+
MOCK_RESPONSES['expression.getMany'] = (p: Record<string, unknown>) => {
|
|
512
|
+
const urls = (p.urls || []) as string[];
|
|
513
|
+
return urls.map((url: string) => {
|
|
514
|
+
if (url === 'lang://getNull') return null;
|
|
515
|
+
return {
|
|
516
|
+
author: 'did:test:123', timestamp: '2024-01-01', data: `{"url":"${url}"}`,
|
|
517
|
+
language: { address: 'lang://test' }, proof: { valid: true },
|
|
518
|
+
};
|
|
519
|
+
});
|
|
520
|
+
};
|
|
521
|
+
|
|
522
|
+
try {
|
|
523
|
+
const results = await ad4m.expression.getMany([
|
|
524
|
+
'lang://test/Qm-valid',
|
|
525
|
+
'lang://getNull',
|
|
526
|
+
]);
|
|
527
|
+
|
|
528
|
+
expect(results[0].author).toBe('did:test:123');
|
|
529
|
+
expect(results[1]).toBeNull();
|
|
530
|
+
|
|
531
|
+
rpcCallLog = [];
|
|
532
|
+
|
|
533
|
+
// Second call: Qm-valid should be cached, lang://getNull should go to network again
|
|
534
|
+
const results2 = await ad4m.expression.getMany([
|
|
535
|
+
'lang://test/Qm-valid',
|
|
536
|
+
'lang://getNull',
|
|
537
|
+
]);
|
|
538
|
+
|
|
539
|
+
expect(results2[0].author).toBe('did:test:123');
|
|
540
|
+
expect(results2[1]).toBeNull();
|
|
541
|
+
|
|
542
|
+
// Only lang://getNull needed a network call
|
|
543
|
+
const getManyCalls = rpcCallLog.filter(c => c.type === 'expression.getMany');
|
|
544
|
+
expect(getManyCalls).toHaveLength(1);
|
|
545
|
+
expect(getManyCalls[0].params.urls).toEqual(['lang://getNull']);
|
|
546
|
+
} finally {
|
|
547
|
+
MOCK_RESPONSES['expression.getMany'] = origHandler;
|
|
548
|
+
}
|
|
549
|
+
});
|
|
550
|
+
|
|
551
|
+
test('get() after getMany() uses L1 cache from getMany()', async () => {
|
|
552
|
+
await ad4m.expression.getMany(['lang://test/Qm-cross1', 'lang://test/Qm-cross2']);
|
|
553
|
+
expect(rpcCallLog.filter(c => c.type === 'expression.getMany')).toHaveLength(1);
|
|
554
|
+
|
|
555
|
+
// Individual get() should hit L1 from getMany
|
|
556
|
+
await ad4m.expression.get('lang://test/Qm-cross1');
|
|
557
|
+
await ad4m.expression.get('lang://test/Qm-cross2');
|
|
558
|
+
|
|
559
|
+
expect(rpcCallLog.filter(c => c.type === 'expression.get')).toHaveLength(0); // no individual RPCs
|
|
560
|
+
});
|
|
561
|
+
|
|
562
|
+
test('get() populates cache for subsequent getMany()', async () => {
|
|
563
|
+
await ad4m.expression.get('lang://test/Qm-pre');
|
|
564
|
+
expect(rpcCallLog.filter(c => c.type === 'expression.get')).toHaveLength(1);
|
|
565
|
+
|
|
566
|
+
rpcCallLog = [];
|
|
567
|
+
|
|
568
|
+
const results = await ad4m.expression.getMany([
|
|
569
|
+
'lang://test/Qm-pre', // cached from get()
|
|
570
|
+
'lang://test/Qm-new', // not cached
|
|
571
|
+
]);
|
|
572
|
+
|
|
573
|
+
expect(results).toHaveLength(2);
|
|
574
|
+
// Should only fetch Qm-new
|
|
575
|
+
const getManyCalls = rpcCallLog.filter(c => c.type === 'expression.getMany');
|
|
576
|
+
expect(getManyCalls).toHaveLength(1);
|
|
577
|
+
expect(getManyCalls[0].params.urls).toEqual(['lang://test/Qm-new']);
|
|
578
|
+
});
|
|
579
|
+
|
|
580
|
+
test('L1 LRU eviction by MAX_MEM_BYTES', async () => {
|
|
581
|
+
const origMaxEntries = ExpressionClient.MAX_MEM_ENTRIES;
|
|
582
|
+
const origMaxBytes = ExpressionClient.MAX_MEM_BYTES;
|
|
583
|
+
ExpressionClient.MAX_MEM_ENTRIES = 1000; // won't be the eviction trigger
|
|
584
|
+
// Each mock entry is ~100 bytes JSON. Set limit to hold ~2 entries.
|
|
585
|
+
ExpressionClient.MAX_MEM_BYTES = 250;
|
|
586
|
+
|
|
587
|
+
try {
|
|
588
|
+
await ad4m.expression.get('lang://test/Qm-bytes-1');
|
|
589
|
+
await ad4m.expression.get('lang://test/Qm-bytes-2');
|
|
590
|
+
expect(rpcCallLog.filter(c => c.type === 'expression.get')).toHaveLength(2);
|
|
591
|
+
|
|
592
|
+
// Adding 3rd should evict 1st (oldest)
|
|
593
|
+
await ad4m.expression.get('lang://test/Qm-bytes-3');
|
|
594
|
+
expect(rpcCallLog.filter(c => c.type === 'expression.get')).toHaveLength(3);
|
|
595
|
+
|
|
596
|
+
// Qm-bytes-1 was evicted — needs re-fetch
|
|
597
|
+
await ad4m.expression.get('lang://test/Qm-bytes-1');
|
|
598
|
+
expect(rpcCallLog.filter(c => c.type === 'expression.get')).toHaveLength(4);
|
|
599
|
+
} finally {
|
|
600
|
+
ExpressionClient.MAX_MEM_ENTRIES = origMaxEntries;
|
|
601
|
+
ExpressionClient.MAX_MEM_BYTES = origMaxBytes;
|
|
602
|
+
}
|
|
603
|
+
});
|
|
604
|
+
});
|
|
605
|
+
|
|
606
|
+
// ===================== AGENT CACHE — ADDITIONAL EDGE CASES =====================
|
|
607
|
+
|
|
608
|
+
describe('AgentClient Cache — additional edge cases', () => {
|
|
609
|
+
test('agent-updated event for unknown DID pre-populates cache', async () => {
|
|
610
|
+
ad4m.agent.subscribeAgentUpdated();
|
|
611
|
+
|
|
612
|
+
// Emit event for a DID we never fetched
|
|
613
|
+
const ws = lastOf(MockWebSocket.instances);
|
|
614
|
+
ws.emit({
|
|
615
|
+
type: 'agent-updated',
|
|
616
|
+
agent: {
|
|
617
|
+
did: 'did:test:preload',
|
|
618
|
+
perspective: null,
|
|
619
|
+
directMessageLanguage: 'lang://pre',
|
|
620
|
+
},
|
|
621
|
+
});
|
|
622
|
+
|
|
623
|
+
// byDID should return from cache — no RPC
|
|
624
|
+
const agent = await ad4m.agent.byDID('did:test:preload');
|
|
625
|
+
expect(agent.did).toBe('did:test:preload');
|
|
626
|
+
expect(agent.directMessageLanguage).toBe('lang://pre');
|
|
627
|
+
|
|
628
|
+
const byDidCalls = rpcCallLog.filter(c => c.type === 'agent.byDid');
|
|
629
|
+
expect(byDidCalls).toHaveLength(0);
|
|
630
|
+
});
|
|
631
|
+
|
|
632
|
+
test('invalidateByDid() on non-existent DID does not throw', () => {
|
|
633
|
+
expect(() => ad4m.agent.invalidateByDid('did:test:nonexistent')).not.toThrow();
|
|
634
|
+
});
|
|
635
|
+
|
|
636
|
+
test('setSelfDid() then invalidateByDid() allows re-fetch of self', async () => {
|
|
637
|
+
ad4m.agent.setSelfDid('did:test:self-inv');
|
|
638
|
+
await ad4m.agent.byDID('did:test:self-inv');
|
|
639
|
+
expect(rpcCallLog.filter(c => c.type === 'agent.byDid')).toHaveLength(1);
|
|
640
|
+
|
|
641
|
+
ad4m.agent.invalidateByDid('did:test:self-inv');
|
|
642
|
+
|
|
643
|
+
await ad4m.agent.byDID('did:test:self-inv');
|
|
644
|
+
expect(rpcCallLog.filter(c => c.type === 'agent.byDid')).toHaveLength(2);
|
|
645
|
+
});
|
|
646
|
+
|
|
647
|
+
test('concurrent byDID() for different DIDs makes parallel RPCs', async () => {
|
|
648
|
+
const [a1, a2, a3] = await Promise.all([
|
|
649
|
+
ad4m.agent.byDID('did:test:par-1'),
|
|
650
|
+
ad4m.agent.byDID('did:test:par-2'),
|
|
651
|
+
ad4m.agent.byDID('did:test:par-3'),
|
|
652
|
+
]);
|
|
653
|
+
|
|
654
|
+
expect(a1.did).toBe('did:test:par-1');
|
|
655
|
+
expect(a2.did).toBe('did:test:par-2');
|
|
656
|
+
expect(a3.did).toBe('did:test:par-3');
|
|
657
|
+
|
|
658
|
+
const byDidCalls = rpcCallLog.filter(c => c.type === 'agent.byDid');
|
|
659
|
+
expect(byDidCalls).toHaveLength(3); // all different DIDs
|
|
660
|
+
});
|
|
661
|
+
|
|
662
|
+
test('updatePublicPerspective() does not interact with byDID cache', async () => {
|
|
663
|
+
// updatePublicPerspective uses agent.updateProfile RPC, not agent.byDid
|
|
664
|
+
// Verify cache is unaffected
|
|
665
|
+
await ad4m.agent.byDID('did:test:update-profile');
|
|
666
|
+
expect(rpcCallLog.filter(c => c.type === 'agent.byDid')).toHaveLength(1);
|
|
667
|
+
|
|
668
|
+
// byDID should still be cached
|
|
669
|
+
await ad4m.agent.byDID('did:test:update-profile');
|
|
670
|
+
expect(rpcCallLog.filter(c => c.type === 'agent.byDid')).toHaveLength(1);
|
|
671
|
+
});
|
|
672
|
+
});
|
|
673
|
+
|
|
674
|
+
// ===================== CROSS-CLIENT ISOLATION =====================
|
|
675
|
+
|
|
676
|
+
describe('Cache isolation between clients', () => {
|
|
677
|
+
test('two Ad4mClient instances have independent caches', async () => {
|
|
678
|
+
const client2 = new Ad4mClient('http://127.0.0.1:12000', 'test-token', false);
|
|
679
|
+
|
|
680
|
+
await ad4m.agent.byDID('did:test:isolated');
|
|
681
|
+
await ad4m.expression.get('lang://test/Qm-isolated');
|
|
682
|
+
|
|
683
|
+
// client2 should not see client1's cache
|
|
684
|
+
await client2.agent.byDID('did:test:isolated');
|
|
685
|
+
await client2.expression.get('lang://test/Qm-isolated');
|
|
686
|
+
|
|
687
|
+
// 2 RPCs for each — both clients went to network independently
|
|
688
|
+
const byDidCalls = rpcCallLog.filter(c => c.type === 'agent.byDid');
|
|
689
|
+
expect(byDidCalls).toHaveLength(2);
|
|
690
|
+
const getCalls = rpcCallLog.filter(c => c.type === 'expression.get');
|
|
691
|
+
expect(getCalls).toHaveLength(2);
|
|
692
|
+
});
|
|
693
|
+
});
|
|
694
|
+
|
|
695
|
+
// ===================== AD4M CLIENT INTEGRATION =====================
|
|
696
|
+
|
|
697
|
+
describe('Ad4mClient cache integration', () => {
|
|
698
|
+
test('close() clears agent L1 cache', async () => {
|
|
699
|
+
await ad4m.agent.byDID('did:test:close');
|
|
700
|
+
expect(rpcCallLog.filter(c => c.type === 'agent.byDid')).toHaveLength(1);
|
|
701
|
+
|
|
702
|
+
ad4m.close();
|
|
703
|
+
|
|
704
|
+
// After close, a new client is needed; but we can test that
|
|
705
|
+
// the clearByDidCache was called by checking the old client
|
|
706
|
+
// Note: close() calls apiClient.closeAll() which may close sockets,
|
|
707
|
+
// so we create a fresh client to verify the pattern
|
|
708
|
+
const fresh = new Ad4mClient('http://127.0.0.1:12000', 'test-token', false);
|
|
709
|
+
await fresh.agent.byDID('did:test:close');
|
|
710
|
+
// New client should make its own RPC (separate cache)
|
|
711
|
+
expect(rpcCallLog.filter(c => c.type === 'agent.byDid')).toHaveLength(2);
|
|
712
|
+
});
|
|
713
|
+
});
|