nmshd · jkoenig134 · Oct 18, 2024 · Oct 18, 2024 · Oct 22, 2024 · Oct 22, 2024
diff --git a/packages/consumption/test/modules/requests/testHelpers/TestObjectFactory.ts b/packages/consumption/test/modules/requests/testHelpers/TestObjectFactory.ts
@@ -66,7 +66,7 @@ export class TestObjectFactory {
                             newStatus: RelationshipStatus.Pending
                         }
                     ],
-                    template: this.createIncomingRelationshipTemplate()
+                    templateId: { id: "b9uMR7u7lsKLzRfVJNYb" }
                 })
         });
     }
@@ -108,7 +108,7 @@ export class TestObjectFactory {
                             newStatus: RelationshipStatus.Active
                         }
                     ],
-                    template: this.createIncomingRelationshipTemplate()
+                    templateId: { id: "b9uMR7u7lsKLzRfVJNYb" }
                 })
         });
     }
@@ -159,7 +159,7 @@ export class TestObjectFactory {
                             newStatus: RelationshipStatus.Terminated
                         }
                     ],
-                    template: this.createIncomingRelationshipTemplate()
+                    templateId: { id: "b9uMR7u7lsKLzRfVJNYb" }
                 })
         });
     }
@@ -219,7 +219,7 @@ export class TestObjectFactory {
                             newStatus: RelationshipStatus.DeletionProposed
                         }
                     ],
-                    template: this.createIncomingRelationshipTemplate()
+                    templateId: { id: "b9uMR7u7lsKLzRfVJNYb" }
                 })
         });
     }

diff --git a/packages/runtime/src/dataViews/DataViewExpander.ts b/packages/runtime/src/dataViews/DataViewExpander.ts
@@ -1698,10 +1698,7 @@ export class DataViewExpander {
             }
         }
 
