@clairejs/server 3.15.2 → 3.16.0

package/.mocharc.json

@@ -0,0 +1,3 @@
+{
+    "node-option": ["experimental-specifier-resolution=node", "loader=ts-node/esm"]
+}

package/dist/common/AbstractController.js

@@ -0,0 +1,3 @@
+import { Transactionable } from "./Transactionable";
+export class AbstractController extends Transactionable {
+}

package/dist/common/ControllerMetadata.js

@@ -0,0 +1 @@
+export {};

package/dist/common/FileOperation.js

@@ -0,0 +1,6 @@
+export var FileOperation;
+(function (FileOperation) {
+    FileOperation["GET"] = "getObject";
+    FileOperation["PUT"] = "putObject";
+    FileOperation["DELETE"] = "deleteObject";
+})(FileOperation || (FileOperation = {}));

package/dist/common/ServerModelMetadata.js

@@ -0,0 +1 @@
+export {};

package/dist/common/Transactionable.js

@@ -0,0 +1,17 @@
+import { Errors } from "@clairejs/core";
+import { getTransactionFromContext } from "@clairejs/orm";
+export class Transactionable {
+    transactionFactory;
+    constructor(transactionFactory) {
+        this.transactionFactory = transactionFactory;
+    }
+    async createTransaction() {
+        if (!this.transactionFactory) {
+            throw Errors.SYSTEM_ERROR("Transaction factory not injected to this class");
+        }
+        return this.transactionFactory.createTransaction();
+    }
+    async getCurrentTransaction() {
+        return getTransactionFromContext(this);
+    }
+}

package/dist/common/auth/AbstractPrincipalResolver.js

@@ -0,0 +1,2 @@
+export class AbstractPrincipalResolver {
+}

package/dist/common/auth/IPrincipal.js

@@ -0,0 +1 @@
+export {};

package/dist/common/constants.js

@@ -0,0 +1,7 @@
+//@internal
+export const ExitCode = {
+    SIGTERM_INTERUPTION: -1,
+    SIGINT_INTERUPTION: -2,
+    UNCAUGHT_EXCEPTION: -3,
+    UNHANDLED_REJECTION: -4,
+};

package/dist/common/decorator.d.ts

@@ -1,5 +1,5 @@
 import { Constructor } from "@clairejs/core";
 import { AbstractController } from "./AbstractController";
 export declare const Controller: (config?: {
-    permissionGroup?: string | undefined;
-} | undefined) => <T extends AbstractController>(constructor: Constructor<T>) => void;
+    permissionGroup?: string;
+}) => <T extends AbstractController>(constructor: Constructor<T>) => void;

package/dist/common/decorator.js

@@ -0,0 +1,6 @@
+import { getServiceProvider, initObjectMetadata } from "@clairejs/core";
+export const Controller = (config) => (constructor) => {
+    getServiceProvider().register(constructor, "singleton");
+    const metadata = initObjectMetadata(constructor.prototype);
+    metadata.permissionGroup = config?.permissionGroup;
+};

package/dist/common/request/EndpointMetadata.js

@@ -0,0 +1 @@
+export {};

package/dist/common/request/HttpData.js

@@ -0,0 +1 @@
+export {};

package/dist/common/request/HttpEndpoint.js

@@ -0,0 +1 @@
+export {};

package/dist/common/request/JobData.js

@@ -0,0 +1 @@
+export {};

package/dist/common/request/MountedEndpointInfo.js

@@ -0,0 +1 @@
+export {};

package/dist/common/request/RequestOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/common/request/SocketData.js

@@ -0,0 +1 @@
+export {};

package/dist/common/request/types.d.ts

@@ -1 +1 @@
-export declare type RequestDataSource = "body" | "params" | "queries" | "headers" | "socket" | "raw";
+export type RequestDataSource = "body" | "params" | "queries" | "headers" | "socket" | "raw";

package/dist/common/request/types.js

@@ -0,0 +1 @@
+export {};

package/dist/controllers/FileManageController.js

