@enbox/dwn-sdk-js 0.0.7 → 0.1.0

package/dist/esm/tests/handlers/records-query.spec.js

@@ -14,11 +14,11 @@ import { Message } from '../../src/core/message.js';
 import { RecordsQuery } from '../../src/interfaces/records-query.js';
 import { RecordsQueryHandler } from '../../src/handlers/records-query.js';
 import { RecordsWriteHandler } from '../../src/handlers/records-write.js';
-import { TestDataGenerator } from '../utils/test-data-generator.js';
-import { TestEventStream } from '../test-event-stream.js';
+import { TestEventLog } from '../test-event-stream.js';
 import { TestStores } from '../test-stores.js';
 import { TestStubGenerator } from '../utils/test-stub-generator.js';
-import { DataStoreLevel, Dwn, MessageStoreLevel, RecordsWrite, Time } from '../../src/index.js';
+import { CoreProtocolRegistry, DataStoreLevel, Dwn, MessageStoreLevel, ProtocolsConfigure, RecordsWrite, Time } from '../../src/index.js';
+import { defaultTestProtocolDefinition, TestDataGenerator } from '../utils/test-data-generator.js';
 import { DidKey, UniversalResolver } from '@enbox/dids';
 export function testRecordsQueryHandler() {
     describe('RecordsQueryHandler.handle()', () => {
@@ -31,7 +31,7 @@ export function testRecordsQueryHandler() {
             let dataStore;
             let resumableTaskStore;
             let stateIndex;
-            let eventStream;
+            let eventLog;
             let dwn;
             // important to follow the `before` and `after` pattern to initialize and clean the stores in tests
             // so that different test suites can reuse the same backend store for testing
@@ -42,8 +42,9 @@ export function testRecordsQueryHandler() {
                 dataStore = stores.dataStore;
                 resumableTaskStore = stores.resumableTaskStore;
                 stateIndex = stores.stateIndex;
-                eventStream = TestEventStream.get();
-                dwn = await Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventStream, resumableTaskStore });
+                eventLog = TestEventLog.get();
+                eventLog = TestEventLog.get();
+                dwn = await Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventLog, resumableTaskStore });
             });
             beforeEach(async () => {
                 // clean up before each test rather than after so that a test does not depend on other tests to do the clean up
@@ -77,6 +78,7 @@ export function testRecordsQueryHandler() {
                 const alice = await TestDataGenerator.generatePersona();
                 const bob = await TestDataGenerator.generatePersona();
                 TestStubGenerator.stubDidResolver(didResolver, [alice, bob]);
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const dataFormat = 'myAwesomeDataFormat';
                 const write = await TestDataGenerator.generateRecordsWrite({ author: alice, attesters: [bob], dataFormat });
                 const writeReply = await dwn.processMessage(alice.did, write.message, { dataStream: write.dataStream });
@@ -101,6 +103,7 @@ export function testRecordsQueryHandler() {
                 const mockResolution = TestDataGenerator.createDidResolutionResult(alice);
                 ;
                 sinon.stub(didResolver, 'resolve').resolves(mockResolution);
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // insert data
                 const writeReply1 = await dwn.processMessage(alice.did, write1.message, { dataStream: write1.dataStream });
                 const writeReply2 = await dwn.processMessage(alice.did, write2.message, { dataStream: write2.dataStream });
@@ -128,6 +131,7 @@ export function testRecordsQueryHandler() {
             it('should return `encodedData` if data size is within the spec threshold', async () => {
                 const data = TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded); // within/on threshold
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const write = await TestDataGenerator.generateRecordsWrite({ author: alice, data });
                 const writeReply = await dwn.processMessage(alice.did, write.message, { dataStream: write.dataStream });
                 expect(writeReply.status.code).toBe(202);
@@ -140,6 +144,7 @@ export function testRecordsQueryHandler() {
             it('should not return `encodedData` if data size is greater then spec threshold', async () => {
                 const data = TestDataGenerator.randomBytes(DwnConstant.maxDataSizeAllowedToBeEncoded + 1); // exceeding threshold
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const write = await TestDataGenerator.generateRecordsWrite({ author: alice, data });
                 const writeReply = await dwn.processMessage(alice.did, write.message, { dataStream: write.dataStream });
                 expect(writeReply.status.code).toBe(202);
@@ -151,6 +156,7 @@ export function testRecordsQueryHandler() {
             });
             it('should include `initialWrite` property if RecordsWrite is not initial write', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const write = await TestDataGenerator.generateRecordsWrite({ author: alice, published: false });
                 const writeReply = await dwn.processMessage(alice.did, write.message, { dataStream: write.dataStream });
                 expect(writeReply.status.code).toBe(202);
@@ -170,6 +176,7 @@ export function testRecordsQueryHandler() {
                 // scenario: 2 records authored by alice, 1st attested by alice, 2nd attested by bob
                 const alice = await TestDataGenerator.generateDidKeyPersona();
                 const bob = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const recordsWrite1 = await TestDataGenerator.generateRecordsWrite({ author: alice, attesters: [alice] });
                 const recordsWrite2 = await TestDataGenerator.generateRecordsWrite({ author: alice, attesters: [bob] });
                 // insert data
@@ -393,6 +400,7 @@ export function testRecordsQueryHandler() {
             it('should be able to query for published records', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
                 const bob = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // create a published record
                 const publishedWrite = await TestDataGenerator.generateRecordsWrite({ author: alice, published: true, schema: 'post' });
                 const publishedWriteReply = await dwn.processMessage(alice.did, publishedWrite.message, { dataStream: publishedWrite.dataStream });
@@ -449,6 +457,7 @@ export function testRecordsQueryHandler() {
             });
             it('should be able to query for unpublished records', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // create a published record
                 const publishedWrite = await TestDataGenerator.generateRecordsWrite({ author: alice, published: true, schema: 'post' });
                 const publishedWriteReply = await dwn.processMessage(alice.did, publishedWrite.message, { dataStream: publishedWrite.dataStream });
@@ -479,6 +488,7 @@ export function testRecordsQueryHandler() {
             it('should not be able to query for unpublished records if unauthorized', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
                 const bob = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // create a published record
                 const publishedWrite = await TestDataGenerator.generateRecordsWrite({ author: alice, published: true, schema: 'post' });
                 const publishedWriteReply = await dwn.processMessage(alice.did, publishedWrite.message, { dataStream: publishedWrite.dataStream });
@@ -517,6 +527,7 @@ export function testRecordsQueryHandler() {
             });
             it('should be able to query for a record by a dataCid', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // create a record
                 const writeRecord = await TestDataGenerator.generateRecordsWrite({ author: alice });
                 const writeRecordReply = await dwn.processMessage(alice.did, writeRecord.message, { dataStream: writeRecord.dataStream });
@@ -531,6 +542,7 @@ export function testRecordsQueryHandler() {
             });
             it('should be able to query with `dataSize` filter (half-open range)', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const write1 = await TestDataGenerator.generateRecordsWrite({ author: alice, data: TestDataGenerator.randomBytes(10) });
                 const write2 = await TestDataGenerator.generateRecordsWrite({ author: alice, data: TestDataGenerator.randomBytes(50) });
                 const write3 = await TestDataGenerator.generateRecordsWrite({ author: alice, data: TestDataGenerator.randomBytes(100) });
@@ -590,6 +602,7 @@ export function testRecordsQueryHandler() {
             });
             it('should be able to range query with `dataSize` filter (open & closed range)', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const write1 = await TestDataGenerator.generateRecordsWrite({ author: alice, data: TestDataGenerator.randomBytes(10) });
                 const write2 = await TestDataGenerator.generateRecordsWrite({ author: alice, data: TestDataGenerator.randomBytes(50) });
                 const write3 = await TestDataGenerator.generateRecordsWrite({ author: alice, data: TestDataGenerator.randomBytes(100) });
@@ -642,6 +655,7 @@ export function testRecordsQueryHandler() {
                 const firstDayOf2022 = Time.createTimestamp({ year: 2022, month: 1, day: 1 });
                 const firstDayOf2023 = Time.createTimestamp({ year: 2023, month: 1, day: 1 });
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const write1 = await TestDataGenerator.generateRecordsWrite({ author: alice, dateCreated: firstDayOf2021, messageTimestamp: firstDayOf2021 });
                 const write2 = await TestDataGenerator.generateRecordsWrite({ author: alice, dateCreated: firstDayOf2022, messageTimestamp: firstDayOf2022 });
                 const write3 = await TestDataGenerator.generateRecordsWrite({ author: alice, dateCreated: firstDayOf2023, messageTimestamp: firstDayOf2023 });
@@ -702,6 +716,14 @@ export function testRecordsQueryHandler() {
                 const firstDayOf2022 = Time.createTimestamp({ year: 2022, month: 1, day: 1 });
                 const firstDayOf2023 = Time.createTimestamp({ year: 2023, month: 1, day: 1 });
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                // install protocol at a timestamp before the record timestamps so temporal lookup works for updates
+                const protocolsConfigure = await ProtocolsConfigure.create({
+                    definition: defaultTestProtocolDefinition,
+                    signer: Jws.createSigner(alice),
+                    messageTimestamp: Time.createTimestamp({ year: 2019, month: 1, day: 1 }),
+                });
+                const protoReply = await dwn.processMessage(alice.did, protocolsConfigure.message);
+                expect(protoReply.status.code).toBe(202);
                 const write1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, published: true, dateCreated: firstDayOf2020, datePublished: firstDayOf2021, messageTimestamp: firstDayOf2020
                 });
@@ -807,6 +829,7 @@ export function testRecordsQueryHandler() {
                 const firstDayOf2022 = Time.createTimestamp({ year: 2022, month: 1, day: 1 });
                 const firstDayOf2023 = Time.createTimestamp({ year: 2023, month: 1, day: 1 });
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const write1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, published: true, dateCreated: firstDayOf2020, datePublished: firstDayOf2021, messageTimestamp: firstDayOf2020
                 });
@@ -896,6 +919,14 @@ export function testRecordsQueryHandler() {
                 const firstDayOf2022 = Time.createTimestamp({ year: 2022, month: 1, day: 1 });
                 const firstDayOf2023 = Time.createTimestamp({ year: 2023, month: 1, day: 1 });
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                // install protocol at a timestamp before the record timestamps so temporal lookup works for updates
+                const protocolsConfigure = await ProtocolsConfigure.create({
+                    definition: defaultTestProtocolDefinition,
+                    signer: Jws.createSigner(alice),
+                    messageTimestamp: Time.createTimestamp({ year: 2019, month: 1, day: 1 }),
+                });
+                const protoReply = await dwn.processMessage(alice.did, protocolsConfigure.message);
+                expect(protoReply.status.code).toBe(202);
                 const write1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, dateCreated: firstDayOf2020, messageTimestamp: firstDayOf2020
                 });
@@ -989,6 +1020,7 @@ export function testRecordsQueryHandler() {
                 const firstDayOf2022 = Time.createTimestamp({ year: 2022, month: 1, day: 1 });
                 const firstDayOf2023 = Time.createTimestamp({ year: 2023, month: 1, day: 1 });
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const schema = '2021And2022Schema';
                 const write1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, dateCreated: firstDayOf2021, messageTimestamp: firstDayOf2021, schema
@@ -1027,6 +1059,7 @@ export function testRecordsQueryHandler() {
                 // setting up a stub method resolver
                 const mockResolution = TestDataGenerator.createDidResolutionResult(alice);
                 sinon.stub(didResolver, 'resolve').resolves(mockResolution);
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
                 expect(writeReply.status.code).toBe(202);
                 const queryData = await TestDataGenerator.generateRecordsQuery({
@@ -1041,6 +1074,7 @@ export function testRecordsQueryHandler() {
             it('should include `attestation` in returned records', async () => {
                 // scenario: alice and bob attest to a message alice authored
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice, attesters: [alice] });
                 const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
                 expect(writeReply.status.code).toBe(202);
@@ -1068,6 +1102,7 @@ export function testRecordsQueryHandler() {
                 const mockResolution = TestDataGenerator.createDidResolutionResult(alice);
                 ;
                 sinon.stub(didResolver, 'resolve').resolves(mockResolution);
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // insert data
                 const publishedWriteReply = await dwn.processMessage(alice.did, publishedWriteData.message, { dataStream: publishedWriteData.dataStream });
                 const unpublishedWriteReply = await dwn.processMessage(alice.did, unpublishedWriteData.message, { dataStream: unpublishedWriteData.dataStream });
@@ -1106,6 +1141,7 @@ export function testRecordsQueryHandler() {
                 const mockResolution = TestDataGenerator.createDidResolutionResult(alice);
                 ;
                 sinon.stub(didResolver, 'resolve').resolves(mockResolution);
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // insert data, intentionally out of order
                 const writeReply2 = await dwn.processMessage(alice.did, write2Data.message, { dataStream: write2Data.dataStream });
                 const writeReply1 = await dwn.processMessage(alice.did, write1Data.message, { dataStream: write1Data.dataStream });
@@ -1238,6 +1274,7 @@ export function testRecordsQueryHandler() {
             it('should sort records by `updatedAscending` and `updatedDescending`', async () => {
                 // insert three messages into DB
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const schema = 'aSchema';
                 const write1Data = await TestDataGenerator.generateRecordsWrite({ author: alice, schema });
                 await Time.minimalSleep();
@@ -1279,6 +1316,14 @@ export function testRecordsQueryHandler() {
                 // updatedAscending should return them in order of their update, not creation.
                 const createdTimestamp = Time.createTimestamp({ year: 2020, month: 1, day: 1 });
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                // install protocol at a timestamp before the record timestamps so temporal lookup works for updates
+                const protocolsConfigure = await ProtocolsConfigure.create({
+                    definition: defaultTestProtocolDefinition,
+                    signer: Jws.createSigner(alice),
+                    messageTimestamp: Time.createTimestamp({ year: 2019, month: 1, day: 1 }),
+                });
+                const protoReply = await dwn.processMessage(alice.did, protocolsConfigure.message);
+                expect(protoReply.status.code).toBe(202);
                 const schema = 'aSchema';
                 const write1 = await TestDataGenerator.generateRecordsWrite({
                     author: alice, schema, dateCreated: createdTimestamp, messageTimestamp: createdTimestamp,
@@ -1345,6 +1390,7 @@ export function testRecordsQueryHandler() {
                 const dateCreated = Time.getCurrentTimestamp();
                 const messageTimestamp = dateCreated;
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const schema = 'aSchema';
                 const published = true;
                 const write1Data = await TestDataGenerator.generateRecordsWrite({ messageTimestamp, dateCreated, author: alice, schema, published });
@@ -1384,6 +1430,7 @@ export function testRecordsQueryHandler() {
             });
             it('should paginate all records in ascending order', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const messages = await Promise.all(Array(12).fill({}).map(_ => TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     schema: 'https://schema'
@@ -1421,6 +1468,7 @@ export function testRecordsQueryHandler() {
             });
             it('should paginate all records in descending order', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const messages = await Promise.all(Array(12).fill({}).map(_ => TestDataGenerator.generateRecordsWrite({
                     author: alice,
                     schema: 'https://schema'
@@ -1461,6 +1509,7 @@ export function testRecordsQueryHandler() {
                 // 1st is unpublished
                 // 2nd is published
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const record1Data = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'https://schema1', published: false });
                 const record2Data = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'https://schema2', published: true });
                 const recordsWrite1Reply = await dwn.processMessage(alice.did, record1Data.message, { dataStream: record1Data.dataStream });
@@ -1996,7 +2045,9 @@ export function testRecordsQueryHandler() {
                     ...alicePublishedPromise,
                     ...aliceMessagesForBobPromise,
                 ];
-                const recordsWriteHandler = new RecordsWriteHandler(didResolver, messageStore, dataStore, stateIndex, eventStream);
+                const recordsWriteHandler = new RecordsWriteHandler({
+                    didResolver, messageStore, dataStore, stateIndex, coreProtocols: new CoreProtocolRegistry(), eventLog,
+                });
                 const messages = [];
                 for await (const { recordsWrite, message, dataBytes } of messagePromises) {
                     const indexes = await recordsWrite.constructIndexes(true);
@@ -2083,6 +2134,7 @@ export function testRecordsQueryHandler() {
             it('#170 - should treat records with `published` explicitly set to `false` as unpublished', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
                 const bob = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 const schema = 'schema1';
                 const unpublishedRecordsWrite = await TestDataGenerator.generateRecordsWrite({ author: alice, schema, data: Encoder.stringToBytes('1'), published: false } // explicitly setting `published` to `false`
                 );
@@ -2119,6 +2171,8 @@ export function testRecordsQueryHandler() {
                 // insert three messages into DB, two with matching schema
                 const alice = await TestDataGenerator.generateDidKeyPersona();
                 const bob = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
+                await TestDataGenerator.installDefaultTestProtocol(dwn, bob);
                 const schema = 'myAwesomeSchema';
                 const recordsWriteMessage1Data = await TestDataGenerator.generateRecordsWrite({ author: alice, schema });
                 const recordsWriteMessage2Data = await TestDataGenerator.generateRecordsWrite({ author: bob, schema });
@@ -2187,6 +2241,7 @@ export function testRecordsQueryHandler() {
             });
             it('should return 401 for anonymous queries that filter explicitly for unpublished records', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // create an unpublished record
                 const draftWrite = await TestDataGenerator.generateRecordsWrite({ author: alice, schema: 'post' });
                 const draftWriteReply = await dwn.processMessage(alice.did, draftWrite.message, { dataStream: draftWrite.dataStream });
@@ -3002,7 +3057,9 @@ export function testRecordsQueryHandler() {
             const didResolver = TestStubGenerator.createDidResolverStub(mismatchingPersona);
             const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
             const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
-            const recordsQueryHandler = new RecordsQueryHandler(didResolver, messageStoreStub, dataStoreStub);
+            const recordsQueryHandler = new RecordsQueryHandler({
+                didResolver, messageStore: messageStoreStub, dataStore: dataStoreStub,
+            });
             const reply = await recordsQueryHandler.handle({ tenant, message });
             expect(reply.status.code).toBe(401);
         });
@@ -3013,7 +3070,9 @@ export function testRecordsQueryHandler() {
             const didResolver = TestStubGenerator.createDidResolverStub(author);
             const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
             const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
-            const recordsQueryHandler = new RecordsQueryHandler(didResolver, messageStoreStub, dataStoreStub);
+            const recordsQueryHandler = new RecordsQueryHandler({
+                didResolver, messageStore: messageStoreStub, dataStore: dataStoreStub,
+            });
             // stub the `parse()` function to throw an error
             sinon.stub(RecordsQuery, 'parse').throws('anyError');
             const reply = await recordsQueryHandler.handle({ tenant, message });