@learncard/network-brain-service 3.19.0 → 3.19.1

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

@@ -23,8 +23,8 @@ import { reconsentTerms, upsertRequestedForRelationship } from './update';
 import { addNotificationToQueue } from '@helpers/notifications.helpers';
 import { getNotificationMessage } from '@helpers/notificationMessages';
 import { resolveRecipientLocale } from '@helpers/getRecipientLocale.helpers';
-import { sendBoost } from '@helpers/boost.helpers';
-import { getBoostUri } from '@helpers/boost.helpers';
+import { getBoostUri, sendBoost } from '@helpers/boost.helpers';
+import { setCredentialSubjectIds } from '@helpers/credentialSubject.helpers';
 import { getDidWeb } from '@helpers/did.helpers';
 import { getSigningAuthorityForUserByName } from '@accesslayer/signing-authority/relationships/read';
 import { issueCredentialWithSigningAuthority } from '@helpers/signingAuthority.helpers';
@@ -238,22 +238,15 @@ export const consentToContract = async (
 
                     boostCredential.issuer = { id: contractOwnerSigningAuthority.relationship.did };
 
-                    boostCredential.boostId = getBoostUri(boost.target.id, domain);
-
-                    if (Array.isArray(boostCredential.credentialSubject)) {
-                        boostCredential.credentialSubject = boostCredential.credentialSubject.map(
-                            subject => ({
-                                ...subject,
-                                id: getDidWeb(domain, consenter.profileId),
-                            })
-                        );
-                    } else {
-                        boostCredential.credentialSubject.id = getDidWeb(
-                            domain,
-                            consenter.profileId
-                        );
+                    if (boostCredential.type.includes('BoostCredential')) {
+                        boostCredential.boostId = getBoostUri(boost.target.id, domain);
                     }
 
+                    setCredentialSubjectIds(
+                        boostCredential,
+                        getDidWeb(domain, consenter.profileId)
+                    );
+
                     // Inject OBv3 skill alignments based on boost's framework/skills
                     await injectObv3AlignmentsIntoCredentialForBoost(
                         boostCredential,

package/src/accesslayer/consentflowcontract/relationships/update.ts

@@ -17,6 +17,7 @@ import { getNotificationMessage } from '@helpers/notificationMessages';
 import { resolveRecipientLocale } from '@helpers/getRecipientLocale.helpers';
 import { DbContractType, DbTermsType } from 'types/consentflowcontract';
 import { getBoostUri, sendBoost } from '@helpers/boost.helpers';
+import { setCredentialSubjectIds } from '@helpers/credentialSubject.helpers';
 import { getDidWeb } from '@helpers/did.helpers';
 import { getSigningAuthorityForUserByName } from '@accesslayer/signing-authority/relationships/read';
 import { issueCredentialWithSigningAuthority } from '@helpers/signingAuthority.helpers';
@@ -154,22 +155,15 @@ export const reconsentTerms = async (
                     // Set the issuer and subject
                     boostCredential.issuer = { id: contractOwnerSigningAuthority.relationship.did };
 
-                    boostCredential.boostId = getBoostUri(boost.dataValues.id, domain);
-
-                    if (Array.isArray(boostCredential.credentialSubject)) {
-                        boostCredential.credentialSubject = boostCredential.credentialSubject.map(
-                            subject => ({
-                                ...subject,
-                                id: getDidWeb(domain, relationship.consenter.profileId),
-                            })
-                        );
-                    } else {
-                        boostCredential.credentialSubject.id = getDidWeb(
-                            domain,
-                            relationship.consenter.profileId
-                        );
+                    if (boostCredential.type.includes('BoostCredential')) {
+                        boostCredential.boostId = getBoostUri(boost.dataValues.id, domain);
                     }
 
+                    setCredentialSubjectIds(
+                        boostCredential,
+                        getDidWeb(domain, relationship.consenter.profileId)
+                    );
+
                     // Issue the credential using contract owner's signing authority
                     // Inject OBv3 skill alignments based on boost's framework/skills
                     await injectObv3AlignmentsIntoCredentialForBoost(
@@ -384,22 +378,15 @@ export const updateTerms = async (
                     // Set the issuer and subject
                     boostCredential.issuer = { id: contractOwnerSigningAuthority.relationship.did };
 
-                    boostCredential.boostId = getBoostUri(boost.target.id, domain);
-
-                    if (Array.isArray(boostCredential.credentialSubject)) {
-                        boostCredential.credentialSubject = boostCredential.credentialSubject.map(
-                            subject => ({
-                                ...subject,
-                                id: getDidWeb(domain, relationship.consenter.profileId),
-                            })
-                        );
-                    } else {
-                        boostCredential.credentialSubject.id = getDidWeb(
-                            domain,
-                            relationship.consenter.profileId
-                        );
+                    if (boostCredential.type.includes('BoostCredential')) {
+                        boostCredential.boostId = getBoostUri(boost.target.id, domain);
                     }
 
+                    setCredentialSubjectIds(
+                        boostCredential,
+                        getDidWeb(domain, relationship.consenter.profileId)
+                    );
+
                     // Issue the credential using contract owner's signing authority
                     // Inject OBv3 skill alignments based on boost's framework/skills
                     await injectObv3AlignmentsIntoCredentialForBoost(

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();
 };

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

@@ -2,15 +2,26 @@ import { inflateObject } from '@helpers/objects.helpers';
 import { Presentation, PresentationInstance, Profile, ProfileRelationships } from '@models';
 import { ProfileType } from 'types/profile';
 
+const relationshipProperties = (value: unknown): Record<string, unknown> => {
+    if (value && typeof value === 'object' && 'dataValues' in value) {
+        const { dataValues } = value as { dataValues?: unknown };
+        if (dataValues && typeof dataValues === 'object') {
+            return dataValues as Record<string, unknown>;
+        }
+    }
+
+    return value as Record<string, unknown>;
+};
+
 export const getPresentationSentToProfile = async (
     id: string,
     to: ProfileType
 ): Promise<
     | {
-        source: ProfileType;
-        relationship: ProfileRelationships['presentationSent']['RelationshipProperties'];
-        target: PresentationInstance;
-    }
+          source: ProfileType;
+          relationship: ProfileRelationships['presentationSent']['RelationshipProperties'];
+          target: PresentationInstance;
+      }
     | undefined
 > => {
     const data = (
@@ -22,7 +33,11 @@ export const getPresentationSentToProfile = async (
 
     if (!data) return undefined;
 
-    return { ...data, source: inflateObject(data.source.dataValues as any) };
+    return {
+        ...data,
+        source: inflateObject(data.source.dataValues as unknown as Record<string, unknown>),
+        relationship: inflateObject(relationshipProperties(data.relationship)),
+    };
 };
 
 export const getPresentationOwner = async (
@@ -39,7 +54,7 @@ export const getPresentationOwner = async (
 
     if (!owner) return undefined;
 
-    return inflateObject<ProfileType>(owner.dataValues as any);
+    return inflateObject(owner.dataValues as unknown as Record<string, unknown>) as ProfileType;
 };
 
 export const getPresentationReceivedByProfile = async (

package/src/accesslayer/share-link/abandon.ts

@@ -0,0 +1,100 @@
+import { ensureShareLinkConstraints } from '../../models/share-link-constraints';
+import { failShareLink } from './errors';
+import {
+    deleteReservation,
+    enqueueCleanupJob,
+    lockShare,
+    markOperationAbandoned,
+    readReservation,
+    toShareLinkRecord,
+    toShareLinkReservationRecord,
+} from './helpers';
+import { withShareLinkTransaction } from './transaction';
+import type { AbandonReservationInput, AbandonReservationResult } from './types';
+
+/**
+ * Irreversibly abandons a reservation.
+ *
+ * The operation transitions to cleanup-only: its exact immutable object is queued
+ * for tracked cleanup and the reservation is deleted, so a late finalize for the
+ * same operation is rejected. A stale worker can never abandon a newer reservation
+ * because the operation id (and, when supplied, generation/lease owner) must match.
+ *
+ * When the reservation is already gone but the share records this operation as the
+ * committed one, abandon reports `already_finalized` instead of pretending to have
+ * cleaned up live content.
+ */
+export const abandonReservation = async (
+    input: AbandonReservationInput
+): Promise<AbandonReservationResult> => {
+    await ensureShareLinkConstraints();
+
+    const now = input.now ?? new Date();
+    const nowIso = now.toISOString();
+
+    return withShareLinkTransaction(async tx => {
+        const lockedProps = await lockShare(tx, input.shareId);
+
+        if (!lockedProps) {
+            failShareLink('NOT_FOUND', 'share not found');
+        }
+
+        const share = toShareLinkRecord(lockedProps);
+
+        if (share.namespace !== input.namespace || share.ownerProfileId !== input.ownerProfileId) {
+            failShareLink('NOT_FOUND', 'share not found');
+        }
+
+        const reservationProps = await readReservation(tx, input.shareId);
+
+        if (!reservationProps) {
+            if (share.lastOperationId === input.operationId) {
+                return { outcome: 'already_finalized', share };
+            }
+
+            return { outcome: 'already_absent' };
+        }
+
+        const reservation = toShareLinkReservationRecord(reservationProps);
+
+        if (reservation.operationId !== input.operationId) {
+            return { outcome: 'already_absent' };
+        }
+
+        if (input.generation !== undefined && reservation.generation !== input.generation) {
+            return { outcome: 'already_absent' };
+        }
+
+        if (input.leaseOwner !== undefined && reservation.leaseOwner !== input.leaseOwner) {
+            return { outcome: 'already_absent' };
+        }
+
+        let cleanupQueuedFor: string | null = null;
+
+        if (reservation.objectRef) {
+            await enqueueCleanupJob(tx, {
+                objectRef: reservation.objectRef,
+                operationId: reservation.operationId,
+                namespace: reservation.namespace,
+                ownerProfileId: reservation.ownerProfileId,
+                shareId: reservation.shareId,
+                contentVersion: reservation.contentVersion ?? reservation.baseContentVersion,
+                reason: 'abandoned',
+                now: nowIso,
+            });
+
+            cleanupQueuedFor = reservation.objectRef;
+        }
+
+        await markOperationAbandoned(tx, {
+            namespace: reservation.namespace,
+            ownerProfileId: reservation.ownerProfileId,
+            opKind: reservation.opKind,
+            clientRequestId: reservation.clientRequestId,
+            now: nowIso,
+        });
+        await deleteReservation(tx, input.shareId);
+
+        return { outcome: 'abandoned', cleanupQueuedFor };
+    });
+};