@enbox/dwn-sdk-js 0.4.15 → 0.4.17

package/dist/esm/tests/features/records-record-limit.spec.js

@@ -1,10 +1,11 @@
-import sinon from 'sinon';
 import { DataStream } from '../../src/utils/data-stream.js';
+import { DateSort } from '../../src/types/records-types.js';
 import { DidKey } from '@enbox/dids';
 import { Dwn } from '../../src/dwn.js';
 import { DwnConstant } from '../../src/core/dwn-constant.js';
 import { DwnErrorCode } from '../../src/core/dwn-error.js';
 import { Jws } from '../../src/utils/jws.js';
+import { Poller } from '../utils/poller.js';
 import { ProtocolsConfigure } from '../../src/interfaces/protocols-configure.js';
 import { RecordsRead } from '../../src/interfaces/records-read.js';
 import { sleep } from '@enbox/common';
@@ -34,7 +35,6 @@ export function testRecordsRecordLimit() {
             dwn = await Dwn.create({ didResolver, messageStore, dataStore, eventLog, resumableTaskStore });
         });
         beforeEach(async () => {
-            sinon.restore();
             await messageStore.clear();
             await dataStore.clear();
             await resumableTaskStore.clear();
@@ -58,6 +58,7 @@ export function testRecordsRecordLimit() {
                 protocol: input.protocol,
                 protocolPath: input.protocolPath,
                 parentContextId: input.parentContextId,
+                published: input.published,
                 dateCreated: input.dateCreated,
                 messageTimestamp: input.dateCreated,
             });
@@ -73,6 +74,7 @@ export function testRecordsRecordLimit() {
                     protocolPath: input.protocolPath,
                     ...(input.contextId === undefined ? {} : { contextId: input.contextId }),
                 },
+                dateSort: input.dateSort,
                 pagination: input.pagination,
             });
             const reply = await (input.targetDwn ?? dwn).processMessage(input.author.did, recordsQuery.message);
@@ -108,6 +110,7 @@ export function testRecordsRecordLimit() {
                 filter: {
                     protocol: input.protocol,
                     protocolPath: input.protocolPath,
+                    ...(input.contextId === undefined ? {} : { contextId: input.contextId }),
                 },
             });
             const reply = await (input.targetDwn ?? dwn).processMessage(input.author.did, recordsSubscribe.message, { subscriptionHandler: () => { } });
@@ -124,7 +127,7 @@ export function testRecordsRecordLimit() {
             }
         }
         describe('ProtocolsConfigure validation', () => {
-            it('should allow $recordLimit with valid max and strategy', async () => {
+            it('should allow $recordLimit with a valid max', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
                 const definition = {
                     protocol: 'http://example.com/record-limit',
@@ -132,7 +135,7 @@ export function testRecordsRecordLimit() {
                     types: { message: {} },
                     structure: {
                         message: {
-                            $recordLimit: { max: 5, strategy: 'reject' },
+                            $recordLimit: { max: 5 },
                         }
                     }
                 };
@@ -141,10 +144,7 @@ export function testRecordsRecordLimit() {
                     definition,
                 });
                 expect(protocolsConfigure.message.descriptor.definition).toBeDefined();
-                expect(protocolsConfigure.message.descriptor.definition.structure.message.$recordLimit).toEqual({
-                    max: 5,
-                    strategy: 'reject',
-                });
+                expect(protocolsConfigure.message.descriptor.definition.structure.message.$recordLimit).toEqual({ max: 5 });
             });
             it('should allow $recordLimit with max of 1', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
@@ -154,7 +154,7 @@ export function testRecordsRecordLimit() {
                     types: { profile: {} },
                     structure: {
                         profile: {
-                            $recordLimit: { max: 1, strategy: 'reject' },
+                            $recordLimit: { max: 1 },
                         }
                     }
                 };
@@ -162,10 +162,7 @@ export function testRecordsRecordLimit() {
                     signer: Jws.createSigner(alice),
                     definition,
                 });
-                expect(protocolsConfigure.message.descriptor.definition.structure.profile.$recordLimit).toEqual({
-                    max: 1,
-                    strategy: 'reject',
-                });
+                expect(protocolsConfigure.message.descriptor.definition.structure.profile.$recordLimit).toEqual({ max: 1 });
             });
             it('should reject $recordLimit above the supported max', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
@@ -175,7 +172,7 @@ export function testRecordsRecordLimit() {
                     types: { message: {} },
                     structure: {
                         message: {
-                            $recordLimit: { max: DwnConstant.maxRecordLimit + 1, strategy: 'reject' },
+                            $recordLimit: { max: DwnConstant.maxRecordLimit + 1 },
                         }
                     }
                 };
@@ -185,27 +182,6 @@ export function testRecordsRecordLimit() {
                 });
                 await expect(promise).rejects.toThrow(DwnErrorCode.ProtocolsConfigureInvalidRecordLimit);
             });