@@ -0,0 +1,90 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Injectable } from "@clairejs/core";
+import { ResponseBuilder } from "../http/common/HttpResponse";
+import { AbstractHttpController } from "../http/controller/AbstractHttpController";
+import { ApiResponse, Body, Get, Post, Queries } from "../http/decorators";
+import { AbstractFileService } from "../services/AbstractFileService";
+import { GetFileAccessUrlRequest, GetFileAccessUrlResponse, GetFileInfoRequest, GetFileInfoResponse, MoveFileRequest, RemoveFileRequest, } from "./dto/upload";
+let FileManageController = class FileManageController extends AbstractHttpController {
+    fileService;
+    constructor(fileService) {
+        super(null);
+        this.fileService = fileService;
+    }
+    async moveFile(body) {
+        await this.fileService.moveObject(body.operations);
+        return ResponseBuilder.success();
+    }
+    async copyFile(body) {
+        await this.fileService.copyObject(body.operations);
+        return ResponseBuilder.success();
+    }
+    async removeFile(body) {
+        await this.fileService.removeObject(body.uris);
+        return ResponseBuilder.success();
+    }
+    async getFileAccessUrl(queries) {
+        const result = await this.fileService.getAccessUrls(queries.uris, queries.public);
+        return ResponseBuilder.json({ urls: result }).get();
+    }
+    async getFileInfo(queries) {
+        const result = await this.fileService.getFileSize(queries.uris);
+        const response = {
+            fileInfos: result.map((size) => ({ fileSizeBytes: size })),
+        };
+        return ResponseBuilder.json(response).get();
+    }
+};
+__decorate([
+    Post("/file/move"),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [MoveFileRequest]),
+    __metadata("design:returntype", Promise)
+], FileManageController.prototype, "moveFile", null);
+__decorate([
+    Post("/file/copy"),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [MoveFileRequest]),
+    __metadata("design:returntype", Promise)
+], FileManageController.prototype, "copyFile", null);
+__decorate([
+    Post("/file/remove"),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [RemoveFileRequest]),
+    __metadata("design:returntype", Promise)
+], FileManageController.prototype, "removeFile", null);
+__decorate([
+    Get("/file"),
+    ApiResponse(GetFileAccessUrlResponse),
+    __param(0, Queries()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [GetFileAccessUrlRequest]),
+    __metadata("design:returntype", Promise)
+], FileManageController.prototype, "getFileAccessUrl", null);
+__decorate([
+    Get("/file/info"),
+    ApiResponse(GetFileInfoResponse),
+    __param(0, Queries()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [GetFileInfoRequest]),
+    __metadata("design:returntype", Promise)
+], FileManageController.prototype, "getFileInfo", null);
+FileManageController = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [AbstractFileService])
+], FileManageController);
+export { FileManageController };

package/dist/controllers/FileUploadController.js

@@ -0,0 +1,64 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Errors, Injectable } from "@clairejs/core";
+import randomstring from "randomstring";
+import { ResponseBuilder } from "../http/common/HttpResponse";
+import { AbstractHttpController } from "../http/controller/AbstractHttpController";
+import { ApiResponse, Get, Queries } from "../http/decorators";
+import { AbstractFileService } from "../services/AbstractFileService";
+import { GetMultipleUploadResponseBody, GetMultipleUploadUrlsQueries, GetUploadUrlQueries, GetUploadUrlResponseBody, } from "./dto/upload";
+let FileUploadController = class FileUploadController extends AbstractHttpController {
+    fileService;
+    allowedUploadExtensions;
+    constructor(fileService, allowedUploadExtensions) {
+        super(null);
+        this.fileService = fileService;
+        this.allowedUploadExtensions = allowedUploadExtensions;
+    }
+    async getUploadUrl(queries) {
+        const ext = queries.extension?.toLowerCase();
+        if (ext && !this.allowedUploadExtensions.includes(ext)) {
+            throw Errors.VALIDATION_ERROR("Not allowed file extension");
+        }
+        const urls = await this.fileService.getUploadUrlForTempUri(`tmp/${randomstring.generate({ length: 64 })}${ext ? `.${ext}` : ""}`);
+        return ResponseBuilder.json(urls).get();
+    }
+    async getMultipleUploadUrls(queries) {
+        if (queries.extensions.some((ext) => !this.allowedUploadExtensions.includes(ext))) {
+            throw Errors.VALIDATION_ERROR("Not allowed file extension");
+        }
+        const urls = await Promise.all(queries.extensions.map((ext) => this.fileService.getUploadUrlForTempUri(`tmp/${randomstring.generate({ length: 64 })}${ext ? `.${ext}` : ""}`)));
+        return ResponseBuilder.json({ files: urls }).get();
+    }
+};
+__decorate([
+    Get("/upload-url"),
+    ApiResponse(GetUploadUrlResponseBody),
+    __param(0, Queries()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [GetUploadUrlQueries]),
+    __metadata("design:returntype", Promise)
+], FileUploadController.prototype, "getUploadUrl", null);
+__decorate([
+    Get("/upload-urls"),
+    ApiResponse(GetMultipleUploadResponseBody),
+    __param(0, Queries()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [GetMultipleUploadUrlsQueries]),
+    __metadata("design:returntype", Promise)
+], FileUploadController.prototype, "getMultipleUploadUrls", null);
+FileUploadController = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [AbstractFileService, Array])
+], FileUploadController);
+export { FileUploadController };

