@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.
Files changed (72) hide show
  1. package/lib/index.cjs +1507 -1372
  2. package/lib/index.js +1505 -1370
  3. package/lib/src/Ad4mClient.d.ts +1 -1
  4. package/lib/src/Ad4mClient.js +12 -1
  5. package/lib/src/agent/AgentClient.d.ts +16 -0
  6. package/lib/src/agent/AgentClient.js +74 -4
  7. package/lib/src/cache/PersistentCache.d.ts +40 -0
  8. package/lib/src/cache/PersistentCache.js +139 -0
  9. package/lib/src/expression/ExpressionClient.d.ts +8 -0
  10. package/lib/src/expression/ExpressionClient.js +113 -5
  11. package/lib/src/index.d.ts +1 -0
  12. package/lib/src/index.js +1 -0
  13. package/lib/src/model/Ad4mModel.d.ts +20 -7
  14. package/lib/src/model/Ad4mModel.js +102 -108
  15. package/lib/src/model/Ad4mModel.test.js +688 -1434
  16. package/lib/src/model/ModelQueryBuilder.d.ts +6 -6
  17. package/lib/src/model/ModelQueryBuilder.js +29 -20
  18. package/lib/src/model/Subject.js +6 -6
  19. package/lib/src/model/hydration.d.ts +2 -39
  20. package/lib/src/model/hydration.js +2 -260
  21. package/lib/src/model/query-surreal.d.ts +44 -0
  22. package/lib/src/model/query-surreal.js +249 -0
  23. package/lib/src/model/query-utils.d.ts +1 -0
  24. package/lib/src/model/query-utils.js +46 -1
  25. package/lib/src/model/relation-filtering.test.js +15 -15
  26. package/lib/src/model/surreal-utils.d.ts +42 -0
  27. package/lib/src/model/surreal-utils.js +128 -0
  28. package/lib/src/model/types.d.ts +4 -6
  29. package/lib/src/perspectives/PerspectiveClient.d.ts +1 -1
  30. package/lib/src/perspectives/PerspectiveClient.js +15 -13
  31. package/lib/src/perspectives/PerspectiveProxy.d.ts +14 -0
  32. package/lib/src/perspectives/PerspectiveProxy.js +16 -3
  33. package/lib/src/perspectives/PerspectiveResolver.d.ts +1 -0
  34. package/lib/src/perspectives/PerspectiveResolver.js +11 -0
  35. package/lib/src/runtime/RuntimeResolver.d.ts +1 -28
  36. package/lib/src/runtime/RuntimeResolver.js +4 -197
  37. package/lib/src/schema.gql +1 -27
  38. package/lib/src/shacl/SHACLShape.test.js +0 -82
  39. package/package.json +11 -8
  40. package/src/Ad4mClient.test.ts +14 -4
  41. package/src/Ad4mClient.ts +12 -1
  42. package/src/agent/AgentClient.ts +84 -2
  43. package/src/cache/PersistentCache.ts +145 -0
  44. package/src/cache/cache.test.ts +713 -0
  45. package/src/expression/ExpressionClient.ts +137 -3
  46. package/src/index.ts +1 -0
  47. package/src/model/Ad4mModel.test.ts +59 -358
  48. package/src/model/Ad4mModel.ts +112 -108
  49. package/src/model/ModelQueryBuilder.ts +29 -17
  50. package/src/model/hydration.ts +2 -279
  51. package/src/model/query-utils.ts +47 -2
  52. package/src/model/types.ts +5 -6
  53. package/src/perspectives/PerspectiveClient.ts +26 -17
  54. package/src/perspectives/PerspectiveProxy.ts +24 -3
  55. package/lib/src/model/hydration-batch.d.ts +0 -34
  56. package/lib/src/model/hydration-batch.js +0 -147
  57. package/lib/src/model/hydration-batching.test.d.ts +0 -7
  58. package/lib/src/model/hydration-batching.test.js +0 -456
  59. package/lib/src/model/model-manifest.d.ts +0 -41
  60. package/lib/src/model/model-manifest.js +0 -11
  61. package/lib/src/model/query-cache.test.d.ts +0 -1
  62. package/lib/src/model/query-cache.test.js +0 -43
  63. package/lib/src/model/query-sparql-batch.d.ts +0 -17
  64. package/lib/src/model/query-sparql-batch.js +0 -260
  65. package/lib/src/model/query-sparql.test.d.ts +0 -1
  66. package/lib/src/model/query-sparql.test.js +0 -312
  67. package/lib/src/model/subscription-delta.test.d.ts +0 -24
  68. package/lib/src/model/subscription-delta.test.js +0 -180
  69. package/lib/src/model/subscription-pool.d.ts +0 -39
  70. package/lib/src/model/subscription-pool.js +0 -165
  71. package/lib/src/perspectives/PerspectiveClient.test.d.ts +0 -1
  72. package/lib/src/perspectives/PerspectiveClient.test.js +0 -224