-            it('should allow $recordLimit with purgeOldest strategy (schema validation only)', async () => {
-                const alice = await TestDataGenerator.generateDidKeyPersona();
-                const definition = {
-                    protocol: 'http://example.com/record-limit',
-                    published: true,
-                    types: { status: {} },
-                    structure: {
-                        status: {
-                            $recordLimit: { max: 10, strategy: 'purgeOldest' },
-                        }
-                    }
-                };
-                const protocolsConfigure = await ProtocolsConfigure.create({
-                    signer: Jws.createSigner(alice),
-                    definition,
-                });
-                expect(protocolsConfigure.message.descriptor.definition.structure.status.$recordLimit).toEqual({
-                    max: 10,
-                    strategy: 'purgeOldest',
-                });
-            });
             it('should reject $recordLimit with max less than 1', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
                 const definition = {
@@ -214,7 +190,7 @@ export function testRecordsRecordLimit() {
                     types: { message: {} },
                     structure: {
                         message: {
-                            $recordLimit: { max: 0, strategy: 'reject' },
+                            $recordLimit: { max: 0 },
                         }
                     }
                 };
@@ -232,25 +208,7 @@ export function testRecordsRecordLimit() {
                     types: { message: {} },
                     structure: {
                         message: {
-                            $recordLimit: { max: 2.5, strategy: 'reject' },
-                        }
-                    }
-                };
-                const promise = ProtocolsConfigure.create({
-                    signer: Jws.createSigner(alice),
-                    definition,
-                });
-                await expect(promise).rejects.toThrow('SchemaValidator');
-            });
-            it('should reject $recordLimit with missing strategy', async () => {
-                const alice = await TestDataGenerator.generateDidKeyPersona();
-                const definition = {
-                    protocol: 'http://example.com/record-limit',
-                    published: true,
-                    types: { message: {} },
-                    structure: {
-                        message: {
-                            $recordLimit: { max: 5 },
+                            $recordLimit: { max: 2.5 },
                         }
                     }
                 };
@@ -260,7 +218,7 @@ export function testRecordsRecordLimit() {
                 });
                 await expect(promise).rejects.toThrow('SchemaValidator');
             });
-            it('should reject $recordLimit with invalid strategy', async () => {
+            it('should reject the removed $recordLimit strategy property', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
                 const definition = {
                     protocol: 'http://example.com/record-limit',
@@ -268,7 +226,7 @@ export function testRecordsRecordLimit() {
                     types: { message: {} },
                     structure: {
                         message: {
-                            $recordLimit: { max: 5, strategy: 'invalidStrategy' },
+                            $recordLimit: { max: 5, strategy: 'reject' },
                         }
                     }
                 };
@@ -290,7 +248,7 @@ export function testRecordsRecordLimit() {
                     structure: {
                         room: {
                             message: {
-                                $recordLimit: { max: 100, strategy: 'reject' },
+                                $recordLimit: { max: 100 },
                             }
                         }
                     }
@@ -300,13 +258,10 @@ export function testRecordsRecordLimit() {
                     definition,
                 });
                 const roomRuleSet = protocolsConfigure.message.descriptor.definition.structure.room;
-                expect(roomRuleSet.message.$recordLimit).toEqual({
-                    max: 100,
-                    strategy: 'reject',
-                });
+                expect(roomRuleSet.message.$recordLimit).toEqual({ max: 100 });
             });
         });
