@learncard/network-brain-service 3.19.0 → 4.0.0

package/src/accesslayer/credential/create.test.ts

@@ -1,19 +1,12 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import type { JWE, VC } from '@learncard/types';
+import type { JWE } from '@learncard/types';
 import type { IssuedCredential } from '../../types/credential';
 
-const mocks = vi.hoisted(() => ({ createOne: vi.fn(async input => input) }));
+const mocks = vi.hoisted(() => ({ createOne: vi.fn() }));
 vi.mock('@models', () => ({ Credential: { createOne: mocks.createOne } }));
 
 import { storeCredential } from './create';
 
-const statusEntry = {
-    id: 'https://network.example/status/1#42',
-    type: 'BitstringStatusListEntry' as const,
-    statusPurpose: 'revocation' as const,
-    statusListIndex: '42',
-    statusListCredential: 'https://network.example/status/1',
-};
 const createJwe = (): JWE => ({
     protected: 'header',
     iv: 'iv',
@@ -21,121 +14,15 @@ const createJwe = (): JWE => ({
     tag: 'tag',
     recipients: [],
 });
-const createVc = (): VC => ({
-    '@context': ['https://www.w3.org/2018/credentials/v1'],
-    type: ['VerifiableCredential'],
-    issuer: 'did:example:issuer',
-    issuanceDate: '2026-01-01T00:00:00Z',
-    credentialSubject: { id: 'did:example:subject' },
-    proof: {
-        type: 'Ed25519Signature2020',
-        created: '2026-01-01T00:00:00Z',
-        proofPurpose: 'assertionMethod',
-        verificationMethod: 'did:example:issuer#key-1',
-        proofValue: 'existing-signature',
-    },
-});
 
 describe('credential status storage', () => {
     beforeEach(() => {
-        vi.restoreAllMocks();
         vi.clearAllMocks();
     });
 
-    it('persists public status coordinates after serializing an issuance result', async () => {
-        const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
-        const jwe = createJwe();
-        const issued: IssuedCredential = {
-            kind: 'issued-credential',
-            credential: jwe,
-            statusEntries: [statusEntry],
-        };
-        await storeCredential(JSON.parse(JSON.stringify(issued)));
-        expect(mocks.createOne).toHaveBeenCalledWith(
-            expect.objectContaining({
-                credential: JSON.stringify(jwe),
-                statusEntries: JSON.stringify([statusEntry]),
-            })
-        );
-        expect(warn).not.toHaveBeenCalled();
-    });
-
-    it('warns when a client-encrypted JWE has no metadata, without logging its payload', async () => {
-        const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
-        const original = createJwe();
-        const jwe = { ...original };
-        await storeCredential(jwe);
-        expect(warn).toHaveBeenCalledExactlyOnceWith(
-            expect.stringContaining('Encrypted credential has no status metadata'),
-            { credentialId: expect.any(String) }
-        );
-        expect(mocks.createOne.mock.calls[0]![0].statusEntries).toBeUndefined();
-        expect(mocks.createOne.mock.calls[0]![0].credential).toBe(JSON.stringify(jwe));
-    });
-
     it('rejects internal issuance results that lost their status metadata before writing', async () => {
         const issued = { kind: 'issued-credential', credential: createJwe() } as IssuedCredential;
         await expect(storeCredential(issued)).rejects.toThrow();
         expect(mocks.createOne).not.toHaveBeenCalled();
     });
-
-    it.each([undefined, []])(
-        'warns for a pre-signed plaintext VC with missing or empty status (%j) and preserves its signature',
-        async credentialStatus => {
-            const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
-            const credential = { ...createVc(), credentialStatus };
-            const stored = await storeCredential(credential);
-            expect(warn).toHaveBeenCalledExactlyOnceWith(
-                expect.stringContaining('Plaintext credential has no status metadata'),
-                { credentialId: stored.id }
-            );
-            expect(stored.credential).toBe(JSON.stringify(credential));
-            expect(stored.statusEntries).toBeUndefined();
-        }
-    );
-
-    it.each([statusEntry, [statusEntry]])(
-        'does not warn for a plaintext VC with embedded status entries (%j)',
-        async credentialStatus => {
-            const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
-            const credential = { ...createVc(), credentialStatus };
-            const stored = await storeCredential(credential);
-            expect(warn).not.toHaveBeenCalled();
-            expect(stored.credential).toBe(JSON.stringify(credential));
-        }
-    );
-
-    it.each([
-        ['Encrypted', createJwe()],
-        ['Plaintext', createVc()],
-    ] as const)(
-        'warns for %s VC v1 issuance with empty status metadata',
-        async (kind, credential) => {
-            const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
-            const stored = await storeCredential({
-                kind: 'issued-credential',
-                credential,
-                statusEntries: [],
-            });
-            expect(warn).toHaveBeenCalledExactlyOnceWith(
-                expect.stringContaining(`${kind} credential has no status metadata`),
-                { credentialId: stored.id }
-            );
-            expect(stored.credential).toBe(JSON.stringify(credential));
-            expect(stored.statusEntries).toBeUndefined();
-        }
-    );
-
-    it('does not treat a wire JWE with extra envelope-like fields as trusted issuance metadata', async () => {
-        vi.spyOn(console, 'warn').mockImplementation(() => {});
-        const jwe = {
-            ...createJwe(),
-            kind: 'issued-credential',
-            credential: createJwe(),
-            statusEntries: [statusEntry],
-        };
-        await storeCredential(jwe);
-        expect(mocks.createOne.mock.calls[0]![0].statusEntries).toBeUndefined();
-        expect(mocks.createOne.mock.calls[0]![0].credential).toBe(JSON.stringify(jwe));
-    });
 });

package/src/accesslayer/credential/create.ts

@@ -1,4 +1,5 @@
 import { BitstringStatusListEntryValidator, UnsignedVC, VC, JWE } from '@learncard/types';
+import type { Transaction } from 'neo4j-driver';
 import { v4 as uuid } from 'uuid';
 import { getBitstringStatusListEntries, isEncrypted } from '@learncard/helpers';
 import { isIssuedCredential } from '@helpers/issuedCredentialStatus.helpers';
@@ -7,7 +8,8 @@ import type { IssuedCredential } from 'types/credential';
 import { Credential, CredentialInstance } from '@models';
 
 export const storeCredential = async (
-    input: UnsignedVC | VC | JWE | IssuedCredential
+    input: UnsignedVC | VC | JWE | IssuedCredential,
+    transaction?: Transaction
 ): Promise<CredentialInstance> => {
     const id = uuid();
 
@@ -28,9 +30,12 @@ export const storeCredential = async (
             { credentialId: id }
         );
     }
-    return Credential.createOne({
-        id,
-        credential: JSON.stringify(credential),
-        ...(statusEntries?.length ? { statusEntries: JSON.stringify(statusEntries) } : {}),
-    });
+    return Credential.createOne(
+        {
+            id,
+            credential: JSON.stringify(credential),
+            ...(statusEntries?.length ? { statusEntries: JSON.stringify(statusEntries) } : {}),
+        },
+        transaction ? { session: transaction } : undefined
+    );
 };

package/src/accesslayer/credential/relationships/create.ts

@@ -1,4 +1,6 @@
+import { termsReferralSnapshotCypher } from '@helpers/consent-referral.helpers';
 import { QueryBuilder, BindParam } from 'neogma';
+import type { Transaction } from 'neo4j-driver';
 import { v4 as uuid } from 'uuid';
 
 import {
@@ -24,7 +26,8 @@ export const createSentCredentialRelationship = async (
     credential: CredentialInstance,
     metadata?: Record<string, unknown>,
     activityId?: string,
-    integrationId?: string
+    integrationId?: string,
+    transaction?: Transaction
 ): Promise<void> => {
     const properties = flattenObject({
         to: to.profileId,
@@ -57,12 +60,10 @@ export const createSentCredentialRelationship = async (
             ],
         })
         .create(
-            `(profile)-[r:${
-                Profile.getRelationshipByAlias('credentialSent').name
-            }]->(credential)`
+            `(profile)-[r:${Profile.getRelationshipByAlias('credentialSent').name}]->(credential)`
         )
         .set('r = $params')
-        .run();
+        .run(transaction);
 
     // If the issuer is an AppStoreListing, additionally write the
     // AppStoreListing -> CREDENTIAL_SENT -> Credential edge so that
@@ -91,7 +92,7 @@ export const createSentCredentialRelationship = async (
                 }]->(credential)`
             )
             .set('r = $params')
-            .run();
+            .run(transaction);
     }
 };
 
@@ -139,7 +140,8 @@ export const createReceivedCredentialRelationship = async (
     to: ProfileType,
     from: ProfileType | { listing_id: string },
     credential: CredentialInstance,
-    metadata?: Record<string, unknown>
+    metadata?: Record<string, unknown>,
+    transaction?: Transaction
 ): Promise<void> => {
     const fromId = 'profileId' in from ? from.profileId : from.listing_id;
     const properties = flattenObject({
@@ -165,12 +167,13 @@ export const createReceivedCredentialRelationship = async (
             }]->(profile)`
         )
         .set('r = $params')
-        .run();
+        .run(transaction);
 };
 
 export const setDefaultClaimedRole = async (
     profile: ProfileType,
-    credential: CredentialInstance
+    credential: CredentialInstance,
+    transaction?: Transaction
 ): Promise<void> => {
     await new QueryBuilder()
         .match({
@@ -200,7 +203,10 @@ export const setDefaultClaimedRole = async (
                 { identifier: 'boost' },
             ],
         })
-        .run();
+        .run(transaction);
+
+    // An enclosing transaction invalidates caches only after its writes commit.
+    if (transaction) return;
 
     try {
         const boostId = await getBoostIdForCredentialInstance(credential);
@@ -239,6 +245,7 @@ export const createCredentialIssuedViaContractRelationship = async (
                 { identifier: 'terms' },
             ],
         })