package/dist/controllers/dto/system.js

@@ -0,0 +1,14 @@
+export var CacheOperation;
+(function (CacheOperation) {
+    CacheOperation["GET"] = "get";
+    CacheOperation["KEYS"] = "keys";
+    CacheOperation["HGET"] = "hget";
+    CacheOperation["HKEYS"] = "hkeys";
+    CacheOperation["FLUSH"] = "flush";
+})(CacheOperation || (CacheOperation = {}));
+export var UserVerificationMethod;
+(function (UserVerificationMethod) {
+    UserVerificationMethod["SMS_OTP"] = "SMS";
+    UserVerificationMethod["VOICE_OTP"] = "VOICE";
+    UserVerificationMethod["MANUAL_OTP"] = "MANUAL";
+})(UserVerificationMethod || (UserVerificationMethod = {}));

package/dist/controllers/dto/upload.js

@@ -0,0 +1,205 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Data, DataType, ElementDto, Field } from "@clairejs/core";
+let GetUploadUrlQueries = class GetUploadUrlQueries {
+    extension;
+};
+__decorate([
+    Field({
+        description: "Extension of the file to be uploaded (without dot)",
+    }),
+    __metadata("design:type", String)
+], GetUploadUrlQueries.prototype, "extension", void 0);
+GetUploadUrlQueries = __decorate([
+    Data()
+], GetUploadUrlQueries);
+export { GetUploadUrlQueries };
+let GetUploadUrlResponseBody = class GetUploadUrlResponseBody {
+    objectKey;
+    putPresignedUrl;
+    deletePresignedUrl;
+};
+__decorate([
+    Field({
+        description: "Object key of file that store in the server",
+        isRequired: true,
+    }),
+    __metadata("design:type", String)
+], GetUploadUrlResponseBody.prototype, "objectKey", void 0);
+__decorate([
+    Field({
+        description: "Presigned URl to put the file to server",
+    }),
+    __metadata("design:type", String)
+], GetUploadUrlResponseBody.prototype, "putPresignedUrl", void 0);
+__decorate([
+    Field({
+        description: "Presigned URL to remove the temporary file from server",
+        isRequired: true,
+    }),
+    __metadata("design:type", String)
+], GetUploadUrlResponseBody.prototype, "deletePresignedUrl", void 0);
+GetUploadUrlResponseBody = __decorate([
+    Data()
+], GetUploadUrlResponseBody);
+export { GetUploadUrlResponseBody };
+let GetMultipleUploadUrlsQueries = class GetMultipleUploadUrlsQueries {
+    extensions;
+};
+__decorate([
+    Field({
+        description: "Extensions of those files",
+        isRequired: true,
+        vectorProps: { allowDuplicated: true },
+    }),
+    __metadata("design:type", Array)
+], GetMultipleUploadUrlsQueries.prototype, "extensions", void 0);
+GetMultipleUploadUrlsQueries = __decorate([
+    Data({ relaxed: true })
+], GetMultipleUploadUrlsQueries);
+export { GetMultipleUploadUrlsQueries };
+export class GetMultipleUploadResponseBody {
+    files;
+}
+__decorate([
+    Field({
+        description: "Upload urls for files",
+        vectorProps: { elementDataType: DataType.OBJECT },
+        ...ElementDto(GetUploadUrlResponseBody),
+    }),
+    __metadata("design:type", Array)
+], GetMultipleUploadResponseBody.prototype, "files", void 0);
+let MoveOperation = class MoveOperation {
+    fromURI;
+    toURI;
+};
+__decorate([
+    Field({ description: "Source of move operation", isRequired: true }),
+    __metadata("design:type", String)
+], MoveOperation.prototype, "fromURI", void 0);
+__decorate([
+    Field({ description: "Destination of move operation", isRequired: true }),
+    __metadata("design:type", String)
+], MoveOperation.prototype, "toURI", void 0);
+MoveOperation = __decorate([
+    Data()
+], MoveOperation);
+export { MoveOperation };
+let MoveFileRequest = class MoveFileRequest {
+    operations;
+};
+__decorate([
+    Field({
+        description: "All move operations",
+        isRequired: true,
+        vectorProps: { elementDataType: DataType.OBJECT },
+        ...ElementDto(MoveOperation),
+    }),
+    __metadata("design:type", Array)
+], MoveFileRequest.prototype, "operations", void 0);
+MoveFileRequest = __decorate([
+    Data()
+], MoveFileRequest);
+export { MoveFileRequest };
+let RemoveFileRequest = class RemoveFileRequest {
+    uris;
+};
+__decorate([
+    Field({
+        description: "File URIs to remove",
+        isRequired: true,
+        vectorProps: { elementDataType: DataType.STRING },
+    }),
+    __metadata("design:type", Array)
+], RemoveFileRequest.prototype, "uris", void 0);
+RemoveFileRequest = __decorate([
+    Data()
+], RemoveFileRequest);
+export { RemoveFileRequest };
+let GetFileAccessUrlRequest = class GetFileAccessUrlRequest {
+    uris;
+    public;
+};
+__decorate([
+    Field({
+        description: "All URIs to get access link",
+        isRequired: true,
+        vectorProps: { elementDataType: DataType.STRING },
+    }),
+    __metadata("design:type", Array)
+], GetFileAccessUrlRequest.prototype, "uris", void 0);
+__decorate([
+    Field({
+        description: "Whether to get public or private link",
+        isRequired: true,
+    }),
+    __metadata("design:type", Boolean)
+], GetFileAccessUrlRequest.prototype, "public", void 0);
+GetFileAccessUrlRequest = __decorate([
+    Data({ relaxed: true })
+], GetFileAccessUrlRequest);
+export { GetFileAccessUrlRequest };
+let GetFileAccessUrlResponse = class GetFileAccessUrlResponse {
+    urls;
+};
+__decorate([
+    Field({
+        description: "File access URLs",
+        isRequired: true,
+        vectorProps: { elementDataType: DataType.STRING },
+    }),
+    __metadata("design:type", Array)
+], GetFileAccessUrlResponse.prototype, "urls", void 0);
+GetFileAccessUrlResponse = __decorate([
+    Data()
+], GetFileAccessUrlResponse);
+export { GetFileAccessUrlResponse };
+let GetFileInfoRequest = class GetFileInfoRequest {
+    uris;
+};
+__decorate([
+    Field({
+        description: "File URIs to get info",
+        isRequired: true,
+        vectorProps: { elementDataType: DataType.STRING },
+    }),
+    __metadata("design:type", Array)
+], GetFileInfoRequest.prototype, "uris", void 0);
+GetFileInfoRequest = __decorate([
+    Data({ relaxed: true })
+], GetFileInfoRequest);
+export { GetFileInfoRequest };
+let FileInfo = class FileInfo {
+    fileSizeBytes;
+};
+__decorate([
+    Field({ description: "Size of file in bytes", isRequired: true }),
+    __metadata("design:type", Number)
+], FileInfo.prototype, "fileSizeBytes", void 0);
+FileInfo = __decorate([
+    Data()
+], FileInfo);
+export { FileInfo };
+let GetFileInfoResponse = class GetFileInfoResponse {
+    fileInfos;
+};
+__decorate([
+    Field({
+        description: "File infos",
+        isRequired: true,
+        vectorProps: { elementDataType: DataType.OBJECT },
+        ...ElementDto(FileInfo),
+    }),
+    __metadata("design:type", Array)
+], GetFileInfoResponse.prototype, "fileInfos", void 0);
+GetFileInfoResponse = __decorate([
+    Data()
+], GetFileInfoResponse);
+export { GetFileInfoResponse };