-        describe('read-time occupancy projection — reject strategy', () => {
+        describe('read-time occupancy projection', () => {
             it('should admit candidates and project Query, Read, and Count to top-ranked occupants', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
                 const protocolDefinition = {
@@ -315,7 +270,7 @@ export function testRecordsRecordLimit() {
                     types: { blob: {} },
                     structure: {
                         blob: {
-                            $recordLimit: { max: 2, strategy: 'reject' },
+                            $recordLimit: { max: 2 },
                         }
                     }
                 };
@@ -362,7 +317,7 @@ export function testRecordsRecordLimit() {
                     types: { profile: {} },
                     structure: {
                         profile: {
-                            $recordLimit: { max: 1, strategy: 'reject' },
+                            $recordLimit: { max: 1 },
                         }
                     }
                 };
@@ -406,7 +361,7 @@ export function testRecordsRecordLimit() {
                     structure: {
                         room: {
                             message: {
-                                $recordLimit: { max: 2, strategy: 'reject' },
+                                $recordLimit: { max: 2 },
                             }
                         }
                     }
@@ -489,6 +444,30 @@ export function testRecordsRecordLimit() {
                     room2Messages[0].message.recordId,
                     room2Messages[1].message.recordId,
                 ]);
+                expect((await queryProtocolRecordIds({
+                    author: alice,
+                    protocol,
+                    protocolPath: 'room/message',
+                    contextId: room1Messages[0].message.contextId,
+                })).recordIds).toEqual([room1Messages[0].message.recordId]);
+                expect(await countProtocolRecords({
+                    author: alice,
+                    protocol,
+                    protocolPath: 'room/message',
+                    contextId: room1Messages[0].message.contextId,
+                })).toBe(1);
+                expect((await queryProtocolRecordIds({
+                    author: alice,
+                    protocol,
+                    protocolPath: 'room/message',
+                    contextId: room1Messages[2].message.contextId,
+                })).recordIds).toEqual([]);
+                expect(await countProtocolRecords({
+                    author: alice,
+                    protocol,
+                    protocolPath: 'room/message',
+                    contextId: room1Messages[2].message.contextId,
+                })).toBe(0);
                 const broadQuery = await TestDataGenerator.generateRecordsQuery({
                     author: alice,
                     filter: {
@@ -500,6 +479,220 @@ export function testRecordsRecordLimit() {
                 expect(broadReply.status.code).toBe(400);
                 expect(broadReply.status.detail).toContain(DwnErrorCode.RecordsQueryNestedProtocolPathContextIdInvalid);
             });
+            it('should project ancestor queries independently across parent contexts', async () => {
+                const alice = await TestDataGenerator.generateDidKeyPersona();
+                const protocolDefinition = {
+                    protocol: `http://record-limit-${TestDataGenerator.randomString(12)}.xyz`,
+                    published: true,
+                    types: {
+                        channel: {},
+                        community: {},
+                        message: {},
+                    },
+                    structure: {
+                        community: {
+                            channel: {
+                                message: {
+                                    $recordLimit: { max: 2 },
+                                },
+                            },
+                        },
+                    },
+                };
+                const protocol = protocolDefinition.protocol;
+                await installProtocol({ author: alice, definition: protocolDefinition });
+                const community = await writeProtocolRecord({
+                    author: alice,
+                    protocol,
+                    protocolPath: 'community',
+                    dateCreated: '2025-01-01T00:00:00.000000Z',
+                });
+                const channel1 = await writeProtocolRecord({
+                    author: alice,
+                    protocol,
+                    protocolPath: 'community/channel',
+                    parentContextId: community.message.contextId,
+                    dateCreated: '2025-01-02T00:00:00.000000Z',
+                });
+                const channel2 = await writeProtocolRecord({
+                    author: alice,
+                    protocol,
+                    protocolPath: 'community/channel',
+                    parentContextId: community.message.contextId,
+                    dateCreated: '2025-01-03T00:00:00.000000Z',
+                });
+                const { cursor: cursorBeforeMessages } = await eventLog.read(alice.did);
+                // Creation times are interleaved across channels so pagination proves
+                // that projection happens per direct parent before global ordering.
+                // Channel 2 arrives newest-first to prove occupancy ignores arrival order.
+                const channel1Messages = [
+                    await writeProtocolRecord({
+                        author: alice,
+                        protocol,
+                        protocolPath: 'community/channel/message',
+                        parentContextId: channel1.message.contextId,
+                        dateCreated: '2025-02-01T00:00:00.000000Z',
+                    }),
+                    await writeProtocolRecord({
+                        author: alice,
+                        protocol,
+                        protocolPath: 'community/channel/message',
+                        parentContextId: channel1.message.contextId,
+                        published: true,
+                        dateCreated: '2025-02-04T00:00:00.000000Z',
+                    }),
+                    await writeProtocolRecord({
+                        author: alice,
+                        protocol,
+                        protocolPath: 'community/channel/message',
+                        parentContextId: channel1.message.contextId,
+                        published: true,
+                        dateCreated: '2025-02-06T00:00:00.000000Z',
+                    }),
+                ];
+                const channel2Tie1 = await writeProtocolRecord({
+                    author: alice,
+                    protocol,
+                    protocolPath: 'community/channel/message',
+                    parentContextId: channel2.message.contextId,
+                    published: true,
+                    dateCreated: '2025-02-03T00:00:00.000000Z',
+                });
+                const channel2Tie2 = await writeProtocolRecord({
+                    author: alice,
+                    protocol,
+                    protocolPath: 'community/channel/message',
+                    parentContextId: channel2.message.contextId,
+                    published: true,
+                    dateCreated: '2025-02-03T00:00:00.000000Z',
+                });
+                const channel2Oldest = await writeProtocolRecord({
+                    author: alice,
+                    protocol,
+                    protocolPath: 'community/channel/message',
+                    parentContextId: channel2.message.contextId,
+                    published: true,
+                    dateCreated: '2025-02-02T00:00:00.000000Z',
+                });
+                const channel2Messages = [channel2Oldest, channel2Tie1, channel2Tie2];
+                const channel2BoundaryOccupant = channel2Messages[1].message.recordId < channel2Messages[2].message.recordId
+                    ? channel2Messages[1]
+                    : channel2Messages[2];
+                const expectedRecordIds = [
+                    channel1Messages[0].message.recordId,
+                    channel2Messages[0].message.recordId,
+                    channel2BoundaryOccupant.message.recordId,
+                    channel1Messages[1].message.recordId,
+                ];
+                const queryInput = {
+                    author: alice,
+                    protocol,
+                    protocolPath: 'community/channel/message',
+                    contextId: community.message.contextId,
+                };
+                expect((await queryProtocolRecordIds(queryInput)).recordIds).toEqual(expectedRecordIds);
+                expect((await queryProtocolRecordIds({
+                    ...queryInput,
+                    dateSort: DateSort.CreatedDescending,
+                })).recordIds).toEqual([...expectedRecordIds].reverse());
+                expect(await countProtocolRecords(queryInput)).toBe(expectedRecordIds.length);
+                expect(await subscribeSnapshotRecordIds(queryInput)).toEqual(expectedRecordIds);
+                const page1 = await queryProtocolRecordIds({ ...queryInput, pagination: { limit: 2 } });
+                expect(page1.recordIds).toEqual(expectedRecordIds.slice(0, 2));
+                expect(page1.cursor).toBeDefined();
+                const page2 = await queryProtocolRecordIds({
+                    ...queryInput,
+                    pagination: { limit: 2, cursor: page1.cursor },
+                });
+                expect(page2.recordIds).toEqual(expectedRecordIds.slice(2));
+                expect(page2.cursor).toBeUndefined();
+                const descendingPage1 = await queryProtocolRecordIds({
+                    ...queryInput,
+                    dateSort: DateSort.CreatedDescending,
+                    pagination: { limit: 2 },
+                });
+                expect(descendingPage1.recordIds).toEqual([...expectedRecordIds].reverse().slice(0, 2));
+                expect(descendingPage1.cursor).toBeDefined();
+                const descendingPage2 = await queryProtocolRecordIds({
+                    ...queryInput,
+                    dateSort: DateSort.CreatedDescending,
+                    pagination: { limit: 2, cursor: descendingPage1.cursor },
+                });
+                expect(descendingPage2.recordIds).toEqual([...expectedRecordIds].reverse().slice(2));
+                expect(descendingPage2.cursor).toBeUndefined();
+                // Occupancy is ranked before requester visibility. The unpublished
+                // first channel-1 occupant still consumes a slot, so the later
+                // published over-limit candidate must remain hidden anonymously.
+                const publishedFilter = {
+                    contextId: community.message.contextId,
+                    protocol,
+                    protocolPath: 'community/channel/message',
+                    published: true,
+                };
+                const anonymousQuery = await TestDataGenerator.generateRecordsQuery({
+                    anonymous: true,
+                    filter: publishedFilter,
+                });
+                const anonymousReply = await dwn.processMessage(alice.did, anonymousQuery.message);
+                expect(anonymousReply.status.code).toBe(200);
+                expect(anonymousReply.entries?.map((entry) => entry.recordId)).toEqual([
+                    channel2Messages[0].message.recordId,
+                    channel2BoundaryOccupant.message.recordId,
+                    channel1Messages[1].message.recordId,
+                ]);
+                const anonymousCount = await TestDataGenerator.generateRecordsCount({
+                    anonymous: true,
+                    filter: publishedFilter,
+                });
+                const anonymousCountReply = await dwn.processMessage(alice.did, anonymousCount.message);
+                expect(anonymousCountReply.status.code).toBe(200);
+                expect(anonymousCountReply.count).toBe(3);
+                const replayedRecordIds = [];
+                const cursorSubscribe = await TestDataGenerator.generateRecordsSubscribe({
+                    author: alice,
+                    cursor: cursorBeforeMessages,
+                    filter: {
+                        contextId: community.message.contextId,
+                        protocol,
+                        protocolPath: 'community/channel/message',
+                    },
+                });
+                const cursorSubscribeReply = await dwn.processMessage(alice.did, cursorSubscribe.message, {
+                    subscriptionHandler: (subscriptionMessage) => {
+                        if (subscriptionMessage.type === 'event' && subscriptionMessage.event.message.descriptor.method === 'Write') {
+                            replayedRecordIds.push(subscriptionMessage.event.message.recordId);
+                        }
+                    },
+                });
+                expect(cursorSubscribeReply.status.code).toBe(200);
+                await Poller.pollUntilSuccessOrTimeout(async () => {
+                    expect(replayedRecordIds).toHaveLength(expectedRecordIds.length);
+                });
+                expect([...replayedRecordIds].sort()).toEqual([...expectedRecordIds].sort());
+                await cursorSubscribeReply.subscription?.close();
+                const deleteChannel1Occupant = await TestDataGenerator.generateRecordsDelete({
+                    author: alice,
+                    recordId: channel1Messages[0].message.recordId,
+                });
+                const deleteReply = await dwn.processMessage(alice.did, deleteChannel1Occupant.message);
+                expect(deleteReply.status.code).toBe(202);
+                const expectedAfterPromotion = [
+                    channel2Messages[0].message.recordId,
+                    channel2BoundaryOccupant.message.recordId,
+                    channel1Messages[1].message.recordId,
+                    channel1Messages[2].message.recordId,
+                ];
+                expect((await queryProtocolRecordIds(queryInput)).recordIds).toEqual(expectedAfterPromotion);
+                expect((await queryProtocolRecordIds({
+                    author: alice,
+                    protocol,
+                    protocolPath: 'community/channel/message',
+                    contextId: channel2.message.contextId,
+                })).recordIds).toEqual([
+                    channel2Messages[0].message.recordId,
+                    channel2BoundaryOccupant.message.recordId,
+                ]);
+            });
             it('should paginate over the projected occupant set for max:N scopes', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
                 const protocolDefinition = {
@@ -508,7 +701,7 @@ export function testRecordsRecordLimit() {
                     types: { item: {} },
                     structure: {
                         item: {
-                            $recordLimit: { max: 3, strategy: 'reject' },
+                            $recordLimit: { max: 3 },
                         }
                     }
                 };
@@ -551,7 +744,7 @@ export function testRecordsRecordLimit() {
                     types: { status: {} },
                     structure: {
                         status: {
-                            $recordLimit: { max: 1, strategy: 'reject' },
+                            $recordLimit: { max: 1 },
                         }
                     }
                 };
@@ -633,10 +826,10 @@ export function testRecordsRecordLimit() {
                         },
                         structure: {
                             note: {
-                                $recordLimit: { max: 2, strategy: 'reject' },
+                                $recordLimit: { max: 2 },
                             },
                             profile: {
-                                $recordLimit: { max: 1, strategy: 'reject' },
+                                $recordLimit: { max: 1 },
                             }
                         }
                     };
@@ -712,7 +905,7 @@ export function testRecordsRecordLimit() {
                     types: { blob: {} },
                     structure: {
                         blob: {
-                            $recordLimit: { max: 1, strategy: 'reject' },
+                            $recordLimit: { max: 1 },
                         }
                     }
                 };
@@ -734,30 +927,6 @@ export function testRecordsRecordLimit() {
                     record.message.recordId,
                 ]);
             });
-            it('should reject purgeOldest strategy at write time with not-implemented error', async () => {
-                const alice = await TestDataGenerator.generateDidKeyPersona();
-                const protocolDefinition = {
-                    protocol: `http://record-limit-${TestDataGenerator.randomString(12)}.xyz`,
-                    published: true,
-                    types: { blob: {} },
-                    structure: {
-                        blob: {
-                            $recordLimit: { max: 1, strategy: 'purgeOldest' },
-                        }
-                    }
-                };
-                const protocol = protocolDefinition.protocol;
-                await installProtocol({ author: alice, definition: protocolDefinition });
-                const record = await TestDataGenerator.generateRecordsWrite({
-                    author: alice,
-                    recipient: alice.did,
-                    protocol,
-                    protocolPath: 'blob',
-                });
-                const reply = await dwn.processMessage(alice.did, record.message, { dataStream: record.dataStream });
-                expect(reply.status.code).toBe(400);
-                expect(reply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationRecordLimitStrategyNotImplemented);
-            });
         });
     });
 }