+        .raw(termsReferralSnapshotCypher())
         .with('transaction')
         .match({
             model: Credential,

package/src/accesslayer/inbox-credential/relationships/create.ts

@@ -1,4 +1,5 @@
 import { QueryBuilder, BindParam } from 'neogma';
+import type { Transaction } from 'neo4j-driver';
 import { Profile, InboxCredential } from '@models';
 
 export const createDeliveredRelationship = async (
@@ -8,19 +9,23 @@ export const createDeliveredRelationship = async (
     deliveryMethod: string = 'direct'
 ): Promise<boolean> => {
     const timestamp = new Date().toISOString();
-    
-    const result = await new QueryBuilder(new BindParam({ 
-        profileId, 
-        inboxCredentialId, 
-        timestamp, 
-        recipientDid, 
-        deliveryMethod 
-    }))
+
+    const result = await new QueryBuilder(
+        new BindParam({
+            profileId,
+            inboxCredentialId,
+            timestamp,
+            recipientDid,
+            deliveryMethod,
+        })
+    )
         .match({ model: Profile, identifier: 'profile' })
         .where('profile.profileId = $profileId')
         .match({ model: InboxCredential, identifier: 'inboxCredential' })
         .where('inboxCredential.id = $inboxCredentialId')
-        .create('(profile)-[:DELIVERED_INBOX_CREDENTIAL { timestamp: $timestamp, recipientDid: $recipientDid, deliveryMethod: $deliveryMethod }]->(inboxCredential)')
+        .create(
+            '(profile)-[:DELIVERED_INBOX_CREDENTIAL { timestamp: $timestamp, recipientDid: $recipientDid, deliveryMethod: $deliveryMethod }]->(inboxCredential)'
+        )
         .return('profile')
         .run();
 
@@ -30,23 +35,28 @@ export const createDeliveredRelationship = async (
 export const createClaimedRelationship = async (
     profileId: string,
     inboxCredentialId: string,
-    claimToken: string
+    claimToken: string,
+    transaction?: Transaction
 ): Promise<boolean> => {
     const timestamp = new Date().toISOString();
-    
-    const result = await new QueryBuilder(new BindParam({ 
-        profileId, 
-        inboxCredentialId, 
-        timestamp, 
-        claimToken 
-    }))
-        .match({ model: Profile, identifier: 'profile'})
+
+    const result = await new QueryBuilder(
+        new BindParam({
+            profileId,
+            inboxCredentialId,
+            timestamp,
+            claimToken,
+        })
+    )
+        .match({ model: Profile, identifier: 'profile' })
         .where('profile.profileId = $profileId')
-        .match({ model: InboxCredential, identifier: 'inboxCredential'})
+        .match({ model: InboxCredential, identifier: 'inboxCredential' })
         .where('inboxCredential.id = $inboxCredentialId')
-        .create('(profile)-[:CLAIMED_INBOX_CREDENTIAL { timestamp: $timestamp, claimToken: $claimToken }]->(inboxCredential)')
+        .create(
+            '(profile)-[:CLAIMED_INBOX_CREDENTIAL { timestamp: $timestamp, claimToken: $claimToken }]->(inboxCredential)'
+        )
         .return('profile')
-        .run();
+        .run(transaction);
 
     return result.records.length > 0;
 };
@@ -58,19 +68,23 @@ export const createEmailSentRelationship = async (
     token: string
 ): Promise<boolean> => {
     const timestamp = new Date().toISOString();
-    
-    const result = await new QueryBuilder(new BindParam({ 
-        profileDid, 
-        inboxCredentialId, 
-        timestamp, 
-        emailAddress, 
-        token 
-    }))
+
+    const result = await new QueryBuilder(
+        new BindParam({
+            profileDid,
+            inboxCredentialId,
+            timestamp,
+            emailAddress,
+            token,
+        })
+    )
         .match({ model: Profile, identifier: 'profile' })
         .where('profile.did = $profileDid')
         .match({ model: InboxCredential, identifier: 'inboxCredential' })
         .where('inboxCredential.id = $inboxCredentialId')
-        .create('(profile)-[:SENT_EMAIL { timestamp: $timestamp, emailAddress: $emailAddress, token: $token }]->(inboxCredential)')
+        .create(
+            '(profile)-[:SENT_EMAIL { timestamp: $timestamp, emailAddress: $emailAddress, token: $token }]->(inboxCredential)'
+        )
         .return('profile')
         .run();
 
@@ -85,20 +99,24 @@ export const createWebhookSentRelationship = async (
     response?: string
 ): Promise<boolean> => {
     const timestamp = new Date().toISOString();
-    
-    const result = await new QueryBuilder(new BindParam({ 
-        profileDid, 
-        inboxCredentialId, 
-        timestamp, 
-        url, 
-        status,
-        response: response || null
-    }))
+
+    const result = await new QueryBuilder(
+        new BindParam({
+            profileDid,
+            inboxCredentialId,
+            timestamp,
+            url,
+            status,
+            response: response || null,
+        })
+    )
         .match({ model: Profile, identifier: 'profile' })
         .where('profile.did = $profileDid')
         .match({ model: InboxCredential, identifier: 'inboxCredential' })
         .where('inboxCredential.id = $inboxCredentialId')
-        .create('(profile)-[:SENT_WEBHOOK { timestamp: $timestamp, url: $url, status: $status, response: $response }]->(inboxCredential)')
+        .create(
+            '(profile)-[:SENT_WEBHOOK { timestamp: $timestamp, url: $url, status: $status, response: $response }]->(inboxCredential)'
+        )
         .return('profile')
         .run();
 
@@ -110,19 +128,23 @@ export const createExpiredRelationship = async (
     inboxCredentialId: string
 ): Promise<boolean> => {
     const timestamp = new Date().toISOString();
-    
-    const result = await new QueryBuilder(new BindParam({ 
-        profileDid, 
-        inboxCredentialId, 
-        timestamp 
-    }))
+
+    const result = await new QueryBuilder(
+        new BindParam({
+            profileDid,
+            inboxCredentialId,
+            timestamp,
+        })
+    )
         .match({ model: Profile, identifier: 'profile' })
         .where('profile.did = $profileDid')
         .match({ model: InboxCredential, identifier: 'inboxCredential' })
         .where('inboxCredential.id = $inboxCredentialId')
-        .create('(profile)-[:EXPIRED_INBOX_CREDENTIAL { timestamp: $timestamp }]->(inboxCredential)')
+        .create(
+            '(profile)-[:EXPIRED_INBOX_CREDENTIAL { timestamp: $timestamp }]->(inboxCredential)'
+        )
         .return('profile')
         .run();
 
     return result.records.length > 0;
-};
+};

package/src/accesslayer/inbox-credential/update.ts

@@ -1,4 +1,5 @@
 import { QueryBuilder, BindParam } from 'neogma';
+import type { Transaction } from 'neo4j-driver';
 import { InboxCredential } from '@models';
 import { InboxCredentialType } from '@learncard/types';
 import { flattenObject, inflateObject } from '@helpers/objects.helpers';
@@ -31,7 +32,8 @@ export const updateInboxCredential = async (
 export const finalizeAndWipeInboxCredential = async (
     id: string,
     delivery: InboxDelivery,
-    { isAccepted = true }: { isAccepted?: boolean } = {}
+    { isAccepted = true }: { isAccepted?: boolean } = {},
+    transaction?: Transaction
 ): Promise<InboxCredentialType | null> => {
     const result = await new QueryBuilder(
         new BindParam({
@@ -64,7 +66,7 @@ export const finalizeAndWipeInboxCredential = async (
         )
         .return('inboxCredential')
         .limit(1)
-        .run();
+        .run(transaction);
 
     const inboxCredential = result.records[0]?.get('inboxCredential')?.properties;
     return inboxCredential

package/src/accesslayer/presentation/read.ts

@@ -14,6 +14,12 @@ import { PresentationType } from 'types/presentation';
 import { ProfileType } from 'types/profile';
 import { convertQueryResultToPropertiesObjectArray } from '@helpers/neo4j.helpers';
 import { getIdFromUri } from '@helpers/uri.helpers';
+import { inflateObject } from '@helpers/objects.helpers';
+
+const inflateRelationshipProperties = (
+    properties: Record<string, unknown>
+): Record<string, unknown> & { metadata?: Record<string, unknown> } =>
+    inflateObject(properties) as Record<string, unknown> & { metadata?: Record<string, unknown> };
 
 export const getPresentationById = async (id: string): Promise<PresentationInstance | null> => {
     return Presentation.findOne({ where: { id } });
@@ -56,8 +62,8 @@ export const getReceivedPresentationsForProfile = async (
     const query =
         from && from.length > 0
             ? matchQuery.where(
-                new Where({ source: { profileId: { [Op.in]: from } } }, matchQuery.getBindParam())
-            )
+                  new Where({ source: { profileId: { [Op.in]: from } } }, matchQuery.getBindParam())
+              )
             : matchQuery;
 
     const results = convertQueryResultToPropertiesObjectArray<{
@@ -66,13 +72,22 @@ export const getReceivedPresentationsForProfile = async (
         received: PresentationRelationships['presentationReceived']['RelationshipProperties'];
     }>(await query.return('sent, presentation, received').limit(limit).run());
 
-    return results.map(({ sent, presentation, received }) => ({
-        uri: getPresentationUri(presentation.id, domain),
-        to: sent.to,
-        from: received.from,
-        sent: sent.date,
-        received: received.date,
-    }));
+    return results.map(({ sent, presentation, received }) => {
+        const sentProps = inflateRelationshipProperties(sent as unknown as Record<string, unknown>);
+        const receivedProps = inflateRelationshipProperties(
+            received as unknown as Record<string, unknown>
+        );
+
+        return {
+            uri: getPresentationUri(presentation.id, domain),
+            to: sentProps.to as string,
+            from: receivedProps.from as string,
+            sent: sentProps.date as string,
+            received: receivedProps.date as string,
+            metadata: (receivedProps.metadata ?? sentProps.metadata) as
+                Record<string, unknown> | undefined,
+        };
+    });
 };
 
 export const getSentPresentationsForProfile = async (
@@ -101,8 +116,8 @@ export const getSentPresentationsForProfile = async (
     const whereQuery =
         to && to.length > 0
             ? matchQuery.where(
-                new Where({ sent: { to: { [Op.in]: to } } }, matchQuery.getBindParam())
-            )
+                  new Where({ sent: { to: { [Op.in]: to } } }, matchQuery.getBindParam())
+              )
             : matchQuery;
 
     const query = whereQuery.match({
@@ -124,13 +139,22 @@ export const getSentPresentationsForProfile = async (
         received?: PresentationRelationships['presentationReceived']['RelationshipProperties'];
     }>(await query.return('source, sent, presentation, received').limit(limit).run());
 
-    return results.map(({ source, sent, presentation, received }) => ({
-        uri: getPresentationUri(presentation.id, domain),
-        to: sent.to,
-        from: source.profileId,
-        sent: sent.date,
-        received: received?.date,
-    }));
+    return results.map(({ source, sent, presentation, received }) => {
+        const sentProps = inflateRelationshipProperties(sent as unknown as Record<string, unknown>);
+        const receivedProps = received
+            ? inflateRelationshipProperties(received as unknown as Record<string, unknown>)
+            : undefined;
+
+        return {
+            uri: getPresentationUri(presentation.id, domain),
+            to: sentProps.to as string,
+            from: source.profileId,
+            sent: sentProps.date as string,
+            received: receivedProps?.date as string | undefined,
+            metadata: (sentProps.metadata ?? receivedProps?.metadata) as
+                Record<string, unknown> | undefined,
+        };
+    });
 };
 
 export const getIncomingPresentationsForProfile = async (
@@ -168,7 +192,8 @@ export const getIncomingPresentationsForProfile = async (
             })
             // Don't return presentations that have been accepted
             .where(
-                `NOT (presentation)-[:PRESENTATION_RECEIVED]->()${whereFrom ? `AND ${whereFrom.getStatement('text')}` : ''
+                `NOT (presentation)-[:PRESENTATION_RECEIVED]->()${
+                    whereFrom ? `AND ${whereFrom.getStatement('text')}` : ''
                 }`
             )
             .return('source, relationship, presentation')
@@ -176,10 +201,17 @@ export const getIncomingPresentationsForProfile = async (
             .run()
     );
 
-    return results.map(({ source, relationship, presentation }) => ({
-        uri: getPresentationUri(presentation.id, domain),
-        to: relationship.to,
-        from: source.profileId,
-        sent: relationship.date,
-    }));
+    return results.map(({ source, relationship, presentation }) => {
+        const relationshipProps = inflateRelationshipProperties(
+            relationship as unknown as Record<string, unknown>
+        );
+
+        return {
+            uri: getPresentationUri(presentation.id, domain),
+            to: relationshipProps.to as string,
+            from: source.profileId,
+            sent: relationshipProps.date as string,
+            metadata: relationshipProps.metadata,
+        };
+    });
 };

package/src/accesslayer/presentation/relationships/create.ts

@@ -1,26 +1,69 @@
-import { PresentationInstance, Profile } from '@models';
+import { BindParam, QueryBuilder } from 'neogma';
+
+import { Presentation, PresentationInstance, Profile } from '@models';
+import { flattenObject } from '@helpers/objects.helpers';
 import { ProfileType } from 'types/profile';
 
 export const createSentPresentationRelationship = async (
     from: ProfileType,
     to: ProfileType,
-    presentation: PresentationInstance
+    presentation: PresentationInstance,
+    metadata?: Record<string, unknown>
 ): Promise<void> => {
-    await Profile.relateTo({
-        alias: 'presentationSent',
-        where: { source: { profileId: from.profileId }, target: { id: presentation.id } },
-        properties: { to: to.profileId, date: new Date().toISOString() },
+    const properties = flattenObject({
+        to: to.profileId,
+        date: new Date().toISOString(),
+        ...(metadata ? { metadata } : {}),
     });
+
+    await new QueryBuilder(new BindParam({ params: properties }))
+        .match({
+            related: [
+                { model: Profile, where: { profileId: from.profileId }, identifier: 'profile' },
+            ],
+        })
+        .match({
+            related: [
+                { model: Presentation, where: { id: presentation.id }, identifier: 'presentation' },
+            ],
+        })
+        .create(
+            `(profile)-[relationship:${
+                Profile.getRelationshipByAlias('presentationSent').name
+            }]->(presentation)`
+        )
+        .set('relationship = $params')
+        .run();
 };
 
 export const createReceivedPresentationRelationship = async (
     to: ProfileType,
     from: ProfileType,
-    presentation: PresentationInstance
+    presentation: PresentationInstance,
+    metadata?: Record<string, unknown>
 ): Promise<void> => {
-    await presentation.relateTo({
-        alias: 'presentationReceived',
-        where: { profileId: to.profileId },
-        properties: { from: from.profileId, date: new Date().toISOString() },
+    const properties = flattenObject({
+        from: from.profileId,
+        date: new Date().toISOString(),
+        ...(metadata ? { metadata } : {}),
     });
+
+    await new QueryBuilder(new BindParam({ params: properties }))
+        .match({
+            related: [
+                { model: Presentation, where: { id: presentation.id }, identifier: 'presentation' },
+            ],
+        })
+        .match({
+            related: [
+                { model: Profile, where: { profileId: to.profileId }, identifier: 'profile' },
+            ],
+        })
+        .create(
+            `(presentation)-[relationship:${
+                Presentation.getRelationshipByAlias('presentationReceived').name
+            }]->(profile)`
+        )
+        .set('relationship = $params')
+        .run();
 };