Add CanCreateRelationshipUseCase and handling of expired RelationshipTemplates

.dev/compose.backbone.env

@@ -1 +1 @@
-BACKBONE_VERSION=6.10.0
+BACKBONE_VERSION=6.13.2

packages/consumption/src/consumption/ConsumptionController.ts

@@ -124,7 +124,8 @@ export class ConsumptionController {
             this,
             this.transport.eventBus,
             this.accountController.identity,
-            this.accountController.relationships
+            this.accountController.relationships,
+            this.accountController.relationshipTemplates
         ).init();
 
         const notificationItemProcessorRegistry = new NotificationItemProcessorRegistry(this, this.getDefaultNotificationItemProcessors());

packages/consumption/src/modules/requests/incoming/IncomingRequestsController.ts

@@ -39,6 +39,10 @@ export class IncomingRequestsController extends ConsumptionBaseController {
         private readonly identity: { address: CoreAddress },
         private readonly relationshipResolver: {
             getRelationshipToIdentity(id: CoreAddress): Promise<Relationship | undefined>;
+            getExistingRelationshipToIdentity(id: CoreAddress): Promise<Relationship | undefined>;
+        },
+        private readonly relationshipTemplateResolver: {
+            getRelationshipTemplate(id: CoreId): Promise<RelationshipTemplate | undefined>;
         }
     ) {
         super(ConsumptionControllerName.RequestsController, parent);
@@ -60,6 +64,11 @@ export class IncomingRequestsController extends ConsumptionBaseController {
             statusLog: []
         });
 
+        if (!(await this.relationshipResolver.getExistingRelationshipToIdentity(CoreAddress.from(infoFromSource.peer))) && infoFromSource.expiresAt) {
+            request.content.expiresAt = CoreDate.min(infoFromSource.expiresAt, request.content.expiresAt);
+            request.updateStatusBasedOnExpiration();
+        }
+
         await this.localRequests.create(request);
 
         this.eventBus.publish(new IncomingRequestReceivedEvent(this.identity.address.toString(), request));
@@ -95,7 +104,8 @@ export class IncomingRequestsController extends ConsumptionBaseController {
             source: {
                 reference: template.id,
                 type: "RelationshipTemplate"
-            }
+            },
+            expiresAt: template.cache!.expiresAt
         };
     }
 
@@ -377,7 +387,7 @@ export class IncomingRequestsController extends ConsumptionBaseController {
         return request;
     }
 