@@ -1,180 +0,0 @@
1
- /**
2
- * Tests for the delta fast-path logic used in subscription-pool.ts.
3
- *
4
- * The delta optimisation in pooledSubscribe's onResult handler:
5
- * 1. Checks if new rows are a strict superset of previous rows
6
- * 2. Extracts added rows (new triples not in prev set)
7
- * 3. Verifies ALL added rows have source URIs not already in previous results
8
- * 4. If condition 3 fails (existing source got new links), falls back to full rehydration
9
- *
10
- * These tests validate the detection logic in isolation.
11
- */
12
- /**
13
- * Replicates the delta-path eligibility check from subscription-pool.ts
14
- */
15
- function detectDeltaPath(prevArr, newArr) {
16
- if (newArr.length <= prevArr.length) {
17
- return { useDelta: false, addedRows: [], reason: 'no growth' };
18
- }
19
- if (newArr.length - prevArr.length > 5) {
20
- return { useDelta: false, addedRows: [], reason: 'delta too large' };
21
- }
22
- const prevSources = new Set(prevArr.map(r => `${r.source}|${r.predicate}|${r.target}`));
23
- const addedRows = newArr.filter(r => !prevSources.has(`${r.source}|${r.predicate}|${r.target}`));
24
- const newSources = new Set(newArr.map(r => `${r.source}|${r.predicate}|${r.target}`));
25
- const removedRows = prevArr.filter(r => !newSources.has(`${r.source}|${r.predicate}|${r.target}`));
26
- if (removedRows.length > 0) {
27
- return { useDelta: false, addedRows, reason: 'rows removed' };
28
- }
29
- // Key check: all added rows must have NEW source URIs
30
- const prevSourceIds = new Set(prevArr.map(r => r.source));
31
- const allNewSources = addedRows.every(r => !prevSourceIds.has(r.source));
32
- if (!allNewSources) {
33
- return { useDelta: false, addedRows, reason: 'existing source got new links' };
34
- }
35
- return { useDelta: true, addedRows };
36
- }
37
- describe('delta fast-path detection', () => {
38
- const prev = [
39
- { source: 'a', predicate: 'p1', target: 't1' },
40
- { source: 'a', predicate: 'p2', target: 't2' },
41
- { source: 'b', predicate: 'p1', target: 't3' },
42
- ];
43
- it('appends genuinely new items via delta path', () => {
44
- const next = [
45
- ...prev,
46
- { source: 'c', predicate: 'p1', target: 't4' },
47
- ];
48
- const result = detectDeltaPath(prev, next);
49
- expect(result.useDelta).toBe(true);
50
- expect(result.addedRows).toHaveLength(1);
51
- expect(result.addedRows[0].source).toBe('c');
52
- });
53
- it('falls back when existing source gets new links', () => {
54
- const next = [
55
- ...prev,
56
- { source: 'a', predicate: 'p3', target: 't5' }, // source 'a' already exists
57
- ];
58
- const result = detectDeltaPath(prev, next);
59
- expect(result.useDelta).toBe(false);
60
- expect(result.reason).toBe('existing source got new links');
61
- });
62
- it('falls back when rows are removed (even if new ones added)', () => {
63
- const next = [
64
- { source: 'a', predicate: 'p1', target: 't1' },
65
- { source: 'a', predicate: 'p2', target: 't2' },
66
- // source 'b' row removed, two new sources added so length grows
67
- { source: 'c', predicate: 'p1', target: 't4' },
68
- { source: 'd', predicate: 'p1', target: 't5' },
69
- ];
70
- const result = detectDeltaPath(prev, next);
71
- expect(result.useDelta).toBe(false);
72
- expect(result.reason).toBe('rows removed');
73
- });
74
- it('falls back when delta is too large (>5 new rows)', () => {
75
- const next = [
76
- ...prev,
77
- ...Array.from({ length: 6 }, (_, i) => ({
78
- source: `new${i}`, predicate: 'p1', target: `t${10 + i}`,
79
- })),
80
- ];
81
- const result = detectDeltaPath(prev, next);
82
- expect(result.useDelta).toBe(false);
83
- expect(result.reason).toBe('delta too large');
84
- });
85
- it('falls back when no growth', () => {
86
- const result = detectDeltaPath(prev, prev);
87
- expect(result.useDelta).toBe(false);
88
- expect(result.reason).toBe('no growth');
89
- });
90
- it('handles multiple new sources in one delta', () => {
91
- const next = [
92
- ...prev,
93
- { source: 'c', predicate: 'p1', target: 't4' },
94
- { source: 'd', predicate: 'p1', target: 't5' },
95
- ];
96
- const result = detectDeltaPath(prev, next);
97
- expect(result.useDelta).toBe(true);
98
- expect(result.addedRows).toHaveLength(2);
99
- });
100
- // ── Test #8: Rapid successive additions ──
101
- it('handles 10 items added in quick succession without duplicates', () => {
102
- let current = [...prev];
103
- for (let i = 0; i < 10; i++) {
104
- const next = [...current, { source: `rapid-${i}`, predicate: 'p1', target: `t-rapid-${i}` }];
105
- const result = detectDeltaPath(current, next);
106
- // Each individual addition should be eligible for delta
107
- expect(result.useDelta).toBe(true);
108
- expect(result.addedRows).toHaveLength(1);
109
- expect(result.addedRows[0].source).toBe(`rapid-${i}`);
110
- current = next;
111
- }
112
- });
113
- // ── Test #9: Addition + removal in same batch ──
114
- it('falls back when one item added and another removed simultaneously', () => {
115
- const next = [
116
- { source: 'a', predicate: 'p1', target: 't1' },
117
- { source: 'a', predicate: 'p2', target: 't2' },
118
- // source 'b' removed, source 'c' added
119
- { source: 'c', predicate: 'p1', target: 't4' },
120
- { source: 'd', predicate: 'p1', target: 't5' },
121
- ];
122
- const result = detectDeltaPath(prev, next);
123
- expect(result.useDelta).toBe(false);
124
- expect(result.reason).toBe('rows removed');
125
- });
126
- // ── Test #10: Delta with nested relations (detection only) ──
127
- it('delta path detects new items correctly even when sources have complex URIs', () => {
128
- const next = [
129
- ...prev,
130
- { source: 'flux://post/123/comment/456', predicate: 'flux://belongs_to', target: 'flux://post/123' },
131
- ];
132
- const result = detectDeltaPath(prev, next);
133
- expect(result.useDelta).toBe(true);
134
- expect(result.addedRows).toHaveLength(1);
135
- expect(result.addedRows[0].source).toBe('flux://post/123/comment/456');
136
- });
137
- // ── Test #11: Empty previous result + new items ──
138
- it('handles empty previous array with new items arriving', () => {
139
- const empty = [];
140
- const next = [
141
- { source: 'x', predicate: 'p1', target: 't1' },
142
- ];
143
- const result = detectDeltaPath(empty, next);
144
- expect(result.useDelta).toBe(true);
145
- expect(result.addedRows).toHaveLength(1);
146
- });
147
- it('handles empty previous with no new items', () => {
148
- const result = detectDeltaPath([], []);
149
- expect(result.useDelta).toBe(false);
150
- expect(result.reason).toBe('no growth');
151
- });
152
- // ── Test #12: Source URI with special characters ──
153
- it('handles URIs with encoded characters, fragments, and query params', () => {
154
- const specialPrev = [
155
- { source: 'flux://item%20one', predicate: 'p1', target: 't1' },
156
- { source: 'flux://item#section', predicate: 'p2', target: 't2' },
157
- { source: 'flux://item?key=val&foo=bar', predicate: 'p3', target: 't3' },
158
- ];
159
- const specialNext = [
160
- ...specialPrev,
161
- { source: 'flux://new%C3%A9item', predicate: 'p1', target: 't4' },
162
- ];
163
- const result = detectDeltaPath(specialPrev, specialNext);
164
- expect(result.useDelta).toBe(true);
165
- expect(result.addedRows).toHaveLength(1);
166
- expect(result.addedRows[0].source).toBe('flux://new%C3%A9item');
167
- });
168
- it('correctly identifies existing source with special chars getting new links', () => {
169
- const specialPrev = [
170
- { source: 'flux://item#section', predicate: 'p1', target: 't1' },
171
- ];
172
- const specialNext = [
173
- ...specialPrev,
174
- { source: 'flux://item#section', predicate: 'p2', target: 't2' },
175
- ];
176
- const result = detectDeltaPath(specialPrev, specialNext);
177
- expect(result.useDelta).toBe(false);
178
- expect(result.reason).toBe('existing source got new links');
179
- });
180
- });
@@ -1,39 +0,0 @@
1
- /**
2
- * Subscription Pool — deduplicates identical SPARQL subscriptions.
3
- *
4
- * When multiple UI components subscribe to the same SPARQL query on the same
5
- * perspective, the pool shares a single `subscribeQuery()` call and distributes
6
- * results to all registered callbacks. Hydration happens once per result set,
7
- * then is shared across all subscribers.
8
- *
9
- * Key: `perspectiveUUID + sparqlQuery`
10
- */
11
- import type { PerspectiveProxy } from "../perspectives/PerspectiveProxy";
12
- type HydrateCallback = (rawResult: any) => Promise<any>;
13
- type ResultCallback = (hydratedResult: any) => void;
14
- export interface PooledSubscription {
15
- /** The initial (hydrated) result */
16
- initialResult: any;
17
- /** Unsubscribe this particular callback from the pool */
18
- dispose: () => void;
19
- }
20
- /**
21
- * Subscribe to a SPARQL query, sharing the underlying subscription
22
- * with any other subscribers using the same perspective + query.
23
- *
24
- * @param perspective - The perspective proxy
25
- * @param sparqlQuery - The SPARQL query text
26
- * @param hydrate - Async function that takes raw SPARQL results and returns hydrated results
27
- * @param onResult - Callback for subsequent result updates (hydrated)
28
- * @returns PooledSubscription with initial result and dispose function
29
- */
30
- export declare function pooledSubscribe(perspective: PerspectiveProxy, sparqlQuery: string, hydrate: HydrateCallback, onResult: ResultCallback): Promise<PooledSubscription>;
31
- /**
32
- * Clear the entire pool (for testing).
33
- */
34
- export declare function clearSubscriptionPool(): void;
35
- /**
36
- * Get the current pool size (for testing).
37
- */
38
- export declare function subscriptionPoolSize(): number;
39
- export {};
@@ -1,165 +0,0 @@
1
- /**
2
- * Subscription Pool — deduplicates identical SPARQL subscriptions.
3
- *
4
- * When multiple UI components subscribe to the same SPARQL query on the same
5
- * perspective, the pool shares a single `subscribeQuery()` call and distributes
6
- * results to all registered callbacks. Hydration happens once per result set,
7
- * then is shared across all subscribers.
8
- *
9
- * Key: `perspectiveUUID + sparqlQuery`
10
- */
11
- const pool = new Map();
12
- function makeKey(perspectiveUUID, sparqlQuery) {
13
- return `${perspectiveUUID}::${sparqlQuery}`;
14
- }
15
- /**
16
- * Subscribe to a SPARQL query, sharing the underlying subscription
17
- * with any other subscribers using the same perspective + query.
18
- *
19
- * @param perspective - The perspective proxy
20
- * @param sparqlQuery - The SPARQL query text
21
- * @param hydrate - Async function that takes raw SPARQL results and returns hydrated results
22
- * @param onResult - Callback for subsequent result updates (hydrated)
23
- * @returns PooledSubscription with initial result and dispose function
24
- */
25
- export async function pooledSubscribe(perspective, sparqlQuery, hydrate, onResult) {
26
- const uuid = perspective.uuid || perspective.handle?.uuid || '';
27
- const key = makeKey(uuid, sparqlQuery);
28
- const entry = pool.get(key);
29
- const subscriber = { onResult, hydrate };
30
- if (entry) {
31
- // Join existing subscription
32
- entry.callbacks.add(subscriber);
33
- entry.refCount++;
34
- // Hydrate latest result for this new subscriber
35
- let initialResult;
36
- if (entry.latestHydrated !== undefined) {
37
- initialResult = entry.latestHydrated;
38
- }
39
- else if (entry.latestRaw !== undefined) {
40
- initialResult = await hydrate(entry.latestRaw);
41
- }
42
- return {
43
- initialResult,
44
- dispose: () => disposeSubscriber(key, subscriber),
45
- };
46
- }
47
- // Create new subscription
48
- const subscription = await perspective.subscribeQuery(sparqlQuery);
49
- const newEntry = {
50
- subscription,
51
- callbacks: new Set([subscriber]),
52
- latestRaw: subscription.result,
53
- latestHydrated: undefined,
54
- hydrating: false,
55
- refCount: 1,
56
- };
57
- pool.set(key, newEntry);
58
- // Set up shared result handler with delta optimization
59
- subscription.onResult(async (rawResult) => {
60
- const prevRaw = newEntry.latestRaw;
61
- newEntry.latestRaw = rawResult;
62
- newEntry.hydrating = true;
63
- try {
64
- const firstSub = newEntry.callbacks.values().next().value;
65
- if (firstSub) {
66
- // Delta optimization: if the new result is strictly an addition
67
- // (all previous rows still present + new rows), only hydrate the
68
- // new rows and append them to the cached hydrated result.
69
- const prevArr = Array.isArray(prevRaw) ? prevRaw : [];
70
- const newArr = Array.isArray(rawResult) ? rawResult : [];
71
- const prevHydrated = newEntry.latestHydrated;
72
- if (prevHydrated &&
73
- Array.isArray(prevHydrated) &&
74
- newArr.length > prevArr.length &&
75
- newArr.length - prevArr.length <= 5 // small delta — worth optimizing
76
- ) {
77
- // Build a set of source URIs from previous results for quick lookup
78
- const prevSources = new Set(prevArr.map((r) => `${r.source}|${r.predicate}|${r.target}`));
79
- const addedRows = newArr.filter((r) => !prevSources.has(`${r.source}|${r.predicate}|${r.target}`));
80
- // Check that no rows were removed (pure addition)
81
- const newSources = new Set(newArr.map((r) => `${r.source}|${r.predicate}|${r.target}`));
82
- const removedRows = prevArr.filter((r) => !newSources.has(`${r.source}|${r.predicate}|${r.target}`));
83
- if (removedRows.length === 0 && addedRows.length > 0) {
84
- // Verify ALL added rows have sources not in previous results.
85
- // If any added row's source matches an existing source, it means
86
- // an existing instance got new links — we need full rehydration.
87
- const prevSourceIds = new Set(prevArr.map((r) => r.source));
88
- const allNewSources = addedRows.every((r) => !prevSourceIds.has(r.source));
89
- if (allNewSources) {
90
- // Pure addition of new instances — hydrate only the new rows
91
- try {
92
- const deltaHydrated = await firstSub.hydrate(addedRows);
93
- if (Array.isArray(deltaHydrated)) {
94
- const merged = [...prevHydrated, ...deltaHydrated];
95
- newEntry.latestHydrated = merged;
96
- for (const cb of newEntry.callbacks) {
97
- try {
98
- cb.onResult(merged);
99
- }
100
- catch (e) { /* subscriber error */ }
101
- }
102
- return; // Delta path succeeded
103
- }
104
- }
105
- catch {
106
- // Delta hydration failed — fall through to full hydration
107
- }
108
- }
109
- }
110
- }
111
- // Full hydration fallback
112
- const hydrated = await firstSub.hydrate(rawResult);
113
- newEntry.latestHydrated = hydrated;
114
- // Distribute to all callbacks
115
- for (const cb of newEntry.callbacks) {
116
- try {
117
- cb.onResult(hydrated);
118
- }
119
- catch (e) { /* subscriber error */ }
120
- }
121
- }
122
- }
123
- finally {
124
- newEntry.hydrating = false;
125
- }
126
- });
127
- // Hydrate initial result
128
- const initialResult = await hydrate(subscription.result);
129
- newEntry.latestHydrated = initialResult;
130
- return {
131
- initialResult,
132
- dispose: () => disposeSubscriber(key, subscriber),
133
- };
134
- }
135
- function disposeSubscriber(key, subscriber) {
136
- const entry = pool.get(key);
137
- if (!entry)
138
- return;
139
- entry.callbacks.delete(subscriber);
140
- entry.refCount--;
141
- if (entry.refCount <= 0) {
142
- // Last subscriber — tear down the underlying subscription
143
- if (entry.subscription?.dispose) {
144
- entry.subscription.dispose();
145
- }
146
- pool.delete(key);
147
- }
148
- }
149
- /**
150
- * Clear the entire pool (for testing).
151
- */
152
- export function clearSubscriptionPool() {
153
- for (const entry of pool.values()) {
154
- if (entry.subscription?.dispose) {
155
- entry.subscription.dispose();
156
- }
157
- }
158
- pool.clear();
159
- }
160
- /**
161
- * Get the current pool size (for testing).
162
- */
163
- export function subscriptionPoolSize() {
164
- return pool.size;
165
- }
@@ -1 +0,0 @@
1
- export {};
@@ -1,224 +0,0 @@
1
- import { PerspectiveClient } from "./PerspectiveClient";
2
- import { PerspectiveHandle, PerspectiveState } from "./PerspectiveHandle";
3
- /**
4
- * Focused unit tests for PerspectiveClient proxy cache behaviour.
5
- * Uses a mock Apollo client to isolate cache logic from network.
6
- */
7
- // Minimal mock Apollo client that returns controllable results
8
- function createMockApolloClient(overrides = {}) {
9
- return {
10
- query: overrides.query || jest.fn().mockResolvedValue({ data: {} }),
11
- mutate: overrides.mutate || jest.fn().mockResolvedValue({ data: {} }),
12
- subscribe: overrides.subscribe || jest.fn().mockReturnValue({
13
- subscribe: jest.fn()
14
- }),
15
- };
16
- }
17
- function makeHandle(uuid, name, state = PerspectiveState.Private) {
18
- const h = new PerspectiveHandle(uuid, name, state);
19
- return h;
20
- }
21
- describe('PerspectiveClient proxy cache', () => {
22
- it('byUUID returns the same proxy reference on cache hit', async () => {
23
- const handle = makeHandle('uuid-1', 'Test');
24
- const mockClient = createMockApolloClient({
25
- query: jest.fn().mockResolvedValue({
26
- data: { perspective: handle }
27
- }),
28
- });
29
- const client = new PerspectiveClient(mockClient, false);
30
- const p1 = await client.byUUID('uuid-1');
31
- const p2 = await client.byUUID('uuid-1');
32
- expect(p1).toBe(p2);
33
- // Only one query should have been made (second is cache hit)
34
- expect(mockClient.query).toHaveBeenCalledTimes(1);
35
- });
36
- it('byUUID returns null for non-existent perspectives', async () => {
37
- const mockClient = createMockApolloClient({
38
- query: jest.fn().mockResolvedValue({
39
- data: { perspective: null }
40
- }),
41
- });
42
- const client = new PerspectiveClient(mockClient, false);
43
- const p = await client.byUUID('non-existent');
44
- expect(p).toBeNull();
45
- });
46
- it('all() populates cache so subsequent byUUID is a hit', async () => {
47
- const handles = [
48
- makeHandle('uuid-a', 'A'),
49
- makeHandle('uuid-b', 'B'),
50
- ];
51
- const queryFn = jest.fn()
52
- .mockResolvedValueOnce({ data: { perspectives: handles } });
53
- const mockClient = createMockApolloClient({ query: queryFn });
54
- const client = new PerspectiveClient(mockClient, false);
55
- const all = await client.all();
56
- expect(all.length).toBe(2);
57
- // byUUID should be a cache hit — no additional query
58
- const pa = await client.byUUID('uuid-a');
59
- expect(pa).toBe(all[0]);
60
- expect(queryFn).toHaveBeenCalledTimes(1); // only the all() query
61
- });
62
- it('add() populates cache', async () => {
63
- const handle = makeHandle('uuid-new', 'New');
64
- const mockClient = createMockApolloClient({
65
- mutate: jest.fn().mockResolvedValue({
66
- data: { perspectiveAdd: handle }
67
- }),
68
- });
69
- const client = new PerspectiveClient(mockClient, false);
70
- const added = await client.add('New');
71
- expect(added.uuid).toBe('uuid-new');
72
- // byUUID should hit cache
73
- const fetched = await client.byUUID('uuid-new');
74
- expect(fetched).toBe(added);
75
- });
76
- it('update() evicts and recreates cached proxy', async () => {
77
- const originalHandle = makeHandle('uuid-u', 'Original');
78
- const updatedHandle = makeHandle('uuid-u', 'Updated');
79
- const queryFn = jest.fn().mockResolvedValue({
80
- data: { perspective: originalHandle }
81
- });
82
- const mutateFn = jest.fn().mockResolvedValue({
83
- data: { perspectiveUpdate: updatedHandle }
84
- });
85
- const mockClient = createMockApolloClient({
86
- query: queryFn,
87
- mutate: mutateFn,
88
- });
89
- const client = new PerspectiveClient(mockClient, false);
90
- const original = await client.byUUID('uuid-u');
91
- expect(original.name).toBe('Original');
92
- const updated = await client.update('uuid-u', 'Updated');
93
- expect(updated).not.toBe(original); // new reference after eviction
94
- expect(updated.name).toBe('Updated');
95
- expect(original.name).toBe('Original'); // old reference retains stale data
96
- });
97
- it('remove() evicts from cache', async () => {
98
- const handle = makeHandle('uuid-r', 'ToRemove');
99
- const queryFn = jest.fn().mockResolvedValue({
100
- data: { perspective: handle }
101
- });
102
- const mutateFn = jest.fn().mockResolvedValue({
103
- data: { perspectiveRemove: true }
104
- });
105
- const mockClient = createMockApolloClient({
106
- query: queryFn,
107
- mutate: mutateFn,
108
- });
109
- const client = new PerspectiveClient(mockClient, false);
110
- const p = await client.byUUID('uuid-r');
111
- expect(p).toBeTruthy();
112
- expect(queryFn).toHaveBeenCalledTimes(1);
113
- await client.remove('uuid-r');
114
- // byUUID should miss cache and query again
115
- const handle2 = makeHandle('uuid-r', 'Recreated');
116
- queryFn.mockResolvedValueOnce({ data: { perspective: handle2 } });
117
- const p2 = await client.byUUID('uuid-r');
118
- expect(p2).not.toBe(p);
119
- expect(p2.name).toBe('Recreated');
120
- expect(queryFn).toHaveBeenCalledTimes(2);
121
- });
122
- it('getOrCreateProxy does not re-register listeners on cache hit', async () => {
123
- // Verify that getting the same proxy twice does not create duplicate subscriptions
124
- const handle = makeHandle('uuid-dup', 'NoDuplicates');
125
- const subscribeCalls = [];
126
- const subscribeFn = jest.fn().mockImplementation((opts) => {
127
- // Track subscription query names
128
- const queryStr = opts.query?.loc?.source?.body || '';
129
- subscribeCalls.push(queryStr);
130
- return {
131
- subscribe: jest.fn()
132
- };
133
- });
134
- const queryFn = jest.fn()
135
- .mockResolvedValueOnce({ data: { perspectives: [handle] } });
136
- const mockClient = createMockApolloClient({
137
- query: queryFn,
138
- subscribe: subscribeFn,
139
- });
140
- const client = new PerspectiveClient(mockClient, false);
141
- const all = await client.all();
142
- const firstProxy = all[0];
143
- // Record how many subscribe calls happened from PerspectiveProxy constructor
144
- const callsAfterFirst = subscribeFn.mock.calls.length;
145
- // Get same proxy again via all() — should be cache hit, no new constructor call
146
- queryFn.mockResolvedValueOnce({ data: { perspectives: [handle] } });
147
- const all2 = await client.all();
148
- const secondProxy = all2[0];
149
- expect(secondProxy).toBe(firstProxy);
150
- // No additional subscribe calls should have been made
151
- expect(subscribeFn.mock.calls.length).toBe(callsAfterFirst);
152
- });
153
- it('all() updates existing cached proxies with fresh data', async () => {
154
- const handle1 = makeHandle('uuid-f', 'OldName');
155
- const handle2 = makeHandle('uuid-f', 'FreshName');
156
- const queryFn = jest.fn()
157
- .mockResolvedValueOnce({ data: { perspective: handle1 } })
158
- .mockResolvedValueOnce({ data: { perspectives: [handle2] } });
159
- const mockClient = createMockApolloClient({ query: queryFn });
160
- const client = new PerspectiveClient(mockClient, false);
161
- const original = await client.byUUID('uuid-f');
162
- expect(original.name).toBe('OldName');
163
- const all = await client.all();
164
- const refreshed = all.find(p => p.uuid === 'uuid-f');
165
- expect(refreshed).toBe(original); // same reference
166
- expect(refreshed.name).toBe('FreshName'); // updated in-place
167
- expect(original.name).toBe('FreshName'); // original ref also updated
168
- });
169
- });
170
- describe('PerspectiveProxy getClassShape sh:in URI-decoding', () => {
171
- // This tests the sh:in parsing logic in getClassShape() which was fixed
172
- // to URI-decode values from the Rust executor's SPARQL results
173
- function parseShInValue(raw) {
174
- // Reproduce the exact parsing logic from PerspectiveProxy.getClassShape()
175
- try {
176
- if (raw.startsWith('literal:string:')) {
177
- raw = decodeURIComponent(raw.substring('literal:string:'.length));
178
- }
179
- return JSON.parse(raw);
180
- }
181
- catch {
182
- return undefined;
183
- }
184
- }
185
- it('parses plain JSON sh:in values', () => {
186
- const result = parseShInValue('[{"value":"a"},{"value":"b","label":"B"}]');
187
- expect(result).toEqual([
188
- { value: 'a' },
189
- { value: 'b', label: 'B' },
190
- ]);
191
- });
192
- it('strips literal:string: prefix and parses', () => {
193
- const result = parseShInValue('literal:string:[{"value":"x"},{"value":"y"}]');
194
- expect(result).toEqual([
195
- { value: 'x' },
196
- { value: 'y' },
197
- ]);
198
- });
199
- it('URI-decodes encoded sh:in values from Rust executor', () => {
200
- // Rust executor may URI-encode the JSON when returning SPARQL results
201
- const encoded = 'literal:string:' + encodeURIComponent('[{"value":"hello world"},{"value":"a&b"}]');
202
- const result = parseShInValue(encoded);
203
- expect(result).toEqual([
204
- { value: 'hello world' },
205
- { value: 'a&b' },
206
- ]);
207
- });
208
- it('handles double-encoded brackets and quotes', () => {
209
- const encoded = 'literal:string:%5B%7B%22value%22%3A%22active%22%7D%2C%7B%22value%22%3A%22inactive%22%7D%5D';
210
- const result = parseShInValue(encoded);
211
- expect(result).toEqual([
212
- { value: 'active' },
213
- { value: 'inactive' },
214
- ]);
215
- });
216
- it('returns undefined for malformed JSON', () => {
217
- const result = parseShInValue('literal:string:not-json');
218
- expect(result).toBeUndefined();
219
- });
220
- it('handles already-decoded values without prefix', () => {
221
- const result = parseShInValue('[{"value":"test"}]');
222
- expect(result).toEqual([{ value: 'test' }]);
223
- });
224
- });