package/dist/http/auth/AbstractHttpAuthorizer.js

@@ -0,0 +1,2 @@
+export class AbstractRequestAuthorizer {
+}

package/dist/http/common/HttpRequest.js

@@ -0,0 +1,72 @@
+import { HttpMethod, validateData, Errors } from "@clairejs/core";
+export class HttpRequest {
+    endpointMetadata;
+    valueHolder = {};
+    clientIP;
+    headers;
+    method;
+    hash;
+    pathName;
+    cookies;
+    params = {};
+    query = {};
+    body = {};
+    authInfo;
+    constructor(options, endpointMetadata) {
+        this.endpointMetadata = endpointMetadata;
+        this.clientIP = options.clientIP;
+        this.method = options.method;
+        this.pathName = options.pathName;
+        this.headers = (options.headers || {});
+        this.cookies = (options.cookies || {});
+        this.hash = options.hash || "";
+        this.params.data = options.params || {};
+        this.query.data = options.query || {};
+        this.body.data = options.body || {};
+    }
+    jsonParsing(value, modelMetadata) {
+        const result = { ...value };
+        for (const field of modelMetadata.fields) {
+            try {
+                //-- parse if value is found or field is required
+                if (value[field.name] !== undefined || field.isRequired) {
+                    result[field.name] = JSON.parse(value[field.name]);
+                }
+            }
+            catch (err) {
+                throw Errors.VALIDATION_ERROR(`JSON parsing failed for field ${field.name}`);
+            }
+        }
+        return result;
+    }
+    getAuthInfo() {
+        return this.authInfo;
+    }
+    setAuthInfo(authInfo) {
+        this.authInfo = authInfo;
+    }
+    getParams() {
+        if (this.endpointMetadata?.paramsValidationDto && !this.params.validated) {
+            this.params.data = validateData(this.params.data, this.endpointMetadata.paramsValidationDto);
+            this.params.validated = true;
+        }
+        return this.params.data;
+    }
+    getQuery() {
+        if (this.endpointMetadata?.queriesValidationDto && !this.query.validated) {
+            this.query.data = validateData(this.jsonParsing(this.query.data, this.endpointMetadata.queriesValidationDto), this.endpointMetadata.queriesValidationDto);
+            this.query.validated = true;
+        }
+        return this.query.data;
+    }
+    getBody() {
+        if (this.endpointMetadata &&
+            (this.endpointMetadata.httpMethod === HttpMethod.POST ||
+                this.endpointMetadata.httpMethod === HttpMethod.PUT) &&
+            this.endpointMetadata?.bodyValidationDto) {
+            this.body.data = validateData(this.body.data, this.endpointMetadata.bodyValidationDto, false);
+            this.body.validated = true;
+        }
+        return this.body.data;
+    }
+}

