Add type parameter to Envelope and BaseController

packages/types/src/infrastructure/httpServer/BaseController.ts

@@ -6,20 +6,20 @@ import { Envelope } from "./common/Envelope";
 import { Mimetype } from "./common/Mimetype";
 
 export abstract class BaseController {
-    protected created<T>(result: Result<T>): Return.NewResource<Envelope> {
-        return new Return.NewResource<Envelope>("_", this.json<T>(result));
+    protected created<T>(result: Result<T>): Return.NewResource<Envelope<T>> {
+        return new Return.NewResource<Envelope<T>>("_", this.json<T>(result));
     }
 
-    protected ok<T>(result: Result<T>): Envelope {
-        return this.json(result);
+    protected ok<T>(result: Result<T>): Envelope<T> {
+        return this.json<T>(result);
     }
 
     protected noContent<T>(result: Result<T>): void {
-        this.guard(result);
+        this.guard<T>(result);
         return;
     }
 
-    private json<T>(result: Result<T>): Envelope {
+    private json<T>(result: Result<T>): Envelope<T> {
         this.guard(result);
         return Envelope.ok(result.value);
     }

packages/types/src/infrastructure/httpServer/common/Envelope.ts

@@ -1,17 +1,17 @@
 import { ConnectorMode } from "../../../ConnectorMode";
 import { HttpError, HttpErrorJSON } from "./HttpError";
 
-export class Envelope {
+export class Envelope<T> {
     protected constructor(
-        public result?: any,
+        public result?: T,
         public error?: HttpErrorJSON
     ) {}
 
-    public static ok(result: any): Envelope {
+    public static ok<T>(result: T): Envelope<T> {
         return new Envelope(result, undefined);
     }
 
-    public static error(error: HttpError, connectorMode: ConnectorMode): Envelope {
+    public static error(error: HttpError, connectorMode: ConnectorMode): Envelope<undefined> {
         switch (connectorMode) {
             case "debug":
                 return new Envelope(undefined, error.toJSON("verbose"));

src/modules/coreHttpApi/controllers/AccountController.ts

@@ -1,5 +1,5 @@
 import { BaseController, Envelope } from "@nmshd/connector-types";
-import { TransportServices } from "@nmshd/runtime";
+import { GetIdentityInfoResponse, SyncInfo, TransportServices } from "@nmshd/runtime";
 import { Inject } from "@nmshd/typescript-ioc";
 import { Accept, GET, Path, POST, Security } from "@nmshd/typescript-rest";
 
@@ -13,7 +13,7 @@ export class AccountController extends BaseController {
     @GET
     @Path("/IdentityInfo")
     @Accept("application/json")
-    public async getIdentityInfo(): Promise<Envelope> {
+    public async getIdentityInfo(): Promise<Envelope<GetIdentityInfoResponse>> {
         const result = await this.transportServices.account.getIdentityInfo();
         return this.ok(result);
     }
@@ -30,7 +30,7 @@ export class AccountController extends BaseController {
     @GET
     @Path("/SyncInfo")
     @Accept("application/json")
-    public async getSyncInfo(): Promise<Envelope> {
+    public async getSyncInfo(): Promise<Envelope<SyncInfo>> {
         const result = await this.transportServices.account.getSyncInfo();
         return this.ok(result);
     }

src/modules/coreHttpApi/controllers/AnnouncementsController.ts

@@ -1,5 +1,5 @@
 import { BaseController, Envelope } from "@nmshd/connector-types";
-import { TransportServices } from "@nmshd/runtime";
+import { AnnouncementDTO, TransportServices } from "@nmshd/runtime";
 import { Inject } from "@nmshd/typescript-ioc";
 import { Accept, GET, Path, QueryParam, Security } from "@nmshd/typescript-rest";
 
@@ -12,7 +12,7 @@ export class AnnouncementsController extends BaseController {
 
     @GET
     @Accept("application/json")
-    public async getAnnouncements(@QueryParam("language") language: string): Promise<Envelope> {
+    public async getAnnouncements(@QueryParam("language") language: string): Promise<Envelope<AnnouncementDTO[]>> {
         const result = await this.transportServices.announcements.getAnnouncements({ language: language as any });
         return this.ok(result);
     }

src/modules/coreHttpApi/controllers/AttributesController.ts

@@ -1,7 +1,19 @@
 import { BaseController, Envelope } from "@nmshd/connector-types";
-import { ConsumptionServices, RuntimeErrors } from "@nmshd/runtime";
+import {
+    AttributeTagCollectionDTO,
+    CanCreateOwnIdentityAttributeResponse,
+    ConsumptionServices,
+    DeleteAttributeAndNotifyResponse,
+    LocalAttributeDTO,
+    LocalAttributeForwardingDetailsDTO,
+    NotifyPeerAboutOwnIdentityAttributeSuccessionResponse,
+    RuntimeErrors,
+    SucceedOwnIdentityAttributeResponse,
+    SucceedRelationshipAttributeAndNotifyPeerResponse,
+    ValidateIQLQueryResponse
+} from "@nmshd/runtime";
 import { Inject } from "@nmshd/typescript-ioc";
-import { Accept, Context, DELETE, GET, POST, PUT, Path, PathParam, QueryParam, Return, Security, ServiceContext } from "@nmshd/typescript-rest";
+import { Accept, Context, DELETE, GET, Path, PathParam, POST, PUT, QueryParam, Return, Security, ServiceContext } from "@nmshd/typescript-rest";
 
 @Security("core:attributes")
 @Path("/api/core/v1/Attributes")
@@ -13,22 +25,25 @@ export class AttributesController extends BaseController {
     @PUT
     @Path("CanCreate")
     @Accept("application/json")
-    public async canCreateOwnIdentityAttribute(request: any): Promise<Envelope> {
+    public async canCreateOwnIdentityAttribute(request: any): Promise<Envelope<CanCreateOwnIdentityAttributeResponse>> {
         const result = await this.consumptionServices.attributes.canCreateOwnIdentityAttribute(request);
         return this.ok(result);
     }
 
     @POST
     @Accept("application/json")
-    public async createOwnIdentityAttribute(request: any): Promise<Return.NewResource<Envelope>> {
+    public async createOwnIdentityAttribute(request: any): Promise<Return.NewResource<Envelope<LocalAttributeDTO>>> {
         const result = await this.consumptionServices.attributes.createOwnIdentityAttribute(request);
         return this.created(result);
     }
 
     @POST
     @Path("/:predecessorId/Succeed")
     @Accept("application/json")
-    public async succeedAttribute(@PathParam("predecessorId") predecessorId: string, request: any): Promise<Return.NewResource<Envelope>> {
+    public async succeedAttribute(
+        @PathParam("predecessorId") predecessorId: string,
+        request: any
+    ): Promise<Return.NewResource<Envelope<SucceedOwnIdentityAttributeResponse | SucceedRelationshipAttributeAndNotifyPeerResponse>>> {
         const result = await this.consumptionServices.attributes.getAttribute({ id: predecessorId });
         if (result.isError) {
             throw RuntimeErrors.general.recordNotFoundWithMessage(`Predecessor attribute '${predecessorId}' not found.`);
@@ -54,22 +69,28 @@ export class AttributesController extends BaseController {
     @POST
     @Path("/:id/NotifyPeer")
     @Accept("application/json")
-    public async notifyPeerAboutOwnIdentityAttributeSuccession(@PathParam("id") attributeId: string, request: any): Promise<Return.NewResource<Envelope>> {
+    public async notifyPeerAboutOwnIdentityAttributeSuccession(
+        @PathParam("id") attributeId: string,
+        request: any
+    ): Promise<Return.NewResource<Envelope<NotifyPeerAboutOwnIdentityAttributeSuccessionResponse>>> {
         const result = await this.consumptionServices.attributes.notifyPeerAboutOwnIdentityAttributeSuccession({ attributeId: attributeId, peer: request.peer });
         return this.created(result);
     }
 
     @GET
     @Accept("application/json")
-    public async getAttributes(@Context context: ServiceContext): Promise<Envelope> {
+    public async getAttributes(@Context context: ServiceContext): Promise<Envelope<LocalAttributeDTO[]>> {
         const result = await this.consumptionServices.attributes.getAttributes({ query: context.request.query });
         return this.ok(result);
     }
 
     @GET
     @Path("/Own/Identity")
     @Accept("application/json")
-    public async getOwnIdentityAttributes(@Context context: ServiceContext, @QueryParam("onlyLatestVersions") onlyLatestVersions?: boolean): Promise<Envelope> {
+    public async getOwnIdentityAttributes(
+        @Context context: ServiceContext,
+        @QueryParam("onlyLatestVersions") onlyLatestVersions?: boolean
+    ): Promise<Envelope<LocalAttributeDTO[]>> {
         const query: Record<string, any> = this.extractQuery(context.request.query, ["onlyLatestVersions"]);
         const result = await this.consumptionServices.attributes.getOwnIdentityAttributes({ onlyLatestVersions, query });
         return this.ok(result);
@@ -83,7 +104,7 @@ export class AttributesController extends BaseController {
         @PathParam("peer") peer: string,
         @QueryParam("onlyLatestVersions") onlyLatestVersions?: boolean,
         @QueryParam("hideTechnical") hideTechnical?: boolean
-    ): Promise<Envelope> {
+    ): Promise<Envelope<LocalAttributeDTO[]>> {
         const query: Record<string, any> = this.extractQuery(context.request.query, ["onlyLatestVersions", "hideTechnical"]);
         const result = await this.consumptionServices.attributes.getOwnAttributesSharedWithPeer({ peer, onlyLatestVersions, hideTechnical, query });
         return this.ok(result);
@@ -97,7 +118,7 @@ export class AttributesController extends BaseController {
         @PathParam("peer") peer: string,
         @QueryParam("onlyLatestVersions") onlyLatestVersions?: boolean,
         @QueryParam("hideTechnical") hideTechnical?: boolean
-    ): Promise<Envelope> {
+    ): Promise<Envelope<LocalAttributeDTO[]>> {
         const query: Record<string, any> = this.extractQuery(context.request.query, ["onlyLatestVersions", "hideTechnical"]);
         const result = await this.consumptionServices.attributes.getPeerAttributes({ peer, onlyLatestVersions, hideTechnical, query });
         return this.ok(result);
@@ -106,15 +127,15 @@ export class AttributesController extends BaseController {
     @GET
     @Path("/:id/ForwardingDetails")
     @Accept("application/json")
-    public async getForwardingDetailsForAttribute(@Context context: ServiceContext, @PathParam("id") attributeId: string): Promise<Envelope> {
+    public async getForwardingDetailsForAttribute(@Context context: ServiceContext, @PathParam("id") attributeId: string): Promise<Envelope<LocalAttributeForwardingDetailsDTO[]>> {
         const result = await this.consumptionServices.attributes.getForwardingDetailsForAttribute({ attributeId, query: context.request.query });
         return this.ok(result);
     }
 
     @GET
     @Path("/:id/Versions")
     @Accept("application/json")
-    public async getVersionsOfAttribute(@PathParam("id") attributeId: string): Promise<Envelope> {
+    public async getVersionsOfAttribute(@PathParam("id") attributeId: string): Promise<Envelope<LocalAttributeDTO[]>> {
         const result = await this.consumptionServices.attributes.getVersionsOfAttribute({
             attributeId
         });
@@ -128,70 +149,70 @@ export class AttributesController extends BaseController {
         @PathParam("id") attributeId: string,
         @QueryParam("peer") peer: string,
         @QueryParam("onlyLatestVersions") onlyLatestVersions?: boolean
-    ): Promise<Envelope> {
+    ): Promise<Envelope<LocalAttributeDTO[]>> {
         const result = await this.consumptionServices.attributes.getVersionsOfAttributeSharedWithPeer({ attributeId, onlyLatestVersions, peer });
         return this.ok(result);
     }
 
     @GET
     @Path("/TagCollection")
     @Accept("application/json")
-    public async getAttributeTagCollection(): Promise<Envelope> {
+    public async getAttributeTagCollection(): Promise<Envelope<AttributeTagCollectionDTO>> {
         const result = await this.consumptionServices.attributes.getAttributeTagCollection();
         return this.ok(result);
     }
 
     @POST
     @Path("/ExecuteIdentityAttributeQuery")
     @Accept("application/json")
-    public async executeIdentityAttributeQuery(request: any): Promise<Envelope> {
+    public async executeIdentityAttributeQuery(request: any): Promise<Envelope<LocalAttributeDTO[]>> {
         const result = await this.consumptionServices.attributes.executeIdentityAttributeQuery(request);
         return this.ok(result);
     }
 
     @POST
     @Path("/ExecuteRelationshipAttributeQuery")
     @Accept("application/json")
-    public async executeRelationshipAttributeQuery(request: any): Promise<Envelope> {
+    public async executeRelationshipAttributeQuery(request: any): Promise<Envelope<LocalAttributeDTO>> {
         const result = await this.consumptionServices.attributes.executeRelationshipAttributeQuery(request);
         return this.ok(result);
     }
 
     @POST
     @Path("/ExecuteThirdPartyRelationshipAttributeQuery")
     @Accept("application/json")
-    public async executeThirdPartyRelationshipAttributeQuery(request: any): Promise<Envelope> {
+    public async executeThirdPartyRelationshipAttributeQuery(request: any): Promise<Envelope<LocalAttributeDTO[]>> {
         const result = await this.consumptionServices.attributes.executeThirdPartyRelationshipAttributeQuery(request);
         return this.ok(result);
     }
 
     @POST
     @Path("/ExecuteIQLQuery")
     @Accept("application/json")
-    public async executeIQLQuery(request: any): Promise<Envelope> {
+    public async executeIQLQuery(request: any): Promise<Envelope<LocalAttributeDTO[]>> {
         const result = await this.consumptionServices.attributes.executeIQLQuery(request);
         return this.ok(result);
     }
 
     @POST
     @Path("/ValidateIQLQuery")
     @Accept("application/json")
-    public async validateIQLQuery(request: any): Promise<Envelope> {
+    public async validateIQLQuery(request: any): Promise<Envelope<ValidateIQLQueryResponse>> {
         const result = await this.consumptionServices.attributes.validateIQLQuery(request);
         return this.ok(result);
     }
 
     @GET
     @Path("/:id")
     @Accept("application/json")
-    public async getAttribute(@PathParam("id") id: string): Promise<Envelope> {
+    public async getAttribute(@PathParam("id") id: string): Promise<Envelope<LocalAttributeDTO>> {
         const result = await this.consumptionServices.attributes.getAttribute({ id });
         return this.ok(result);
     }
 
     @DELETE
     @Path(":id")
-    public async deleteAttributeAndNotify(@PathParam("id") attributeId: string): Promise<Envelope> {
+    public async deleteAttributeAndNotify(@PathParam("id") attributeId: string): Promise<Envelope<DeleteAttributeAndNotifyResponse>> {
         const result = await this.consumptionServices.attributes.deleteAttributeAndNotify({ attributeId });
         return this.ok(result);
     }

src/modules/coreHttpApi/controllers/ChallengesController.ts

@@ -1,5 +1,5 @@
 import { BaseController, Envelope } from "@nmshd/connector-types";
-import { TransportServices } from "@nmshd/runtime";
+import { ChallengeDTO, TransportServices, ValidateChallengeResponse } from "@nmshd/runtime";
 import { Inject } from "@nmshd/typescript-ioc";
 import { Accept, Path, POST, Return, Security } from "@nmshd/typescript-rest";
 
@@ -12,15 +12,15 @@ export class ChallengesController extends BaseController {
 
     @POST
     @Accept("application/json")
-    public async createChallenge(request: any): Promise<Return.NewResource<Envelope>> {
+    public async createChallenge(request: any): Promise<Return.NewResource<Envelope<ChallengeDTO>>> {
         const result = await this.transportServices.challenges.createChallenge(request);
         return this.created(result);
     }
 
     @POST
     @Path("/Validate")
     @Accept("application/json")
-    public async validateChallenge(request: any): Promise<Envelope> {
+    public async validateChallenge(request: any): Promise<Envelope<ValidateChallengeResponse>> {
         const result = await this.transportServices.challenges.validateChallenge(request);
         return this.ok(result);
     }

src/modules/coreHttpApi/controllers/FilesController.ts

@@ -1,6 +1,6 @@
 import { BaseController, Envelope, Mimetype } from "@nmshd/connector-types";
 import { Reference } from "@nmshd/core-types";
-import { OwnerRestriction, TransportServices } from "@nmshd/runtime";
+import { FileDTO, OwnerRestriction, TokenDTO, TransportServices } from "@nmshd/runtime";
 import { Inject } from "@nmshd/typescript-ioc";
 import {
     Accept,
@@ -37,7 +37,7 @@ export class FilesController extends BaseController {
         @FileParam("file") file?: Express.Multer.File,
         @FormParam("description") description?: string,
         @FormParam("tags") tags?: string[]
-    ): Promise<Return.NewResource<Envelope>> {
+    ): Promise<Return.NewResource<Envelope<FileDTO>>> {
         const result = await this.transportServices.files.uploadOwnFile({
             content: file?.buffer,
             expiresAt,
@@ -53,7 +53,7 @@ export class FilesController extends BaseController {
     @POST
     @Path("/Peer")
     @Accept("application/json")
-    public async loadPeerFile(request: any): Promise<Return.NewResource<Envelope>> {
+    public async loadPeerFile(request: any): Promise<Return.NewResource<Envelope<FileDTO>>> {
         const result = await this.transportServices.files.getOrLoadFile(request);
         return this.created(result);
     }
@@ -75,31 +75,35 @@ export class FilesController extends BaseController {
 
     @GET
     @Accept("application/json")
-    public async getFiles(@Context context: ServiceContext): Promise<Envelope> {
+    public async getFiles(@Context context: ServiceContext): Promise<Envelope<FileDTO[]>> {
         const result = await this.transportServices.files.getFiles({ query: context.request.query });
         return this.ok(result);
     }
 
     @GET
     @Path("/Own")
     @Accept("application/json")
-    public async getOwnFiles(@Context context: ServiceContext): Promise<Envelope> {
+    public async getOwnFiles(@Context context: ServiceContext): Promise<Envelope<FileDTO[]>> {
         const result = await this.transportServices.files.getFiles({ query: context.request.query, ownerRestriction: OwnerRestriction.Own });
         return this.ok(result);
     }
 
     @GET
     @Path("/Peer")
     @Accept("application/json")
-    public async getPeerFiles(@Context context: ServiceContext): Promise<Envelope> {
+    public async getPeerFiles(@Context context: ServiceContext): Promise<Envelope<FileDTO[]>> {
         const result = await this.transportServices.files.getFiles({ query: context.request.query, ownerRestriction: OwnerRestriction.Peer });
         return this.ok(result);
     }
 
     @GET
     @Path("/:idOrReference")
     @Accept("application/json", "image/png")
-    public async getFile(@PathParam("idOrReference") idOrReference: string, @ContextAccept accept: string, @ContextResponse response: express.Response): Promise<Envelope | void> {
+    public async getFile(
+        @PathParam("idOrReference") idOrReference: string,
+        @ContextAccept accept: string,
+        @ContextResponse response: express.Response
+    ): Promise<Envelope<FileDTO> | void> {
         const fileId = idOrReference.startsWith("FIL") ? idOrReference : Reference.from(idOrReference).id.toString();
 
         const result = await this.transportServices.files.getFile({ id: fileId });
@@ -120,7 +124,7 @@ export class FilesController extends BaseController {
         @ContextAccept accept: string,
         @ContextResponse response: express.Response,
         request: any
-    ): Promise<Return.NewResource<Envelope> | void> {
+    ): Promise<Return.NewResource<Envelope<TokenDTO>> | void> {
         const result = await this.transportServices.files.createTokenForFile({
             fileId: id,
             expiresAt: request.expiresAt,
@@ -146,7 +150,7 @@ export class FilesController extends BaseController {
 
     @PATCH
     @Path("/:id/RegenerateOwnershipToken")
-    public async regenerateOwnershipToken(@PathParam("id") id: string): Promise<Envelope> {
+    public async regenerateOwnershipToken(@PathParam("id") id: string): Promise<Envelope<FileDTO>> {
         const result = await this.transportServices.files.regenerateFileOwnershipToken({ id });
         return this.ok(result);
     }