-    public async getIncomingRequests(query?: any): Promise<LocalRequest[]> {
+    public async getIncomingRequestsWithUpdatedExpiry(query?: any): Promise<LocalRequest[]> {
         const requestDocs = await this.localRequests.find({
             ...query,
             isOwn: false
@@ -387,16 +397,17 @@ export class IncomingRequestsController extends ConsumptionBaseController {
         return await Promise.all(requestPromises);
     }
 
-    public async getIncomingRequest(idIncomingRequest: ICoreId): Promise<LocalRequest | undefined> {
+    public async getIncomingRequestWithUpdatedExpiry(idIncomingRequest: ICoreId): Promise<LocalRequest | undefined> {
         const requestDoc = await this.localRequests.findOne({ id: idIncomingRequest.toString(), isOwn: false });
         if (!requestDoc) return;
 
         const localRequest = LocalRequest.from(requestDoc);
+
         return await this.updateRequestExpiry(localRequest);
     }
 
     private async getOrThrow(id: CoreId | string) {
-        const request = await this.getIncomingRequest(CoreId.from(id));
+        const request = await this.getIncomingRequestWithUpdatedExpiry(CoreId.from(id));
         if (!request) {
             throw TransportCoreErrors.general.recordNotFound(LocalRequest, id.toString());
         }
@@ -412,7 +423,7 @@ export class IncomingRequestsController extends ConsumptionBaseController {
     }
 
     public async deleteRequestsFromPeer(peer: CoreAddress): Promise<void> {
-        const requests = await this.getIncomingRequests({ peer: peer.toString() });
+        const requests = await this.getIncomingRequestsWithUpdatedExpiry({ peer: peer.toString() });
         for (const request of requests) {
             await this.localRequests.delete(request);
         }
@@ -425,13 +436,26 @@ export class IncomingRequestsController extends ConsumptionBaseController {
     }
 
     private async updateRequestExpiry(request: LocalRequest) {
+        let expirationDateUpdated;
+        if (request.source?.type === "RelationshipTemplate" && !(await this.relationshipResolver.getExistingRelationshipToIdentity(request.peer))) {
+            const template = await this.relationshipTemplateResolver.getRelationshipTemplate(request.source.reference);
+            if (!template) {
+                throw TransportCoreErrors.general.recordNotFound(RelationshipTemplate, request.source.reference.toString());
+            }
+            if (template.cache?.expiresAt) {
+                expirationDateUpdated = request.updateExpirationDateBasedOnTemplateExpiration(template.cache.expiresAt);
+            }
+        }
+
         const statusUpdated = request.updateStatusBasedOnExpiration();
-        if (statusUpdated) await this.update(request);
+
+        if (expirationDateUpdated ?? statusUpdated) await this.update(request);
         return request;
     }
 }
 
 interface InfoFromSource {
     peer: ICoreAddress;
     source: ILocalRequestSource;
+    expiresAt?: CoreDate;
 }

packages/consumption/src/modules/requests/local/LocalRequest.ts

@@ -117,7 +117,7 @@ export class LocalRequest extends CoreSynchronizable implements ILocalRequest {
     public isExpired(comparisonDate: CoreDate = CoreDate.utc()): boolean {
         if (!this.content.expiresAt) return false;
 
-        return comparisonDate.isAfter(this.content.expiresAt.add({ seconds: 10 }));
+        return comparisonDate.isAfter(this.content.expiresAt);
     }
 
     public updateStatusBasedOnExpiration(comparisonDate: CoreDate = CoreDate.utc()): boolean {
@@ -130,4 +130,17 @@ export class LocalRequest extends CoreSynchronizable implements ILocalRequest {
 
         return false;
     }
+
+    public updateExpirationDateBasedOnTemplateExpiration(templateExpiresAt: CoreDate): boolean {
+        if (this.source?.type !== "RelationshipTemplate") return false;
+
+        if (this.status === LocalRequestStatus.Completed || this.status === LocalRequestStatus.Expired) return false;
+
+        if (!this.isExpired()) {
+            this.content.expiresAt = CoreDate.min(templateExpiresAt, this.content.expiresAt);
+            return true;
+        }
+
+        return false;
+    }
 }

packages/consumption/src/modules/requests/outgoing/OutgoingRequestsController.ts

@@ -191,7 +191,7 @@ export class OutgoingRequestsController extends ConsumptionBaseController {
     }
 
     public async deleteRequestsToPeer(peer: CoreAddress): Promise<void> {
-        const requests = await this.getOutgoingRequests({ peer: peer.toString() });
+        const requests = await this.getOutgoingRequestsWithUpdatedExpiry({ peer: peer.toString() });
         for (const request of requests) {
             await this.localRequests.delete(request);
         }
@@ -369,7 +369,7 @@ export class OutgoingRequestsController extends ConsumptionBaseController {
         await processor.applyIncomingResponseItem(responseItem, requestItem, request);
     }
 
-    public async getOutgoingRequests(query?: any): Promise<LocalRequest[]> {
+    public async getOutgoingRequestsWithUpdatedExpiry(query?: any): Promise<LocalRequest[]> {
         const requestDocs = await this.localRequests.find({
             ...query,
             isOwn: true
@@ -386,7 +386,7 @@ export class OutgoingRequestsController extends ConsumptionBaseController {
         await this.localRequests.delete(request);
     }
 
-    public async getOutgoingRequest(id: ICoreId): Promise<LocalRequest | undefined> {
+    public async getOutgoingRequestWithUpdatedExpiry(id: ICoreId): Promise<LocalRequest | undefined> {
         const requestDoc = await this.localRequests.findOne({ id: id.toString(), isOwn: true });
         if (!requestDoc) return;
 
@@ -395,7 +395,7 @@ export class OutgoingRequestsController extends ConsumptionBaseController {
     }
 
     private async getOrThrow(id: CoreId) {
-        const request = await this.getOutgoingRequest(id);
+        const request = await this.getOutgoingRequestWithUpdatedExpiry(id);
         if (!request) {
             throw TransportCoreErrors.general.recordNotFound(LocalRequest, id.toString());
         }

packages/consumption/test/modules/requests/DeleteRequest.test.ts

@@ -58,8 +58,8 @@ describe("Delete requests", function () {
         await TestUtil.terminateRelationship(sAccountController, rAccountController);
         await TestUtil.decomposeRelationship(sAccountController, sConsumptionController, rAccountController);
         await TestUtil.decomposeRelationship(rAccountController, rConsumptionController, sAccountController);
-        const sRequest = await sConsumptionController.outgoingRequests.getOutgoingRequest(sLocalRequest.id);
-        const rRequest = await sConsumptionController.incomingRequests.getIncomingRequest(rLocalRequest.id);
+        const sRequest = await sConsumptionController.outgoingRequests.getOutgoingRequestWithUpdatedExpiry(sLocalRequest.id);
+        const rRequest = await sConsumptionController.incomingRequests.getIncomingRequestWithUpdatedExpiry(rLocalRequest.id);
         expect(sRequest).toBeUndefined();
         expect(rRequest).toBeUndefined();
     });

packages/consumption/test/modules/requests/IncomingRequestsController.test.ts

@@ -1,7 +1,7 @@
 import { IDatabaseConnection } from "@js-soft/docdb-access-abstractions";
 import { IRequest, IRequestItemGroup, RejectResponseItem, Request, RequestItemGroup, ResponseItem, ResponseItemGroup, ResponseItemResult } from "@nmshd/content";
 import { CoreDate, CoreId } from "@nmshd/core-types";
-import { CoreIdHelper, TransportLoggerFactory } from "@nmshd/transport";
+import { CoreIdHelper, RelationshipTemplate, TransportLoggerFactory } from "@nmshd/transport";
 import {
     ConsumptionIds,
     DecideRequestItemGroupParametersJSON,
@@ -65,6 +65,34 @@ describe("IncomingRequestsController", function () {
             await Then.eventHasBeenPublished(IncomingRequestReceivedEvent);
         });
 
+        test("takes the expiration date from the Template if the Request has no expiration date", async function () {
+            const timestamp = CoreDate.utc();
+            const incomingTemplate = TestObjectFactory.createIncomingRelationshipTemplate(timestamp);
+            await When.iCreateAnIncomingRequestWith({ requestSourceObject: incomingTemplate });
+            await Then.theRequestHasExpirationDate(timestamp);
+            await Then.theRequestIsInStatus(LocalRequestStatus.Expired);
+        });
+
+        test("takes the expiration date from the Template if the Request has a later expiration date", async function () {
+            const timestamp = CoreDate.utc().add({ days: 1 });
+            const incomingTemplate = TestObjectFactory.createIncomingRelationshipTemplate(timestamp);
+            await When.iCreateAnIncomingRequestWith({
+                requestSourceObject: incomingTemplate,
+                receivedRequest: TestObjectFactory.createRequestWithOneItem({ expiresAt: timestamp.add({ days: 1 }) })
+            });
+            await Then.theRequestHasExpirationDate(timestamp);
+        });
+
+        test("takes the expiration date from the Request if the Template has a later expiration date", async function () {
+            const timestamp = CoreDate.utc().add({ days: 1 });
+            const incomingTemplate = TestObjectFactory.createIncomingRelationshipTemplate(timestamp.add({ days: 1 }));
+            await When.iCreateAnIncomingRequestWith({
+                requestSourceObject: incomingTemplate,
+                receivedRequest: TestObjectFactory.createRequestWithOneItem({ expiresAt: timestamp })
+            });
+            await Then.theRequestHasExpirationDate(timestamp);
+        });
+
         test("uses the ID of the given Request if it exists", async function () {
             const request = TestObjectFactory.createRequestWithOneItem({ id: await CoreIdHelper.notPrefixed.generate() });
 
@@ -954,6 +982,37 @@ describe("IncomingRequestsController", function () {
             await Then.theNumberOfReturnedRequestsIs(2);
         });
 
+        test("updates the expiration date if the Template expires before the Request", async function () {
+            const timestamp = CoreDate.utc();
+            const request = await Given.anIncomingRequestWith({
+                content: TestObjectFactory.createRequestWithOneItem({ expiresAt: timestamp.add({ days: 1 }) }),
+                requestSource: TestObjectFactory.createIncomingRelationshipTemplate(timestamp)
+            });
+            await When.iGetTheIncomingRequestWith(request.id);
+            await Then.theRequestHasExpirationDate(timestamp);
+            await Then.theRequestIsInStatus(LocalRequestStatus.Expired);
+        });
+
+        test("updates the expiration date if the Request has no expiration date", async function () {
+            const timestamp = CoreDate.utc().add({ days: 1 });
+            const request = await Given.anIncomingRequestWith({
+                content: TestObjectFactory.createRequestWithOneItem(),
+                requestSource: TestObjectFactory.createIncomingRelationshipTemplate(timestamp)
+            });
+            await When.iGetTheIncomingRequestWith(request.id);
+            await Then.theRequestHasExpirationDate(timestamp);
+        });
+
+        test("doesn't update the expiration date if the Request expires before the Template", async function () {
+            const timestamp = CoreDate.utc().add({ days: 1 });
+            const request = await Given.anIncomingRequestWith({
+                content: TestObjectFactory.createRequestWithOneItem({ expiresAt: timestamp }),
+                requestSource: TestObjectFactory.createIncomingRelationshipTemplate(timestamp.add({ days: 1 }))
+            });
+            await When.iGetTheIncomingRequestWith(request.id);
+            await Then.theRequestHasExpirationDate(timestamp);
+        });
+
         test("moves the Request to status 'Expired' when expiredAt is reached", async function () {
             const outgoingRequest = await Given.anIncomingRequestWith({
                 status: LocalRequestStatus.Draft,
@@ -999,6 +1058,7 @@ describe("IncomingRequestsController", function () {
                 items: [TestRequestItem.from({ mustBeAccepted: false })]
             });
             const template = TestObjectFactory.createIncomingIRelationshipTemplate();
+            context.templateToReturnFromGetTemplate = RelationshipTemplate.from(template);
 
             let cnsRequest = await context.incomingRequestsController.received({
                 receivedRequest: request,