@enbox/dwn-sdk-js 0.0.7 → 0.1.0

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

@@ -13,7 +13,7 @@ import { HdKey } from '../../src/utils/hd-key.js';
 import { KeyDerivationScheme } from '../../src/utils/hd-key.js';
 import { RecordsReadHandler } from '../../src/handlers/records-read.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 { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
@@ -29,7 +29,7 @@ export function testRecordsReadHandler() {
         let dataStore;
         let resumableTaskStore;
         let stateIndex;
-        let eventStream;
+        let eventLog;
         let dwn;
         beforeEach(() => {
             sinon.restore(); // wipe all previous stubs/spies/mocks/fakes
@@ -44,8 +44,8 @@ export function testRecordsReadHandler() {
                 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();
+                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
@@ -59,6 +59,7 @@ export function testRecordsReadHandler() {
             });
             it('should allow tenant to RecordsRead their own record', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // insert data
                 const { message, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({ author: alice });
                 const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
@@ -80,6 +81,7 @@ export function testRecordsReadHandler() {
             });
             it('should not allow non-tenant to RecordsRead a record', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // insert data
                 const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice });
                 const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
@@ -97,6 +99,7 @@ export function testRecordsReadHandler() {
             });
             it('should allow reading of data that is published without `authorization`', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // insert public data
                 const { message, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({ author: alice, published: true });
                 const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
@@ -115,6 +118,7 @@ export function testRecordsReadHandler() {
             });
             it('should allow an authenticated user to RecordRead data that is published', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // insert public data
                 const { message, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({ author: alice, published: true });
                 const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
@@ -135,6 +139,7 @@ export function testRecordsReadHandler() {
             it('should allow a non-tenant to read RecordsRead data they have received', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
                 const bob = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // Alice inserts data with Bob as recipient
                 const { message, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({
                     author: alice,
@@ -158,6 +163,7 @@ export function testRecordsReadHandler() {
             });
             it('should return 400 when fetching initial write for a deleted record fails', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // Write a record
                 const { message: writeMessage, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice });
                 const writeReply = await dwn.processMessage(alice.did, writeMessage, { dataStream });
@@ -295,6 +301,7 @@ export function testRecordsReadHandler() {
             });
             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);
@@ -731,6 +738,7 @@ export function testRecordsReadHandler() {
                     });
                     it('should return the earliest published record when `dateSort` is `PublishedAscending`', async () => {
                         const alice = await TestDataGenerator.generateDidKeyPersona();
+                        await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                         const schema = 'aSchema';
                         const write1 = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -758,6 +766,7 @@ export function testRecordsReadHandler() {
                     });
                     it('should return the latest published record when `dateSort` is `PublishedDescending`', async () => {
                         const alice = await TestDataGenerator.generateDidKeyPersona();
+                        await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                         const schema = 'aSchema';
                         const write1 = await TestDataGenerator.generateRecordsWrite({
                             author: alice,
@@ -1036,6 +1045,7 @@ export function testRecordsReadHandler() {
                     // scenario: Alice grants Bob access to RecordsWrite, then Bob tries to invoke the grant with RecordsRead
                     const alice = await TestDataGenerator.generateDidKeyPersona();
                     const bob = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                     // Alice writes a record which Bob will later try to read
                     const { recordsWrite, dataStream } = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -1433,6 +1443,7 @@ export function testRecordsReadHandler() {
             });
             it('should return 404 RecordRead if data has been deleted', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 // insert public data
                 const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({ author: alice, published: true });
                 const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
@@ -1464,6 +1475,7 @@ export function testRecordsReadHandler() {
             });
             it('should return 404 underlying data store cannot locate the data when data is above threshold', async () => {
                 const alice = await TestDataGenerator.generateDidKeyPersona();
+                await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                 sinon.stub(dataStore, 'get').resolves(undefined);
                 // insert data larger than the allowed amount in encodedData
                 const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({
@@ -1485,6 +1497,7 @@ export function testRecordsReadHandler() {
             describe('data from encodedData', () => {
                 it('should not get data from DataStore if encodedData exists', async () => {
                     const alice = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                     //since the data is at the threshold it will be returned from the messageStore in the `encodedData` field.
                     const { message, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -1509,6 +1522,7 @@ export function testRecordsReadHandler() {
                 });
                 it('should get data from DataStore if encodedData does not exist', async () => {
                     const alice = await TestDataGenerator.generateDidKeyPersona();
+                    await TestDataGenerator.installDefaultTestProtocol(dwn, alice);
                     //since the data is over the threshold it will not be returned from the messageStore in the `encodedData` field.
                     const { message, dataStream, dataBytes } = await TestDataGenerator.generateRecordsWrite({
                         author: alice,
@@ -1533,138 +1547,6 @@ export function testRecordsReadHandler() {
                 });
             });
             describe('encryption scenarios', () => {
-                it('should be able to decrypt flat-space schema-contained record with a correct derived key', async () => {
-                    // scenario: Alice writes into her own DWN an encrypted record and she is able to decrypt it
-                    const alice = await TestDataGenerator.generatePersona();
-                    TestStubGenerator.stubDidResolver(didResolver, [alice]);
-                    // encrypt Alice's record
-                    const originalData = TestDataGenerator.randomBytes(1000);
-                    const dataEncryptionInitializationVector = TestDataGenerator.randomBytes(12);
-                    const dataEncryptionKey = TestDataGenerator.randomBytes(32);
-                    const { ciphertext: encryptedDataBytes, tag: authenticationTag } = await Encryption.aeadEncrypt(ContentEncryptionAlgorithm.A256GCM, dataEncryptionKey, dataEncryptionInitializationVector, originalData);
-                    // TODO: #450 - Should not require a root key to specify the derivation scheme (https://github.com/enboxorg/enbox/issues/450)
-                    const rootPrivateKeyWithSchemasScheme = {
-                        rootKeyId: alice.keyId,
-                        derivationScheme: KeyDerivationScheme.Schemas,
-                        derivedPrivateKey: alice.encryptionKeyPair.privateJwk
-                    };
-                    const schema = 'https://some-schema.com';
-                    const schemaDerivationPath = Records.constructKeyDerivationPathUsingSchemasScheme(schema);
-                    const schemaDerivedPrivateKey = await HdKey.derivePrivateKey(rootPrivateKeyWithSchemasScheme, schemaDerivationPath);
-                    const schemaDerivedPublicKey = await HdKey.derivePublicKey(rootPrivateKeyWithSchemasScheme, schemaDerivationPath);
-                    const rootPrivateKeyWithDataFormatsScheme = {
-                        rootKeyId: alice.keyId,
-                        derivationScheme: KeyDerivationScheme.DataFormats,
-                        derivedPrivateKey: alice.encryptionKeyPair.privateJwk
-                    };
-                    const dataFormat = 'some/format';
-                    const dataFormatDerivationPath = Records.constructKeyDerivationPathUsingDataFormatsScheme(dataFormat);
-                    const dataFormatDerivedPublicKey = await HdKey.derivePublicKey(rootPrivateKeyWithDataFormatsScheme, dataFormatDerivationPath);
-                    const encryptionInput = {
-                        initializationVector: dataEncryptionInitializationVector,
-                        key: dataEncryptionKey,
-                        authenticationTag,
-                        keyEncryptionInputs: [{
-                                publicKeyId: alice.keyId, // reusing signing key for encryption purely as a convenience
-                                publicKey: schemaDerivedPublicKey,
-                                derivationScheme: KeyDerivationScheme.Schemas
-                            },
-                            {
-                                publicKeyId: alice.keyId, // reusing signing key for encryption purely as a convenience
-                                publicKey: dataFormatDerivedPublicKey,
-                                derivationScheme: KeyDerivationScheme.DataFormats
-                            }]
-                    };
-                    const { message, dataStream } = await TestDataGenerator.generateRecordsWrite({
-                        author: alice,
-                        schema,
-                        dataFormat,
-                        data: encryptedDataBytes,
-                        encryptionInput
-                    });
-                    const writeReply = await dwn.processMessage(alice.did, message, { dataStream });
-                    expect(writeReply.status.code).toBe(202);
-                    const recordsRead = await RecordsRead.create({
-                        filter: {
-                            recordId: message.recordId,
-                        },
-                        signer: Jws.createSigner(alice)
-                    });
-                    // test able to derive correct key using `schemas` scheme from root key to decrypt the message
-                    const readReply = await dwn.processMessage(alice.did, recordsRead.message);
-                    expect(readReply.status.code).toBe(200);
-                    const recordsWriteMessage = readReply.entry.recordsWrite;
-                    const cipherStream = readReply.entry.data;
-                    const plaintextDataStream = await Records.decrypt(recordsWriteMessage, schemaDerivedPrivateKey, cipherStream);
-                    const plaintextBytes = await DataStream.toBytes(plaintextDataStream);
-                    expect(ArrayUtility.byteArraysEqual(plaintextBytes, originalData)).toBe(true);
-                    // test able to derive correct key using `dataFormat` scheme from root key to decrypt the message
-                    const readReply2 = await dwn.processMessage(alice.did, recordsRead.message); // send the same read message to get a new cipher stream
-                    expect(readReply2.status.code).toBe(200);
-                    const cipherStream2 = readReply2.entry.data;
-                    const plaintextDataStream2 = await Records.decrypt(recordsWriteMessage, rootPrivateKeyWithDataFormatsScheme, cipherStream2);
-                    const plaintextBytes2 = await DataStream.toBytes(plaintextDataStream2);
-                    expect(ArrayUtility.byteArraysEqual(plaintextBytes2, originalData)).toBe(true);
-                    // test unable to decrypt the message if dataFormat-derived key uses an incorrect data format in derivation path
-                    const readReply3 = await dwn.processMessage(alice.did, recordsRead.message); // process the same read message to get a new cipher stream
-                    expect(readReply3.status.code).toBe(200);
-                    const cipherStream3 = readReply3.entry.data;
-                    const invalidDerivationPath = [KeyDerivationScheme.DataFormats, 'wrong/format'];
-                    const inValidDescendantPrivateKey = await HdKey.derivePrivateKey(rootPrivateKeyWithDataFormatsScheme, invalidDerivationPath);
-                    await expect(Records.decrypt(recordsWriteMessage, inValidDescendantPrivateKey, cipherStream3)).rejects.toThrow(DwnErrorCode.RecordsInvalidAncestorKeyDerivationSegment);
-                });
-                it('should be able to decrypt flat-space schema-less record with the correct derived key', async () => {
-                    // scenario: Alice writes into her own DWN an encrypted record and she is able to decrypt it
-                    const alice = await TestDataGenerator.generatePersona();
-                    TestStubGenerator.stubDidResolver(didResolver, [alice]);
-                    // encrypt Alice's record
-                    const originalData = TestDataGenerator.randomBytes(1000);
-                    const dataEncryptionInitializationVector = TestDataGenerator.randomBytes(12);
-                    const dataEncryptionKey = TestDataGenerator.randomBytes(32);
-                    const { ciphertext: encryptedDataBytes, tag: authenticationTag } = await Encryption.aeadEncrypt(ContentEncryptionAlgorithm.A256GCM, dataEncryptionKey, dataEncryptionInitializationVector, originalData);
-                    // TODO: #450 - Should not require a root key to specify the derivation scheme (https://github.com/enboxorg/enbox/issues/450)
-                    const rootPrivateKeyWithDataFormatsScheme = {
-                        rootKeyId: alice.keyId,
-                        derivationScheme: KeyDerivationScheme.DataFormats,
-                        derivedPrivateKey: alice.encryptionKeyPair.privateJwk
-                    };
-                    const dataFormat = `image/jpg`;
-                    const dataFormatDerivationPath = Records.constructKeyDerivationPathUsingDataFormatsScheme(dataFormat);
-                    const dataFormatDerivedPublicKey = await HdKey.derivePublicKey(rootPrivateKeyWithDataFormatsScheme, dataFormatDerivationPath);
-                    const encryptionInput = {
-                        initializationVector: dataEncryptionInitializationVector,
-                        key: dataEncryptionKey,
-                        authenticationTag,
-                        keyEncryptionInputs: [{
-                                publicKeyId: alice.keyId, // reusing signing key for encryption purely as a convenience
-                                publicKey: dataFormatDerivedPublicKey,
-                                derivationScheme: KeyDerivationScheme.DataFormats
-                            }]
-                    };
-                    const recordsWrite = await RecordsWrite.create({
-                        signer: Jws.createSigner(alice),
-                        dataFormat,
-                        data: encryptedDataBytes,
-                        encryptionInput
-                    });
-                    const dataStream = DataStream.fromBytes(encryptedDataBytes);
-                    const writeReply = await dwn.processMessage(alice.did, recordsWrite.message, { dataStream });
-                    expect(writeReply.status.code).toBe(202);
-                    const recordsRead = await RecordsRead.create({
-                        filter: {
-                            recordId: recordsWrite.message.recordId,
-                        },
-                        signer: Jws.createSigner(alice)
-                    });
-                    // test able to derive correct key using `dataFormat` scheme from root key to decrypt the message
-                    const readReply = await dwn.processMessage(alice.did, recordsRead.message); // send the same read message to get a new cipher stream
-                    expect(readReply.status.code).toBe(200);
-                    const cipherStream = readReply.entry.data;
-                    const recordsWriteMessage = readReply.entry.recordsWrite;
-                    const plaintextDataStream = await Records.decrypt(recordsWriteMessage, rootPrivateKeyWithDataFormatsScheme, cipherStream);
-                    const plaintextBytes = await DataStream.toBytes(plaintextDataStream);
-                    expect(ArrayUtility.byteArraysEqual(plaintextBytes, originalData)).toBe(true);
-                });
                 it('should only be able to decrypt record with a correct derived private key  - `protocol-context` derivation scheme', async () => {
                     // scenario: Bob initiated an encrypted chat thread with Alice,
                     // bob is able to decrypt subsequent messages from Alice using the `protocol-context` derived private key
@@ -1912,7 +1794,9 @@ export function testRecordsReadHandler() {
             const didResolver = TestStubGenerator.createDidResolverStub(mismatchingPersona);
             const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
             const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
-            const recordsReadHandler = new RecordsReadHandler(didResolver, messageStoreStub, dataStoreStub);
+            const recordsReadHandler = new RecordsReadHandler({
+                didResolver, messageStore: messageStoreStub, dataStore: dataStoreStub,
+            });
             const reply = await recordsReadHandler.handle({ tenant: alice.did, message: recordsRead.message });
             expect(reply.status.code).toBe(401);
         });
@@ -1927,7 +1811,9 @@ export function testRecordsReadHandler() {
             // setting up a stub method resolver & message store
             const messageStoreStub = sinon.createStubInstance(MessageStoreLevel);
             const dataStoreStub = sinon.createStubInstance(DataStoreLevel);
-            const recordsReadHandler = new RecordsReadHandler(didResolver, messageStoreStub, dataStoreStub);
+            const recordsReadHandler = new RecordsReadHandler({
+                didResolver, messageStore: messageStoreStub, dataStore: dataStoreStub,
+            });
             // stub the `parse()` function to throw an error
             sinon.stub(RecordsRead, 'parse').throws('anyError');
             const reply = await recordsReadHandler.handle({ tenant: alice.did, message: recordsRead.message });