package/dist/http/common/HttpResponse.js

@@ -0,0 +1,62 @@
+export class HttpResponse {
+    value;
+    code;
+    headers = {};
+    cookies = {};
+}
+export class ResponseBuilder {
+    response;
+    constructor() {
+        this.response = new HttpResponse();
+    }
+    status(code) {
+        this.response.code = code;
+        return this;
+    }
+    header(name, value) {
+        this.response.headers[name] = value;
+        return this;
+    }
+    cookie(name, value, options) {
+        this.response.cookies[name] = { value, options };
+        return this;
+    }
+    get() {
+        return this.response;
+    }
+    static json(jsonValue) {
+        const builder = new ResponseBuilder();
+        builder.response.value = jsonValue;
+        builder.response.headers["Content-Type"] = "application/json";
+        return builder;
+    }
+    static html(htmlValue) {
+        const builder = new ResponseBuilder();
+        builder.response.value = htmlValue;
+        builder.response.headers["Content-Type"] = "text/html; charset=UTF-8";
+        return builder;
+    }
+    static binary(buffer) {
+        const builder = new ResponseBuilder();
+        builder.response.value = buffer;
+        builder.response.headers["Content-Type"] = "application/octet-stream";
+        return builder;
+    }
+    static success() {
+        const builder = new ResponseBuilder();
+        builder.response.code = 200;
+        return builder.response;
+    }
+    static notFound(data) {
+        const builder = new ResponseBuilder();
+        builder.response.code = 404;
+        builder.response.value = data;
+        return builder.response;
+    }
+    static accessDenied(data) {
+        const builder = new ResponseBuilder();
+        builder.response.code = 403;
+        builder.response.value = data;
+        return builder.response;
+    }
+}

package/dist/http/controller/AbstractHttpController.js

@@ -0,0 +1,21 @@
+import { getObjectMetadata } from "@clairejs/core";
+import { AbstractController } from "../../common/AbstractController";
+const isEndpoint = (metadata) => {
+    return !!metadata.httpMethod || metadata.openAccess !== undefined || !!metadata.accessConditions;
+};
+export class AbstractHttpController extends AbstractController {
+    databaseAdapter;
+    constructor(databaseAdapter) {
+        super(databaseAdapter);
+        this.databaseAdapter = databaseAdapter;
+    }
+    getEndpointMetadata() {
+        const controllerMetadata = getObjectMetadata(this.constructor);
+        if (!controllerMetadata) {
+            return [];
+        }
+        return controllerMetadata.fields
+            .filter((f) => isEndpoint(f))
+            .map((f) => ({ ...f, permissionGroup: controllerMetadata.permissionGroup }));
+    }
+}

package/dist/http/controller/AbstractHttpMiddleware.js

@@ -0,0 +1,2 @@
+export class AbstractHttpMiddleware {
+}