-        let direction = RelationshipDirection.Incoming;
-        if (!relationship.template.isOwn) {
-            direction = RelationshipDirection.Outgoing;
-        }
+        const direction = this.identityController.isMe(CoreAddress.from(relationship.auditLog[0].createdBy)) ? RelationshipDirection.Outgoing : RelationshipDirection.Incoming;
 
         let statusText = "";
         switch (relationship.status) {
@@ -1760,7 +1757,7 @@ export class DataViewExpander {
             attributeMap: attributesByType,
             items: expandedAttributes,
             nameMap: stringByType,
-            templateId: relationship.template.id,
+            templateId: relationship.templateId,
             auditLog: relationship.auditLog,
             creationContent: relationship.creationContent
         };

diff --git a/packages/runtime/src/modules/RequestModule.ts b/packages/runtime/src/modules/RequestModule.ts
@@ -316,10 +316,20 @@ export class RequestModule extends RuntimeModule {
         }
 
         // only trigger for new relationships that were created from an own template
-        if (createdRelationship.status !== RelationshipStatus.Pending || !createdRelationship.template.isOwn) return;
+        const relationshipIsNotPending = createdRelationship.status !== RelationshipStatus.Pending;
+        const relationshipIsCreatedByCurrentAccount = createdRelationship.auditLog[0].createdBy === event.eventTargetAddress;
+        if (relationshipIsNotPending || relationshipIsCreatedByCurrentAccount) return;
+
+        const templateId = createdRelationship.templateId;
+
+        const templateResult = await services.transportServices.relationshipTemplates.getRelationshipTemplate({ id: templateId });
+        if (templateResult.isError) {
+            this.logger.error(`Could not get template with id '${templateId}'. Root error:`, templateResult.error);
+            return;
+        }
+
+        const template = templateResult.value;
 
-        const template = createdRelationship.template;
-        const templateId = template.id;
         // do not trigger for templates without the correct content type
         if (template.content["@type"] !== "RelationshipTemplateContent") return;
         if (createdRelationship.creationContent["@type"] !== "RelationshipCreationContent") {

diff --git a/packages/runtime/src/types/transport/RelationshipDTO.ts b/packages/runtime/src/types/transport/RelationshipDTO.ts
@@ -1,6 +1,5 @@
 import { ArbitraryRelationshipCreationContentJSON, RelationshipCreationContentJSON } from "@nmshd/content";
 import { IdentityDTO } from "./IdentityDTO";
-import { RelationshipTemplateDTO } from "./RelationshipTemplateDTO";
 
 export enum RelationshipStatus {
     Pending = "Pending",
@@ -49,7 +48,7 @@ export interface PeerDeletionInfoDTO {
 
 export interface RelationshipDTO {
     id: string;
-    template: RelationshipTemplateDTO;
+    templateId: string;
     status: RelationshipStatus;
     peer: string;
     peerIdentity: IdentityDTO;

diff --git a/packages/runtime/src/useCases/common/Schemas.ts b/packages/runtime/src/useCases/common/Schemas.ts
@@ -22556,7 +22556,7 @@ export const GetRelationshipsRequest: any = {
                         }
                     ]
                 },
-                "template.id": {
+                "templateId": {
                     "anyOf": [
                         {
                             "type": "string"

diff --git a/packages/runtime/src/useCases/transport/relationships/GetRelationships.ts b/packages/runtime/src/useCases/transport/relationships/GetRelationships.ts
@@ -1,16 +1,16 @@
 import { QueryTranslator } from "@js-soft/docdb-querytranslator";
 import { Result } from "@js-soft/ts-utils";
-import { CachedRelationship, Identity, Relationship, RelationshipsController, RelationshipTemplate } from "@nmshd/transport";
+import { CachedRelationship, Identity, Relationship, RelationshipsController } from "@nmshd/transport";
 import { Inject } from "@nmshd/typescript-ioc";
 import { nameof } from "ts-simple-nameof";
-import { RelationshipDTO, RelationshipTemplateDTO } from "../../../types";
+import { RelationshipDTO } from "../../../types";
 import { SchemaRepository, SchemaValidator, UseCase } from "../../common";
 import { RelationshipMapper } from "./RelationshipMapper";
 
 export interface GetRelationshipsQuery {
     peer?: string | string[];
     status?: string | string[];
-    "template.id"?: string | string[];
+    templateId?: string | string[];
 }
 
 export interface GetRelationshipsRequest {
@@ -28,12 +28,10 @@ export class GetRelationshipsUseCase extends UseCase<GetRelationshipsRequest, Re
         whitelist: {
             [nameof<RelationshipDTO>((r) => r.peer)]: true,
             [nameof<RelationshipDTO>((r) => r.status)]: true,
-            [`${nameof<RelationshipDTO>((r) => r.template)}.${nameof<RelationshipTemplateDTO>((t) => t.id)}`]: true
+            [`${nameof<RelationshipDTO>((r) => r.templateId)}`]: true
         },
         alias: {
-            [`${nameof<RelationshipDTO>((r) => r.template)}.${nameof<RelationshipTemplateDTO>((r) => r.id)}`]: `${nameof<Relationship>(
-                (r) => r.cache
-            )}.${nameof<CachedRelationship>((r) => r.template)}.${nameof<RelationshipTemplate>((r) => r.id)}`,
+            [`${nameof<RelationshipDTO>((r) => r.templateId)}`]: `${nameof<Relationship>((r) => r.cache)}.${nameof<CachedRelationship>((r) => r.templateId)}`,
             [nameof<RelationshipDTO>((r) => r.status)]: nameof<Relationship>((r) => r.status),
             [nameof<RelationshipDTO>((r) => r.peer)]: `${nameof<Relationship>((r) => r.peer)}.${nameof<Identity>((r) => r.address)}`
         }

diff --git a/packages/runtime/src/useCases/transport/relationships/RelationshipMapper.ts b/packages/runtime/src/useCases/transport/relationships/RelationshipMapper.ts
@@ -3,7 +3,6 @@ import { ArbitraryRelationshipCreationContent, RelationshipCreationContent } fro
 import { Relationship, RelationshipAuditLogEntry } from "@nmshd/transport";
 import { RelationshipAuditLogEntryDTO, RelationshipDTO } from "../../../types";
 import { RuntimeErrors } from "../../common";
-import { RelationshipTemplateMapper } from "../relationshipTemplates/RelationshipTemplateMapper";
 
 export class RelationshipMapper {
     public static toRelationshipDTO(relationship: Relationship): RelationshipDTO {
@@ -13,7 +12,7 @@ export class RelationshipMapper {
 
         return {
             id: relationship.id.toString(),
-            template: RelationshipTemplateMapper.toRelationshipTemplateDTO(relationship.cache.template),
+            templateId: relationship.cache.templateId.toString(),
             status: relationship.status,
             peer: relationship.peer.address.toString(),
             peerDeletionInfo: relationship.peerDeletionInfo?.toJSON(),

diff --git a/packages/runtime/test/consumption/requests.test.ts b/packages/runtime/test/consumption/requests.test.ts
@@ -581,7 +581,7 @@ describe("Requests", () => {
             const completionResult = await sConsumptionServices.outgoingRequests.createAndCompleteFromRelationshipTemplateResponse({
                 responseSourceId: sRelationship.id,
                 response: (sRelationship.creationContent as RelationshipCreationContentJSON).response,
-                templateId: relationship!.template.id
+                templateId: relationship!.templateId
             });
 
             expect(completionResult).toBeSuccessful();

diff --git a/packages/runtime/test/dataViews/RelationshipDVO.test.ts b/packages/runtime/test/dataViews/RelationshipDVO.test.ts
@@ -80,7 +80,7 @@ describe("RelationshipDVO", () => {
         expect(dvo.relationship!.status).toBe("Active");
         expect(dvo.relationship!.statusText).toBe("i18n://dvo.relationship.Active");
 
-        expect(dvo.relationship!.templateId).toBe(dto.template.id);
+        expect(dvo.relationship!.templateId).toBe(dto.templateId);
     });
 
     test("check the relationship dvo for the requestor", async () => {
@@ -100,7 +100,7 @@ describe("RelationshipDVO", () => {
         expect(dvo.relationship!.status).toBe("Active");
         expect(dvo.relationship!.statusText).toBe("i18n://dvo.relationship.Active");
 
-        expect(dvo.relationship!.templateId).toBe(dto.template.id);
+        expect(dvo.relationship!.templateId).toBe(dto.templateId);
     });
 
     test("check the relationship dvo for the templator with active relationshipSetting", async () => {

diff --git a/packages/runtime/test/lib/testUtils.ts b/packages/runtime/test/lib/testUtils.ts
@@ -473,7 +473,8 @@ export async function ensureActiveRelationship(sTransportServices: TransportServ
         await rTransportServices.relationships.decomposeRelationship({ relationshipId: relationship.id });
         await establishRelationship(sTransportServices, rTransportServices);
     } else if (sRelationships[0].status === RelationshipStatus.Pending) {
-        if (sRelationships[0].template.isOwn) {
+        const sRelationshipTemplate = await sTransportServices.relationshipTemplates.getRelationshipTemplate({ id: sRelationships[0].templateId });
+        if (sRelationshipTemplate.value.isOwn) {
             const relationship = sRelationships[0];
             await sTransportServices.relationships.acceptRelationship({ relationshipId: relationship.id });
             await syncUntilHasRelationships(rTransportServices, 1);

diff --git a/packages/runtime/test/transport/relationships.test.ts b/packages/runtime/test/transport/relationships.test.ts
@@ -354,7 +354,7 @@ describe("Relationships query", () => {
         const conditions = new QueryParamConditions<GetRelationshipsQuery>(relationship, services1.transport)
             .addStringSet("peer")
             .addStringSet("status")
-            .addStringSet("template.id");
+            .addStringSet("templateId");
         await conditions.executeTests((c, q) => c.relationships.getRelationships({ query: q }));
     });
 });
@@ -849,15 +849,15 @@ describe("RelationshipDecomposition", () => {
     beforeAll(async () => {
         const relationship = await ensureActiveRelationship(services1.transport, services2.transport);
         relationshipId = relationship.id;
-        templateId = relationship.template.id;
+        templateId = relationship.templateId;
 
         await createRelationshipData(services1, services2);
 
         const runtimeServices = await serviceProvider.launch(1, { enableRequestModule: true, enableDeciderModule: true, enableNotificationModule: true });
         services3 = runtimeServices[0];
         const relationship2 = await establishRelationship(services1.transport, services3.transport);
         relationshipId2 = relationship2.id;
-        templateId2 = relationship2.template.id;
+        templateId2 = relationship2.templateId;
 
         await createRelationshipData(services1, services3);
         multipleRecipientsMessageId = (await sendMessageToMultipleRecipients(services1.transport, [services2.address, services3.address])).id;

diff --git a/packages/transport/src/modules/relationshipTemplates/RelationshipTemplateController.ts b/packages/transport/src/modules/relationshipTemplates/RelationshipTemplateController.ts
@@ -263,9 +263,8 @@ export class RelationshipTemplateController extends TransportController {
     }
 
     public async cleanupTemplatesOfDecomposedRelationship(relationship: Relationship): Promise<void> {
-        const templateOfRelationship = relationship.cache!.template;
-
-        if (!templateOfRelationship.isOwn || templateOfRelationship.cache!.maxNumberOfAllocations === 1) {
+        const templateOfRelationship = await this.getRelationshipTemplate(relationship.cache!.templateId);
+        if (templateOfRelationship && (!templateOfRelationship.isOwn || templateOfRelationship.cache!.maxNumberOfAllocations === 1)) {
             await this.templates.delete(templateOfRelationship);
         }
 

diff --git a/packages/transport/src/modules/relationships/RelationshipsController.ts b/packages/transport/src/modules/relationships/RelationshipsController.ts
@@ -173,7 +173,7 @@ export class RelationshipsController extends TransportController {
 
         const backboneResponse = result.value;
 
-        const newRelationship = Relationship.fromBackboneAndCreationContent(backboneResponse, template, template.cache.identity, parameters.creationContent, secretId);
+        const newRelationship = Relationship.fromBackboneAndCreationContent(backboneResponse, template.cache.identity, parameters.creationContent, secretId);
 
         await this.relationships.create(newRelationship);
 
@@ -396,19 +396,13 @@ export class RelationshipsController extends TransportController {
 
         const templateId = CoreId.from(response.relationshipTemplateId);
 
-        this._log.trace(`Parsing relationship template ${templateId} for ${response.id}...`);
-        const template = await this.parent.relationshipTemplates.getRelationshipTemplate(templateId);
-        if (!template) {
-            throw TransportCoreErrors.general.recordNotFound(RelationshipTemplate, templateId.toString());
-        }
-
         this._log.trace(`Parsing relationship creation content of ${response.id}...`);
 
         const creationContent = await this.decryptCreationContent(response.creationContent, CoreAddress.from(response.from), relationshipSecretId);
 
         const cachedRelationship = CachedRelationship.from({
             creationContent: creationContent.content,
-            template,
+            templateId,
             auditLog: RelationshipAuditLog.fromBackboneAuditLog(response.auditLog)
         });
 
@@ -514,7 +508,7 @@ export class RelationshipsController extends TransportController {
         await this.secrets.createTemplatorSecrets(secretId, template.cache, creationContentCipher.publicCreationContentCrypto);
 
         const creationContent = await this.decryptCreationContent(backboneRelationship.creationContent, CoreAddress.from(backboneRelationship.from), secretId);
-        const relationship = Relationship.fromBackboneAndCreationContent(backboneRelationship, template, creationContent.identity, creationContent.content, secretId);
+        const relationship = Relationship.fromBackboneAndCreationContent(backboneRelationship, creationContent.identity, creationContent.content, secretId);
 
         await this.relationships.create(relationship);
         return relationship;

diff --git a/packages/transport/src/modules/relationships/local/CachedRelationship.ts b/packages/transport/src/modules/relationships/local/CachedRelationship.ts
@@ -1,10 +1,9 @@
 import { ISerializable, Serializable, serialize, type, validate } from "@js-soft/ts-serval";
-import { CoreDate, ICoreDate } from "@nmshd/core-types";
-import { IRelationshipTemplate, RelationshipTemplate } from "../../relationshipTemplates/local/RelationshipTemplate";
+import { CoreDate, CoreId, ICoreDate, ICoreId } from "@nmshd/core-types";
 import { IRelationshipAuditLogEntry, RelationshipAuditLogEntry } from "./RelationshipAuditLogEntry";
 
 export interface ICachedRelationship extends ISerializable {
-    template: IRelationshipTemplate;
+    templateId: ICoreId;
     creationContent: ISerializable;
 
     lastMessageSentAt?: ICoreDate;
@@ -16,7 +15,7 @@ export interface ICachedRelationship extends ISerializable {
 export class CachedRelationship extends Serializable implements ICachedRelationship {
     @validate()
     @serialize()
-    public template: RelationshipTemplate;
+    public templateId: CoreId;
 
     @validate()
     @serialize()
@@ -34,6 +33,15 @@ export class CachedRelationship extends Serializable implements ICachedRelations
     @serialize({ type: RelationshipAuditLogEntry })
     public auditLog: RelationshipAuditLogEntry[];
 
+    public static override preFrom(value: any): any {
+        if (typeof value.template !== "undefined") {
+            value.templateId = value.template.id;
+            delete value.template;
+        }
+
+        return value;
+    }
+
     public static from(value: ICachedRelationship): CachedRelationship {
         return this.fromAny(value);
     }

diff --git a/packages/transport/src/modules/relationships/local/Relationship.ts b/packages/transport/src/modules/relationships/local/Relationship.ts
@@ -3,7 +3,6 @@ import { CoreDate, CoreId, ICoreId } from "@nmshd/core-types";
 import { nameof } from "ts-simple-nameof";
 import { CoreSynchronizable, ICoreSynchronizable, TransportError } from "../../../core";
 import { Identity, IIdentity } from "../../accounts/data/Identity";
-import { IRelationshipTemplate } from "../../relationshipTemplates/local/RelationshipTemplate";
 import { BackboneGetRelationshipResponse } from "../backbone/BackboneGetRelationships";
 import { RelationshipStatus } from "../transmission/RelationshipStatus";
 import { CachedRelationship, ICachedRelationship } from "./CachedRelationship";
@@ -74,23 +73,23 @@ export class Relationship extends CoreSynchronizable implements IRelationship {
         // Adds flattened peerAddress and templateId to the JSON stored in the database.
         // This helps us to boost the performance of database queries that include these fields.
         json.peerAddress = this.peer.address.toString();
-        json.templateId = this.cache?.template.id.toString();
+        json.templateId = this.cache?.templateId.toString();
 
         return json;
     }
 
     public static fromBackboneAndCreationContent(
         response: BackboneGetRelationshipResponse,
-        template: IRelationshipTemplate,
         peer: IIdentity,
         creationContent: ISerializable,
         relationshipSecretId: CoreId
     ): Relationship {
         const cache = CachedRelationship.from({
             creationContent,
-            template: template,
+            templateId: CoreId.from(response.relationshipTemplateId),
             auditLog: RelationshipAuditLog.fromBackboneAuditLog(response.auditLog)
         });
+
         return Relationship.from({
             id: CoreId.from(response.id),
             relationshipSecretId: relationshipSecretId,