@clairejs/server 3.17.0 → 3.17.1

package/README.md

@@ -1,7 +1,8 @@
 ## Change Log
 
-#### 3.17.0:
+#### 3.17.1:
 
+-   refactor EndpointMetadata, remove MountedEndpointInfo
 -   add putFile in AbstractFileService
 
 #### 3.16.19:

package/dist/common/ControllerMetadata.d.ts

@@ -1,5 +1,5 @@
-import { ObjectMetadata } from "@clairejs/core";
-import { EndpointMetadata } from "./request/EndpointMetadata";
+import { type ObjectMetadata } from "@clairejs/core";
+import { type EndpointMetadata } from "./request/endpoint-metadata";
 export interface ControllerMetadata extends ObjectMetadata {
     fields: EndpointMetadata[];
     permissionGroup?: string;

package/dist/common/request/endpoint-metadata.d.ts

@@ -0,0 +1,12 @@
+import { type ApiInfo, type Constructor, type ObjectFieldMetadata } from "@clairejs/core";
+import { type RequestDataSource } from "./types";
+export interface EndpointMetadata extends ApiInfo, ObjectFieldMetadata {
+    controller: any;
+    handlerFunctionName: string;
+    params?: {
+        [index: number]: {
+            source?: RequestDataSource;
+            diClass?: Constructor<any>;
+        };
+    };
+}

package/dist/http/auth/AbstractHttpAuthorizer.d.ts

@@ -1,5 +1,5 @@
-import { MountedEndpointInfo } from "../../common/request/MountedEndpointInfo";
+import { EndpointMetadata } from "../../common/request/endpoint-metadata";
 import { HttpRequest } from "../common/HttpRequest";
 export declare abstract class AbstractRequestAuthorizer {
-    abstract authorize(req: HttpRequest, endpoint: MountedEndpointInfo): Promise<void>;
+    abstract authorize(req: HttpRequest, endpoint: EndpointMetadata): Promise<void>;
 }

package/dist/http/common/HttpRequest.d.ts

@@ -1,5 +1,5 @@
 import { HttpMethod, SocketMethod } from "@clairejs/core";
-import { EndpointMetadata } from "../../common/request/EndpointMetadata";
+import { EndpointMetadata } from "../../common/request/endpoint-metadata";
 import { IPrincipal } from "../../common/auth/IPrincipal";
 import { IServerSocket } from "../../socket/IServerSocket";
 export declare class HttpRequest {

package/dist/http/common/HttpRequest.js

@@ -46,25 +46,24 @@ export class HttpRequest {
         this.authInfo = authInfo;
     }
     getParams() {
-        if (this.endpointMetadata?.paramsValidationDto && !this.params.validated) {
-            this.params.data = validateData(this.params.data, this.endpointMetadata.paramsValidationDto);
+        if (this.endpointMetadata?.paramDto && !this.params.validated) {
+            this.params.data = validateData(this.params.data, this.endpointMetadata.paramDto);
             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);
+        if (this.endpointMetadata?.queryDto && !this.query.validated) {
+            this.query.data = validateData(this.jsonParsing(this.query.data, this.endpointMetadata.queryDto), this.endpointMetadata.queryDto);
             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.endpointMetadata.method === HttpMethod.POST || this.endpointMetadata.method === HttpMethod.PUT) &&
+            this.endpointMetadata?.bodyDto) {
+            this.body.data = validateData(this.body.data, this.endpointMetadata.bodyDto, false);
             this.body.validated = true;
         }
         return this.body.data;

package/dist/http/controller/AbstractHttpController.d.ts

@@ -1,6 +1,6 @@
-import { ITransactionFactory } from "@clairejs/orm";
+import { type ITransactionFactory } from "@clairejs/orm";
 import { AbstractController } from "../../common/AbstractController";
-import { EndpointMetadata } from "../../common/request/EndpointMetadata";
+import { type EndpointMetadata } from "../../common/request/endpoint-metadata";
 export declare abstract class AbstractHttpController extends AbstractController {
     protected readonly databaseAdapter: ITransactionFactory;
     constructor(databaseAdapter: ITransactionFactory);

package/dist/http/controller/AbstractHttpController.js

@@ -1,7 +1,7 @@
 import { getObjectMetadata } from "@clairejs/core";
 import { AbstractController } from "../../common/AbstractController";
 const isEndpoint = (metadata) => {
-    return !!metadata.httpMethod || metadata.openAccess !== undefined || !!metadata.accessConditions;
+    return !!metadata.method || metadata.description !== undefined;
 };
 export class AbstractHttpController extends AbstractController {
     databaseAdapter;
@@ -16,6 +16,6 @@ export class AbstractHttpController extends AbstractController {
         }
         return controllerMetadata.fields
             .filter((f) => isEndpoint(f))
-            .map((f) => ({ ...f, permissionGroup: controllerMetadata.permissionGroup }));
+            .map((f) => ({ ...f, apiGroup: controllerMetadata.permissionGroup }));
     }
 }

package/dist/http/controller/AbstractHttpMiddleware.d.ts

@@ -1,4 +1,4 @@
-import { EndpointMetadata } from "../../common/request/EndpointMetadata";
+import { EndpointMetadata } from "../../common/request/endpoint-metadata";
 import { HttpRequest } from "../common/HttpRequest";
 import { HttpResponse } from "../common/HttpResponse";
 export declare abstract class AbstractHttpMiddleware {

package/dist/http/controller/AbstractHttpRequestHandler.d.ts

@@ -1,18 +1,18 @@
 import { AbstractLogger } from "@clairejs/core";
-import { HttpData } from "../../common/request/HttpData";
-import { MountedEndpointInfo } from "../../common/request/MountedEndpointInfo";
-import { HttpResponse } from "../common/HttpResponse";
-import { ControllerMetadata } from "../../common/ControllerMetadata";
-import { CorsConfig } from "../security/cors";
-import { AbstractHttpMiddleware } from "./AbstractHttpMiddleware";
+import { type HttpData } from "../../common/request/HttpData";
+import { type EndpointMetadata } from "../../common/request/endpoint-metadata";
+import { type HttpResponse } from "../common/HttpResponse";
+import { type ControllerMetadata } from "../../common/ControllerMetadata";
+import { type CorsConfig } from "../security/cors";
+import { type AbstractHttpMiddleware } from "./AbstractHttpMiddleware";
 export declare abstract class AbstractHttpRequestHandler {
     readonly mountPoint: string;
     readonly logger: AbstractLogger;
     private mountedEndpointInfo?;
     corsConfig?: CorsConfig;
     constructor(mountPoint: string, logger: AbstractLogger);
-    protected resolverMountPoint(controllerMetadata: ControllerMetadata, mappingUrls: string[]): string;
-    getMountedEndpointInfo(): Promise<MountedEndpointInfo[]>;
+    protected resolveMountPoint(controllerMetadata: ControllerMetadata, mappingUrls: string[]): string;
+    getMountedEndpointInfo(): Promise<EndpointMetadata[]>;
     abstract getMiddleware(): Promise<AbstractHttpMiddleware[]>;
     abstract handle(httpData: HttpData): Promise<HttpResponse<any>>;
 }

package/dist/http/controller/AbstractHttpRequestHandler.js

@@ -1,5 +1,4 @@
-import { getObjectMetadata, getServiceProvider, SocketMethod } from "@clairejs/core";
-import { getEndpointId } from "../utils";
+import { getObjectMetadata, getServiceProvider, HttpMethod, SocketMethod } from "@clairejs/core";
 import { AbstractHttpController } from "./AbstractHttpController";
 export class AbstractHttpRequestHandler {
     mountPoint;
@@ -10,7 +9,7 @@ export class AbstractHttpRequestHandler {
         this.mountPoint = mountPoint;
         this.logger = logger;
     }
-    resolverMountPoint(controllerMetadata, mappingUrls) {
+    resolveMountPoint(controllerMetadata, mappingUrls) {
         if (!controllerMetadata) {
             return "";
         }
@@ -30,33 +29,26 @@ export class AbstractHttpRequestHandler {
             for (const controller of controllers) {
                 const controllerMetadata = getObjectMetadata(controller.constructor);
                 const allEndpointMetadata = controller.getEndpointMetadata();
-                for (const endpointMetadata of allEndpointMetadata) {
-                    const endpoint = {
-                        mount: endpointMetadata.httpMethod === SocketMethod.MESSAGE
-                            ? endpointMetadata.url
-                            : this.resolverMountPoint(controllerMetadata, [
-                                this.mountPoint || "/",
-                                endpointMetadata.url,
-                            ]),
-                        httpMethod: endpointMetadata.httpMethod,
-                        controller: controller,
-                        handlerFunctionName: endpointMetadata.name,
+                result.push(...allEndpointMetadata.map((endpoint) => {
+                    const mount = endpoint.method === SocketMethod.MESSAGE
+                        ? endpoint.mount
+                        : this.resolveMountPoint(controllerMetadata, [this.mountPoint || "/", endpoint.mount]);
+                    return {
+                        ...endpoint,
+                        readOnly: endpoint.method === HttpMethod.GET,
+                        mount,
+                        id: `${endpoint.method}:${mount}`,
                     };
-                    result.push({
-                        endpointMetadata,
-                        endpoint,
-                    });
-                }
+                }));
             }
             //-- add to final to-be-mounted endpoints
             const mountedEndpointInfo = [];
             for (const endpointInfo of result) {
                 //-- check overriden endpoints
-                const overridingEndpoint = mountedEndpointInfo.find((info) => info.endpoint.mount === endpointInfo.endpoint.mount &&
-                    info.endpoint.httpMethod === endpointInfo.endpoint.httpMethod);
+                const overridingEndpoint = mountedEndpointInfo.find((info) => info.mount === endpointInfo.mount && info.method === endpointInfo.method);
                 if (overridingEndpoint) {
                     //-- if this endpoint has an other overriden endpoints then do not mount
-                    this.logger?.warn(`Implicit overriding endpoint: ${getEndpointId(overridingEndpoint.endpoint)} of ${overridingEndpoint.endpoint.controller?.constructor.name}:${overridingEndpoint.endpoint.handlerFunctionName}`, `Ignore ${getEndpointId(endpointInfo.endpoint)} of ${endpointInfo.endpoint.controller?.constructor.name}:${endpointInfo.endpoint.handlerFunctionName}`);
+                    this.logger?.warn(`Implicit overriding endpoint: ${overridingEndpoint.method}:${overridingEndpoint.mount} of ${overridingEndpoint.controller?.constructor.name}:${overridingEndpoint.handlerFunctionName}`, `Ignore ${endpointInfo.method}:${endpointInfo.mount} of ${endpointInfo.controller?.constructor.name}:${endpointInfo.handlerFunctionName}`);
                 }
                 else {
                     mountedEndpointInfo.push(endpointInfo);

package/dist/http/controller/CrudHttpController.d.ts

@@ -1,10 +1,10 @@
-import { CreateManyResponseBody, GetManyResponseBody, UpdateManyResponse, Identifiable, Constructor, ModelMetadata } from "@clairejs/core";
-import { IQueryProvider, ITransactionFactory } from "@clairejs/orm";
-import { HttpRequest } from "../common/HttpRequest";
-import { HttpResponse } from "../common/HttpResponse";
-import { EndpointMetadata } from "../../common/request/EndpointMetadata";
+import { type Constructor, type CreateManyResponseBody, type GetManyResponseBody, type Identifiable, type ModelMetadata, type UpdateManyResponse } from "@clairejs/core";
+import { type IQueryProvider, type ITransactionFactory } from "@clairejs/orm";
+import { type HttpRequest } from "../common/HttpRequest";
+import { type HttpResponse } from "../common/HttpResponse";
+import { type EndpointMetadata } from "../../common/request/endpoint-metadata";
 import { AbstractHttpController } from "./AbstractHttpController";
-import { ICrudRepository } from "../repository/ICrudRepository";
+import { type ICrudRepository } from "../repository/ICrudRepository";
 export declare class CrudHttpController<T extends Identifiable> extends AbstractHttpController {
     protected readonly model: Constructor<T>;
     protected readonly crudRepository: ICrudRepository<T>;

package/dist/http/controller/CrudHttpController.js

@@ -10,15 +10,12 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { getObjectMetadata, HttpMethod, getServiceProvider, leanData, getCreateManyBodyValidator, getCreateManyResponseValidator, getGetManyQueryValidator, getGetManyResponseValidator, getUpdateManyQueryValidator, getUpdateManyBodyValidator, getUpdateManyResponseValidator, uniqueReducer, omitData, getUpdateRecordsQueryValidator, getUpdateRecordsBodyValidator, } from "@clairejs/core";
+import { deepMerge, getCreateManyBodyValidator, getCreateManyResponseValidator, getGetManyQueryValidator, getGetManyResponseValidator, getObjectMetadata, getServiceProvider, getUpdateManyBodyValidator, getUpdateManyQueryValidator, getUpdateManyResponseValidator, getUpdateRecordsBodyValidator, getUpdateRecordsQueryValidator, HttpMethod, omitData, } from "@clairejs/core";
 import { Transactional, PropagationMode } from "@clairejs/orm";
-import { HttpRequest } from "../common/HttpRequest";
 import { ResponseBuilder } from "../common/HttpResponse";
 import { AbstractPrincipalResolver } from "../../common/auth/AbstractPrincipalResolver";
-import { AccessCondition, ApiDescription, Raw } from "../decorators";
+import { ApiDescription, Raw } from "../decorators";
 import { AbstractHttpController } from "./AbstractHttpController";
-import { MaximumQueryLimit } from "../security/access-conditions/MaximumQueryLimit";
-import { FilterModelFieldAccessCondition } from "../security/access-conditions/FilterModelFieldAccessCondition";
 export class CrudHttpController extends AbstractHttpController {
     model;
     crudRepository;
@@ -48,15 +45,14 @@ export class CrudHttpController extends AbstractHttpController {
      */
     createManyEndpoinMetadata() {
         const endpointMetadata = {};
-        endpointMetadata.httpMethod = HttpMethod.POST;
-        endpointMetadata.url = this.getMountedUrl();
-        endpointMetadata.name = CrudHttpController.prototype.createMany.name;
-        endpointMetadata.displayName = "createMany" + this.model.name;
+        endpointMetadata.method = HttpMethod.POST;
+        endpointMetadata.mount = this.getMountedUrl();
+        endpointMetadata.name = "createMany" + this.model.name;
+        endpointMetadata.handlerFunctionName = CrudHttpController.prototype.createMany.name;
         //-- body dto ------------------------------------
-        endpointMetadata.bodyValidationDto = getCreateManyBodyValidator(this.modelMetadata);
+        endpointMetadata.bodyDto = getCreateManyBodyValidator(this.modelMetadata);
         //-- response dto ------------------------------------
-        endpointMetadata.responseValidationDto = getCreateManyResponseValidator(this.modelMetadata);
-        endpointMetadata.accessConditions = [];
+        endpointMetadata.responseDto = getCreateManyResponseValidator(this.modelMetadata);
         endpointMetadata.params = { 0: { source: "raw" } };
         return endpointMetadata;
     }
@@ -66,19 +62,14 @@ export class CrudHttpController extends AbstractHttpController {
     getManyEndpointMetadata() {
         //-- get all
         const endpointMetadata = {};
-        endpointMetadata.httpMethod = HttpMethod.GET;
-        endpointMetadata.url = this.getMountedUrl();
-        endpointMetadata.name = CrudHttpController.prototype.getMany.name;
-        endpointMetadata.displayName = "getAll" + this.model.name;
+        endpointMetadata.method = HttpMethod.GET;
+        endpointMetadata.mount = this.getMountedUrl();
+        endpointMetadata.handlerFunctionName = CrudHttpController.prototype.getMany.name;
+        endpointMetadata.name = "getAll" + this.model.name;
         //-- query dto
-        endpointMetadata.queriesValidationDto = getGetManyQueryValidator(this.modelMetadata);
+        endpointMetadata.queryDto = getGetManyQueryValidator(this.modelMetadata);
         //-- response dto ------------------------------------
-        endpointMetadata.responseValidationDto = getGetManyResponseValidator(this.modelMetadata);
-        //-- access condition
-        endpointMetadata.accessConditions = [
-            FilterModelFieldAccessCondition(this.model, "model_projection", (request) => request.getQuery().projection),
-            MaximumQueryLimit,
-        ];
+        endpointMetadata.responseDto = getGetManyResponseValidator(this.modelMetadata);
         endpointMetadata.params = { 0: { source: "raw" } };
         return endpointMetadata;
     }
@@ -87,50 +78,31 @@ export class CrudHttpController extends AbstractHttpController {
      */
     updateManyEndpointMetadata() {
         const endpointMetadata = {};
-        endpointMetadata.httpMethod = HttpMethod.PUT;
-        endpointMetadata.url = this.getMountedUrl();
-        endpointMetadata.name = CrudHttpController.prototype.updateMany.name;
-        endpointMetadata.displayName = "update" + this.model.name;
+        endpointMetadata.method = HttpMethod.PUT;
+        endpointMetadata.mount = this.getMountedUrl();
+        endpointMetadata.handlerFunctionName = CrudHttpController.prototype.updateMany.name;
+        endpointMetadata.name = "update" + this.model.name;
         //-- queries dto ---------------------------------
-        endpointMetadata.queriesValidationDto = getUpdateManyQueryValidator(this.modelMetadata);
+        endpointMetadata.queryDto = getUpdateManyQueryValidator(this.modelMetadata);
         //-- body dto ------------------------------------
-        endpointMetadata.bodyValidationDto = getUpdateManyBodyValidator(this.modelMetadata);
+        endpointMetadata.bodyDto = getUpdateManyBodyValidator(this.modelMetadata);
         //-- response dto ------------------------------------
-        endpointMetadata.responseValidationDto = getUpdateManyResponseValidator(this.modelMetadata);
-        //-- access condition
-        endpointMetadata.accessConditions = [
-            FilterModelFieldAccessCondition(this.model, "restrict_update_fields", (request) => {
-                const updateBody = request.getBody().update;
-                if (!updateBody) {
-                    return [];
-                }
-                return Object.keys(leanData(updateBody));
-            }),
-        ];
+        endpointMetadata.responseDto = getUpdateManyResponseValidator(this.modelMetadata);
         endpointMetadata.params = { 0: { source: "raw" } };
         return endpointMetadata;
     }
     updateRecordsEndpointMetadata() {
         const endpointMetadata = {};
-        endpointMetadata.httpMethod = HttpMethod.PUT;
-        endpointMetadata.url = `${this.getMountedUrl()}/records`;
-        endpointMetadata.name = CrudHttpController.prototype.updateRecords.name;
-        endpointMetadata.displayName = "updateRecords" + this.model.name;
+        endpointMetadata.method = HttpMethod.PUT;
+        endpointMetadata.mount = `${this.getMountedUrl()}/records`;
+        endpointMetadata.handlerFunctionName = CrudHttpController.prototype.updateRecords.name;
+        endpointMetadata.name = "updateRecords" + this.model.name;
         //-- queries dto ---------------------------------
-        endpointMetadata.queriesValidationDto = getUpdateRecordsQueryValidator();
+        endpointMetadata.queryDto = getUpdateRecordsQueryValidator();
         //-- body dto ------------------------------------
-        endpointMetadata.bodyValidationDto = getUpdateRecordsBodyValidator(this.modelMetadata);
+        endpointMetadata.bodyDto = getUpdateRecordsBodyValidator(this.modelMetadata);
         //-- response dto ------------------------------------
-        endpointMetadata.responseValidationDto = getUpdateManyResponseValidator(this.modelMetadata);
-        //-- access condition
-        endpointMetadata.accessConditions = [
-            FilterModelFieldAccessCondition(this.model, "restrict_update_fields", (request) => {
-                const updates = request.getBody();
-                return updates.records
-                    .flatMap(({ id, ...update }) => Object.keys(leanData(update) || {}))
-                    .reduce(uniqueReducer, []);
-            }),
-        ];
+        endpointMetadata.responseDto = getUpdateManyResponseValidator(this.modelMetadata);
         return endpointMetadata;
     }
     /**
@@ -138,16 +110,14 @@ export class CrudHttpController extends AbstractHttpController {
      */
     deleteManyEndpoinMetadata() {
         const endpointMetadata = {};
-        endpointMetadata.httpMethod = HttpMethod.DEL;
-        endpointMetadata.url = this.getMountedUrl();
-        endpointMetadata.name = CrudHttpController.prototype.deleteMany.name;
-        endpointMetadata.displayName = "delete" + this.model.name;
+        endpointMetadata.method = HttpMethod.DEL;
+        endpointMetadata.mount = this.getMountedUrl();
+        endpointMetadata.handlerFunctionName = CrudHttpController.prototype.deleteMany.name;
+        endpointMetadata.name = "delete" + this.model.name;
         //-- queries ---------------------------------
-        endpointMetadata.queriesValidationDto = getUpdateManyQueryValidator(this.modelMetadata);
-        endpointMetadata.responseValidationDto = getUpdateManyResponseValidator(this.modelMetadata);
+        endpointMetadata.queryDto = getUpdateManyQueryValidator(this.modelMetadata);
+        endpointMetadata.responseDto = getUpdateManyResponseValidator(this.modelMetadata);
         endpointMetadata.params = { 0: { source: "raw" } };
-        //-- access condition
-        endpointMetadata.accessConditions = [];
         return endpointMetadata;
     }
     /**
@@ -184,17 +154,10 @@ export class CrudHttpController extends AbstractHttpController {
         }
         //-- merge with super
         for (const endpoint of crudEnpointMetadata) {
-            const index = allEndpoints.findIndex((e) => (e.httpMethod === endpoint.httpMethod && e.url === endpoint.url) ||
-                (e.name === endpoint.name && (!e.httpMethod || !e.url)));
+            const index = allEndpoints.findIndex((e) => (e.method === endpoint.method && e.mount === endpoint.mount) ||
+                (e.name === endpoint.name && (!e.method || !e.mount)));
             if (index >= 0) {
-                allEndpoints[index] = {
-                    ...endpoint,
-                    ...allEndpoints[index],
-                    accessConditions: [
-                        ...(endpoint.accessConditions || []),
-                        ...(allEndpoints[index].accessConditions || []),
-                    ],
-                };
+                deepMerge(allEndpoints[index], endpoint, true);
             }
             else {
                 allEndpoints.push(endpoint);
@@ -260,44 +223,39 @@ export class CrudHttpController extends AbstractHttpController {
 __decorate([
     Transactional(PropagationMode.INHERIT_OR_CREATE),
     ApiDescription("Update records of this table."),
-    AccessCondition([]),
     __param(0, Raw()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [HttpRequest]),
+    __metadata("design:paramtypes", [Function]),
     __metadata("design:returntype", Promise)
 ], CrudHttpController.prototype, "updateRecords", null);
 __decorate([
     Transactional(PropagationMode.INHERIT_OR_CREATE),
     ApiDescription("Create records of this table."),
-    AccessCondition([]),
     __param(0, Raw()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [HttpRequest]),
+    __metadata("design:paramtypes", [Function]),
     __metadata("design:returntype", Promise)
 ], CrudHttpController.prototype, "createMany", null);
 __decorate([
-    AccessCondition([]),
     ApiDescription("Get records of this table."),
     __param(0, Raw()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [HttpRequest]),
+    __metadata("design:paramtypes", [Function]),
     __metadata("design:returntype", Promise)
 ], CrudHttpController.prototype, "getMany", null);
 __decorate([
     Transactional(PropagationMode.INHERIT_OR_CREATE),
     ApiDescription("Find and update records which match search condition."),
-    AccessCondition([]),
     __param(0, Raw()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [HttpRequest]),
+    __metadata("design:paramtypes", [Function]),
     __metadata("design:returntype", Promise)
 ], CrudHttpController.prototype, "updateMany", null);
 __decorate([
     Transactional(PropagationMode.INHERIT_OR_CREATE),
     ApiDescription("Find and remove records which match search condition."),
-    AccessCondition([]),
     __param(0, Raw()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [HttpRequest]),
+    __metadata("design:paramtypes", [Function]),
     __metadata("design:returntype", Promise)
 ], CrudHttpController.prototype, "deleteMany", null);

package/dist/http/controller/DefaultHttpRequestHandler.d.ts

@@ -3,8 +3,8 @@ import { HttpResponse } from "../common/HttpResponse";
 import { AbstractPrincipalResolver } from "../../common/auth/AbstractPrincipalResolver";
 import { HttpRequest } from "../common/HttpRequest";
 import { AbstractRequestAuthorizer } from "../auth/AbstractHttpAuthorizer";
-import { MountedEndpointInfo } from "../../common/request/MountedEndpointInfo";
 import { HttpData } from "../../common/request/HttpData";
+import { EndpointMetadata } from "../../common/request/endpoint-metadata";
 import { AbstractHttpMiddleware } from "./AbstractHttpMiddleware";
 import { AbstractHttpRequestHandler } from "./AbstractHttpRequestHandler";
 export declare class DefaultHttpRequestHandler extends AbstractHttpRequestHandler {
@@ -13,7 +13,7 @@ export declare class DefaultHttpRequestHandler extends AbstractHttpRequestHandle
     readonly principalResolver: AbstractPrincipalResolver;
     private _middleware;
     constructor(logger: AbstractLogger, authorizationProvider: AbstractRequestAuthorizer, principalResolver: AbstractPrincipalResolver);
-    protected handleRequest(endpoint: MountedEndpointInfo, req: HttpRequest): Promise<HttpResponse<any>>;
+    protected handleRequest(endpoint: EndpointMetadata, req: HttpRequest): Promise<HttpResponse<any>>;
     exit(): void;
     private getResponse;
     handle(httpData: HttpData): Promise<HttpResponse<any>>;

package/dist/http/controller/DefaultHttpRequestHandler.js

@@ -31,7 +31,7 @@ let DefaultHttpRequestHandler = class DefaultHttpRequestHandler extends Abstract
     }
     async handleRequest(endpoint, req) {
         //-- supply correct order of params into handler
-        const params = Object.values(endpoint.endpointMetadata.params || {}).map((p) => {
+        const params = Object.values(endpoint.params || {}).map((p) => {
             switch (p.source) {
                 case "body":
                     return req.getBody();
@@ -45,10 +45,10 @@ let DefaultHttpRequestHandler = class DefaultHttpRequestHandler extends Abstract
                     return req;
             }
         });
-        const response = await endpoint.endpoint.controller[endpoint.endpointMetadata.name](...params);
+        const response = await endpoint.controller[endpoint.handlerFunctionName](...params);
         //-- validate response value against response dto
-        if (endpoint.endpointMetadata.responseValidationDto) {
-            response.value = stripData(response.value, endpoint.endpointMetadata.responseValidationDto);
+        if (endpoint.responseDto) {
+            response.value = stripData(response.value, endpoint.responseDto);
         }
         return response;
     }
@@ -61,8 +61,8 @@ let DefaultHttpRequestHandler = class DefaultHttpRequestHandler extends Abstract
         let params = {};
         const mountedEndpointInfo = await this.getMountedEndpointInfo();
         const info = mountedEndpointInfo.find((info) => {
-            const parsedParams = info.endpointMetadata.httpMethod === method &&
-                match(info.endpointMetadata.url, { decode: decodeURIComponent })(result.pathname || "/");
+            const parsedParams = info.method === method &&
+                match(info.mount, { decode: decodeURIComponent })(result.pathname || "/");
             if (!parsedParams) {
                 return false;
             }
@@ -83,15 +83,13 @@ let DefaultHttpRequestHandler = class DefaultHttpRequestHandler extends Abstract
             params: params.params,
             body: httpData.body,
             cookies: httpData.cookies,
-        }, info.endpointMetadata);
+        }, info);
         const authInfo = await this.principalResolver.resolvePrincipal(request);
         request.setAuthInfo(authInfo);
-        if (!info.endpointMetadata.openAccess) {
-            await this.authorizationProvider.authorize(request, info);
-        }
+        await this.authorizationProvider.authorize(request, info);
         const mws = await this.getMiddleware();
         for (const mw of mws) {
-            const next = await mw.intercept(request, response, info.endpointMetadata);
+            const next = await mw.intercept(request, response, info);
             if (!next) {
                 return response;
             }

package/dist/http/decorators.d.ts

@@ -1,9 +1,8 @@
-import { HttpMethod, Constructor, AbstractModel } from "@clairejs/core";
-import { AbstractHttpController } from "./controller/AbstractHttpController";
-import { AbstractAccessCondition } from "./security/AbstractAccessCondition";
-import { HttpResponse } from "./common/HttpResponse";
-import { UriMapperHandler } from "./file-upload/types";
-import { IPrincipal } from "../common/auth/IPrincipal";
+import { type Constructor, AbstractModel, HttpMethod } from "@clairejs/core";
+import { type UriMapperHandler } from "./file-upload/types";
+import { type HttpResponse } from "./common/HttpResponse";
+import { type IPrincipal } from "../common/auth/IPrincipal";
+import { type AbstractHttpController } from "./controller/AbstractHttpController";
 type HttpFunctionMethod<T> = (...args: any[]) => Promise<HttpResponse<T>>;
 export declare const ApiDescription: (description: string) => (prototype: AbstractHttpController, propertyKey: string) => void;
 export declare const Endpoint: (config: {
@@ -16,9 +15,6 @@ export declare const Del: (url: string) => (prototype: AbstractHttpController, p
 export declare const Get: (url: string) => (prototype: AbstractHttpController, propertyKey: string, _descriptor: TypedPropertyDescriptor<HttpFunctionMethod<any>>) => void;
 export declare const Head: (url: string) => (prototype: AbstractHttpController, propertyKey: string, _descriptor: TypedPropertyDescriptor<HttpFunctionMethod<any>>) => void;
 export declare const ApiResponse: <T>(responseClass: Constructor<T>) => (prototype: AbstractHttpController, propertyKey: string, _descriptor: TypedPropertyDescriptor<HttpFunctionMethod<T>>) => void;
-export declare const OpenAccess: () => (prototype: AbstractHttpController, propertyKey: string) => void;
-export declare const TfaRequired: () => (prototype: AbstractHttpController, propertyKey: string) => void;
-export declare const AccessCondition: (conditions: Constructor<AbstractAccessCondition>[]) => (prototype: AbstractHttpController, propertyKey: string) => void;
 export declare const Body: () => (prototype: AbstractHttpController, propertyKey: string, paramIndex: number) => void;
 export declare const Params: () => (prototype: AbstractHttpController, propertyKey: string, paramIndex: number) => void;
 export declare const Queries: () => (prototype: AbstractHttpController, propertyKey: string, paramIndex: number) => void;

package/dist/http/decorators.js

@@ -1,13 +1,13 @@
-import { initFieldMetadata, getObjectMetadata, HttpMethod, DataType, } from "@clairejs/core";
+import { DataType, getObjectMetadata, HttpMethod, initFieldMetadata, } from "@clairejs/core";
 export const ApiDescription = (description) => (prototype, propertyKey) => {
     const endpointMetadata = initFieldMetadata(prototype, propertyKey);
     endpointMetadata.description = description;
 };
 export const Endpoint = (config) => (prototype, propertyKey) => {
     const endpointMetadata = initFieldMetadata(prototype, propertyKey);
-    endpointMetadata.httpMethod = config.method;
+    endpointMetadata.method = config.method;
     //-- default to "/" if empty string is provided
-    endpointMetadata.url = config.url || "/";
+    endpointMetadata.mount = config.url || "/";
 };
 const HttpMethodDecoratorFactory = (method) => (url) => (prototype, propertyKey, _descriptor) => Endpoint({ method, url })(prototype, propertyKey);
 export const Post = HttpMethodDecoratorFactory(HttpMethod.POST);
@@ -18,42 +18,30 @@ export const Head = HttpMethodDecoratorFactory(HttpMethod.HEAD);
 export const ApiResponse = (responseClass) => (prototype, propertyKey, _descriptor) => {
     const endpointMetadata = initFieldMetadata(prototype, propertyKey);
     if (responseClass === String) {
-        endpointMetadata.responseValidationDto = { id: "", primitiveType: DataType.STRING, fields: [] };
+        endpointMetadata.responseDto = { id: "", primitiveType: DataType.STRING, fields: [] };
     }
     else if (responseClass === Number) {
-        endpointMetadata.responseValidationDto = { id: "", primitiveType: DataType.NUMBER, fields: [] };
+        endpointMetadata.responseDto = { id: "", primitiveType: DataType.NUMBER, fields: [] };
     }
     else if (responseClass === Boolean) {
-        endpointMetadata.responseValidationDto = { id: "", primitiveType: DataType.BOOLEAN, fields: [] };
+        endpointMetadata.responseDto = { id: "", primitiveType: DataType.BOOLEAN, fields: [] };
     }
     else {
-        endpointMetadata.responseValidationDto = getObjectMetadata(responseClass);
+        endpointMetadata.responseDto = getObjectMetadata(responseClass);
     }
 };
-export const OpenAccess = () => (prototype, propertyKey) => {
-    const endpointMetadata = initFieldMetadata(prototype, propertyKey);
-    endpointMetadata.openAccess = true;
-};
-export const TfaRequired = () => (prototype, propertyKey) => {
-    const endpointMetadata = initFieldMetadata(prototype, propertyKey);
-    endpointMetadata.tfaRequired = true;
-};
-export const AccessCondition = (conditions) => (prototype, propertyKey) => {
-    const endpointMetadata = initFieldMetadata(prototype, propertyKey);
-    endpointMetadata.accessConditions = conditions;
-};
 const RequestDeco = (source) => (prototype, propertyKey, paramIndex) => {
     const endpointMetadata = initFieldMetadata(prototype, propertyKey);
     const paramClasses = Reflect.getMetadata("design:paramtypes", prototype, propertyKey) || [];
     switch (source) {
         case "body":
-            endpointMetadata.bodyValidationDto = getObjectMetadata(paramClasses[paramIndex]);
+            endpointMetadata.bodyDto = getObjectMetadata(paramClasses[paramIndex]);
             break;
         case "params":
-            endpointMetadata.paramsValidationDto = getObjectMetadata(paramClasses[paramIndex]);
+            endpointMetadata.paramDto = getObjectMetadata(paramClasses[paramIndex]);
             break;
         case "queries":
-            endpointMetadata.queriesValidationDto = getObjectMetadata(paramClasses[paramIndex]);
+            endpointMetadata.queryDto = getObjectMetadata(paramClasses[paramIndex]);
             break;
         default:
             break;

package/dist/http/repository/ICrudRepository.d.ts

@@ -1,6 +1,6 @@
-import { AbstractLogger, CreateManyRequestBody, CreateManyResponseBody, GetManyQueries, GetManyResponseBody, UpdateManyBody, UpdateManyQueries, UpdateManyResponse } from "@clairejs/core";
-import { IQueryProvider, ITransaction, QueryCondition } from "@clairejs/orm";
-import { IPrincipal } from "../../common/auth/IPrincipal";
+import { type AbstractLogger, type CreateManyRequestBody, type CreateManyResponseBody, type GetManyQueries, type GetManyResponseBody, type UpdateManyBody, type UpdateManyQueries, type UpdateManyResponse } from "@clairejs/core";
+import { type IQueryProvider, type ITransaction, type QueryCondition } from "@clairejs/orm";
+import { type IPrincipal } from "../../common/auth/IPrincipal";
 export interface ICrudRepository<T> {
     createMany({ principal, body, tx, logger, }: {
         body: CreateManyRequestBody<T>;

package/dist/http/utils.d.ts

@@ -1,4 +1,2 @@
-import { ApiInfoResponse } from "@clairejs/core";
-import { HttpEndpoint } from "../common/request/HttpEndpoint";
-export declare const getEndpointId: (endpoint: HttpEndpoint) => string;
+import { type ApiInfoResponse } from "@clairejs/core";
 export declare const getApiInfo: () => Promise<ApiInfoResponse>;

package/dist/http/utils.js

@@ -1,9 +1,7 @@
-import { HttpMethod, getServiceProvider } from "@clairejs/core";
+import { getServiceProvider, pickData, ApiInfo, getObjectMetadata } from "@clairejs/core";
 import { AbstractHttpRequestHandler } from "./controller/AbstractHttpRequestHandler";
 import { AbstractServerSocketManager } from "../socket/AbstractServerSocketManager";
-export const getEndpointId = (endpoint) => {
-    return `${endpoint.httpMethod}:${endpoint.mount}`;
-};
+const fields = (getObjectMetadata(ApiInfo)?.fields || []).map((f) => f.name);
 export const getApiInfo = async () => {
     const injector = getServiceProvider().getInjector();
     const httpHandler = injector.resolveOptional(AbstractHttpRequestHandler);
@@ -12,21 +10,6 @@ export const getApiInfo = async () => {
     const httpInfo = httpHandler ? await httpHandler.getMountedEndpointInfo() : [];
     const socketInfo = socketManager ? await socketManager.getMountedEndpointInfo() : [];
     return {
-        permissions: [...httpInfo, ...socketInfo].map((endpointInfo) => ({
-            id: getEndpointId(endpointInfo.endpoint),
-            description: endpointInfo.endpointMetadata.description,
-            name: endpointInfo.endpointMetadata.displayName || endpointInfo.endpointMetadata.name,
-            openAccess: !!endpointInfo.endpointMetadata.openAccess,
-            permissionGroup: endpointInfo.endpointMetadata.permissionGroup || "",
-            accessConditions: endpointInfo.endpointMetadata.accessConditions?.map((ac) => injector.resolve(ac).getConditionMetadata()) || [],
-            readOnly: endpointInfo.endpointMetadata.httpMethod === HttpMethod.GET,
-            tfaRequired: !!endpointInfo.endpointMetadata.tfaRequired,
-            method: endpointInfo.endpointMetadata.httpMethod,
-            mount: endpointInfo.endpoint.mount || "",
-            paramDto: endpointInfo.endpointMetadata.paramsValidationDto,
-            queryDto: endpointInfo.endpointMetadata.queriesValidationDto,
-            bodyDto: endpointInfo.endpointMetadata.bodyValidationDto,
-            responseDto: endpointInfo.endpointMetadata.responseValidationDto,
-        })),
+        apis: [...httpInfo, ...socketInfo].map((metadata) => pickData(metadata, fields)),
     };
 };

package/dist/index.d.ts

@@ -1,9 +1,7 @@
 export * from "./common/FileOperation";
 export * from "./common/auth/AbstractPrincipalResolver";
 export * from "./common/auth/IPrincipal";
-export * from "./common/request/MountedEndpointInfo";
-export * from "./common/request/HttpEndpoint";
-export * from "./common/request/EndpointMetadata";
+export * from "./common/request/endpoint-metadata";
 export * from "./common/request/RequestOptions";
 export * from "./common/AbstractController";
 export * from "./common/ControllerMetadata";
@@ -17,9 +15,6 @@ export * from "./http/controller/CrudHttpController";
 export * from "./http/controller/AbstractHttpRequestHandler";
 export * from "./http/controller/AbstractHttpMiddleware";
 export * from "./http/security/cors";
-export * from "./http/security/AbstractAccessCondition";
-export * from "./http/security/access-conditions/FilterModelFieldAccessCondition";
-export * from "./http/security/access-conditions/MaximumQueryLimit";
 export * from "./http/auth/AbstractHttpAuthorizer";
 export * from "./http/repository/ModelRepository";
 export * from "./http/repository/DtoRepository";

package/dist/index.js

@@ -2,9 +2,7 @@
 export * from "./common/FileOperation";
 export * from "./common/auth/AbstractPrincipalResolver";
 export * from "./common/auth/IPrincipal";
-export * from "./common/request/MountedEndpointInfo";
-export * from "./common/request/HttpEndpoint";
-export * from "./common/request/EndpointMetadata";
+export * from "./common/request/endpoint-metadata";
 export * from "./common/request/RequestOptions";
 export * from "./common/AbstractController";
 export * from "./common/ControllerMetadata";
@@ -19,9 +17,6 @@ export * from "./http/controller/CrudHttpController";
 export * from "./http/controller/AbstractHttpRequestHandler";
 export * from "./http/controller/AbstractHttpMiddleware";
 export * from "./http/security/cors";
-export * from "./http/security/AbstractAccessCondition";
-export * from "./http/security/access-conditions/FilterModelFieldAccessCondition";
-export * from "./http/security/access-conditions/MaximumQueryLimit";
 export * from "./http/auth/AbstractHttpAuthorizer";
 export * from "./http/repository/ModelRepository";
 export * from "./http/repository/DtoRepository";

package/dist/socket/AbstractServerSocketManager.d.ts

@@ -2,8 +2,8 @@ import { AbstractLogger, SocketMessage } from "@clairejs/core";
 import Redis from "ioredis";
 import { SocketData } from "../common/request/SocketData";
 import { IPrincipal } from "../common/auth/IPrincipal";
+import { EndpointMetadata } from "../common/request/endpoint-metadata";
 import { AbstractPrincipalResolver } from "../common/auth/AbstractPrincipalResolver";
-import { MountedEndpointInfo } from "../common/request/MountedEndpointInfo";
 import { AbstractRequestAuthorizer } from "../http/auth/AbstractHttpAuthorizer";
 import { AbstractSocketConnectionHandler } from "./AbstractSocketConnectionHandler";
 import { AbstractServerSocket } from "./AbstractServerSocket";
@@ -42,5 +42,5 @@ export declare abstract class AbstractServerSocketManager {
     removeSocket(socketId: string, _physicRemove?: boolean): Promise<void>;
     abstract getById(socketId: string): Promise<AbstractServerSocket | undefined>;
     handle(socketData: SocketData): Promise<void>;
-    getMountedEndpointInfo(): Promise<MountedEndpointInfo[]>;
+    getMountedEndpointInfo(): Promise<EndpointMetadata[]>;
 }

package/dist/socket/AbstractServerSocketManager.js

@@ -1,53 +1,10 @@
-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;
-};
-import { AccessConditionValueType, DataType, Errors, getObjectMetadata, getServiceProvider, MessageType, Register, SocketMethod, } from "@clairejs/core";
-import { AbstractAccessCondition } from "../http/security/AbstractAccessCondition";
+import { DataType, Errors, getServiceProvider, MessageType, SocketMethod, } from "@clairejs/core";
 import { HttpRequest } from "../http/common/HttpRequest";
 import { AbstractSocketConnectionHandler } from "./AbstractSocketConnectionHandler";
 import { AbstractSocketController } from "./AbstractSocketController";
 const SOCKET_ACTION_HEADER = "x-socket-action";
 const SOCKET_ACTION_READ = "read";
 const SOCKET_ACTION_WRITE = "write";
-let SocketReadCondition = class SocketReadCondition extends AbstractAccessCondition {
-    async resolveConditionValue(request) {
-        return request.headers[SOCKET_ACTION_HEADER] === SOCKET_ACTION_READ;
-    }
-    async validate(conditionValue) {
-        return !!conditionValue;
-    }
-    getConditionMetadata() {
-        return {
-            name: "disable_write",
-            description: "Disable send message to channel",
-            valueType: AccessConditionValueType.BOOLEAN,
-        };
-    }
-};
-SocketReadCondition = __decorate([
-    Register()
-], SocketReadCondition);
-let SocketWriteCondition = class SocketWriteCondition extends AbstractAccessCondition {
-    async resolveConditionValue(request) {
-        return request.headers[SOCKET_ACTION_HEADER] === SOCKET_ACTION_WRITE;
-    }
-    async validate(conditionValue) {
-        return !!conditionValue;
-    }
-    getConditionMetadata() {
-        return {
-            name: "disable_read",
-            description: "Disable receive message from channel",
-            valueType: AccessConditionValueType.BOOLEAN,
-        };
-    }
-};
-SocketWriteCondition = __decorate([
-    Register()
-], SocketWriteCondition);
 export class AbstractServerSocketManager {
     requireAuthentication;
     logger;
@@ -157,9 +114,9 @@ export class AbstractServerSocketManager {
                     //-- notify all channels
                     this.logger.debug("Notify channels");
                     for (const channelInfo of socket.getChannelsInfo()) {
-                        const currentEndpoint = mountedEndpoints.find((e) => e.endpointMetadata.url === channelInfo.name);
+                        const currentEndpoint = mountedEndpoints.find((e) => e.mount === channelInfo.name);
                         if (currentEndpoint) {
-                            currentEndpoint.endpoint.controller.onChannelLeave(socket);
+                            currentEndpoint.controller.onChannelLeave(socket);
                         }
                     }
                     this.logger.debug("Calling disconnection handler");
@@ -206,7 +163,7 @@ export class AbstractServerSocketManager {
                                     let canSend = false;
                                     let canReceive = false;
                                     const mountedEndpoints = await this.getMountedEndpointInfo();
-                                    const currentEndpoint = mountedEndpoints.find((e) => e.endpointMetadata.url === channel);
+                                    const currentEndpoint = mountedEndpoints.find((e) => e.mount === channel);
                                     if (!currentEndpoint) {
                                         continue;
                                     }
@@ -215,7 +172,7 @@ export class AbstractServerSocketManager {
                                             method: SocketMethod.MESSAGE,
                                             pathName: channel,
                                             headers: { [SOCKET_ACTION_HEADER]: SOCKET_ACTION_READ },
-                                        }, currentEndpoint.endpointMetadata);
+                                        }, currentEndpoint);
                                         request.setAuthInfo(clientSocket.getAuthInfo());
                                         await this.requestAuthorizer.authorize(request, currentEndpoint);
                                         canReceive = true;
@@ -228,7 +185,7 @@ export class AbstractServerSocketManager {
                                             method: SocketMethod.MESSAGE,
                                             pathName: channel,
                                             headers: { [SOCKET_ACTION_HEADER]: SOCKET_ACTION_WRITE },
-                                        }, currentEndpoint.endpointMetadata);
+                                        }, currentEndpoint);
                                         request.setAuthInfo(clientSocket.getAuthInfo());
                                         await this.requestAuthorizer.authorize(request, currentEndpoint);
                                         canSend = true;
@@ -258,7 +215,7 @@ export class AbstractServerSocketManager {
                                             type: MessageType.CHANNEL_JOIN,
                                             data: channelsInfo.map((c) => c.name),
                                         }),
-                                        ...endpoints.map((endpoint) => endpoint.endpoint.controller.onChannelJoin(clientSocket)),
+                                        ...endpoints.map((endpoint) => endpoint.controller.onChannelJoin(clientSocket)),
                                     ]);
                                 }
                             }
@@ -269,11 +226,11 @@ export class AbstractServerSocketManager {
                                 //-- remove channels from socket
                                 const mountedEndpoints = await this.getMountedEndpointInfo();
                                 Promise.all(channels.map((channel) => () => {
-                                    const currentEndpoint = mountedEndpoints.find((e) => e.endpointMetadata.url === channel);
+                                    const currentEndpoint = mountedEndpoints.find((e) => e.mount === channel);
                                     if (!currentEndpoint) {
                                         return;
                                     }
-                                    return currentEndpoint.endpoint.controller.onChannelLeave(clientSocket);
+                                    return currentEndpoint.controller.onChannelLeave(clientSocket);
                                 }));
                                 //-- remove socket from channels
                                 await this.removeSocketFromChannel(clientSocket.getId(), channels);
@@ -291,9 +248,9 @@ export class AbstractServerSocketManager {
                                         .find((info) => info.name === channel && info.clientToServerAllowed);
                                     if (allowed) {
                                         const mountedEndpoints = await this.getMountedEndpointInfo();
-                                        const currentEndpoint = mountedEndpoints.find((e) => e.endpointMetadata.url === channel);
+                                        const currentEndpoint = mountedEndpoints.find((e) => e.mount === channel);
                                         if (currentEndpoint) {
-                                            const result = await currentEndpoint.endpoint.controller.onMessage(clientSocket, data);
+                                            const result = await currentEndpoint.controller.onMessage(clientSocket, data);
                                             if (result !== false) {
                                                 //-- broadcast
                                                 this.logger.debug("broadcasting to channel", channel, data);
@@ -325,23 +282,16 @@ export class AbstractServerSocketManager {
             const socketController = injector.resolveMultiple(AbstractSocketController);
             await injector.initInstances();
             this.mountedEndpointInfo = socketController.map((controller) => {
-                const controllerMetadata = getObjectMetadata(controller.constructor);
                 return {
-                    endpoint: {
-                        httpMethod: SocketMethod.MESSAGE,
-                        mount: controller.getChannelName(),
-                        controller: controller,
-                        handlerFunctionName: controller.onMessage.name,
-                    },
-                    endpointMetadata: {
-                        httpMethod: SocketMethod.MESSAGE,
-                        description: "Send / Receive message to / from channel",
-                        permissionGroup: controllerMetadata.permissionGroup,
-                        dataType: DataType.OBJECT,
-                        url: controller.getChannelName(),
-                        name: controller.getChannelName(),
-                        accessConditions: [SocketReadCondition, SocketWriteCondition],
-                    },
+                    id: `${SocketMethod.MESSAGE}:${controller.getChannelName()}`,
+                    readOnly: false,
+                    controller: socketController,
+                    method: SocketMethod.MESSAGE,
+                    mount: controller.getChannelName(),
+                    handlerFunctionName: controller.onMessage.name,
+                    description: "Send / Receive message to / from channel",
+                    name: controller.getChannelName(),
+                    dataType: DataType.OBJECT,
                 };
             });
         }

package/dist/socket/AbstractSocketController.d.ts

@@ -7,7 +7,6 @@ export declare abstract class AbstractSocketController extends AbstractControlle
     /**
      * Handle the message sent to this channel
      * @param socket the socket sending message
-     * @param data the data payload being sent
      * @returns return false to prevent message broadcast
      */
     onMessage(_socket: IServerSocket, _message: any): Promise<boolean | void>;

package/dist/socket/AbstractSocketController.js

@@ -5,7 +5,6 @@ export class AbstractSocketController extends AbstractController {
     /**
      * Handle the message sent to this channel
      * @param socket the socket sending message
-     * @param data the data payload being sent
      * @returns return false to prevent message broadcast
      */
     async onMessage(_socket, _message) { }

package/dist/system/ClaireServer.d.ts

@@ -1,6 +1,6 @@
 import { AbstractLogger, ClaireApp } from "@clairejs/core";
-import { AbstractHttpRequestHandler } from "../http/controller/AbstractHttpRequestHandler";
-import { AbstractServerSocketManager } from "../socket/AbstractServerSocketManager";
+import { type AbstractHttpRequestHandler } from "../http/controller/AbstractHttpRequestHandler";
+import { type AbstractServerSocketManager } from "../socket/AbstractServerSocketManager";
 export declare class ClaireServer extends ClaireApp {
     protected readonly logger: AbstractLogger;
     protected readonly httpRequestHandler?: AbstractHttpRequestHandler | undefined;
@@ -8,6 +8,5 @@ export declare class ClaireServer extends ClaireApp {
     private booted;
     constructor(logger: AbstractLogger, httpRequestHandler?: AbstractHttpRequestHandler | undefined, socketManager?: AbstractServerSocketManager | undefined);
     init(): Promise<void>;
-    exit(): void;
     private stop;
 }

package/dist/system/ClaireServer.js

@@ -9,9 +9,6 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { AbstractLogger, ClaireApp, LogContext, getGlobalStore } from "@clairejs/core";
 import { ExitCode } from "../common/constants";
-import { AbstractHttpRequestHandler } from "../http/controller/AbstractHttpRequestHandler";
-import { AbstractServerSocketManager } from "../socket/AbstractServerSocketManager";
-import { getEndpointId } from "../http/utils";
 let ClaireServer = class ClaireServer extends ClaireApp {
     logger;
     httpRequestHandler;
@@ -38,7 +35,7 @@ let ClaireServer = class ClaireServer extends ClaireApp {
         }
         //-- save mounted endpoint info in server store to prevent circular dependency when resolving http request handler in controller
         for (const endpoint of mountedEndpointInfo) {
-            this.logger.info(`Mounting: ${getEndpointId(endpoint.endpoint)}`);
+            this.logger.info(`Mounting: ${endpoint.method}:${endpoint.mount}`);
         }
         getGlobalStore().mountedEndpointInfo = mountedEndpointInfo;
         this.logger.debug("Claire server initing");
@@ -60,9 +57,6 @@ let ClaireServer = class ClaireServer extends ClaireApp {
         });
         this.booted = true;
     }
-    exit() {
-        super.exit();
-    }
     stop(code) {
         this.logger.debug("Server is shutting down");
         this.exit();
@@ -71,8 +65,6 @@ let ClaireServer = class ClaireServer extends ClaireApp {
 };
 ClaireServer = __decorate([
     LogContext(),
-    __metadata("design:paramtypes", [AbstractLogger,
-        AbstractHttpRequestHandler,
-        AbstractServerSocketManager])
+    __metadata("design:paramtypes", [AbstractLogger, Function, Function])
 ], ClaireServer);
 export { ClaireServer };

package/dist/system/ServerGlobalStore.d.ts

@@ -1,5 +1,5 @@
 import { CoreGlobalStore } from "@clairejs/core";
-import { MountedEndpointInfo } from "../common/request/MountedEndpointInfo";
+import { EndpointMetadata } from "../common/request/endpoint-metadata";
 export interface ServerGlobalStore extends CoreGlobalStore {
-    mountedEndpointInfo?: MountedEndpointInfo[];
+    mountedEndpointInfo?: EndpointMetadata[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clairejs/server",
-    "version": "3.17.0",
+    "version": "3.17.1",
     "description": "Claire server NodeJs framework written in Typescript.",
     "types": "dist/index.d.ts",
     "main": "dist/index.js",
@@ -16,10 +16,12 @@
     "license": "ISC",
     "dependencies": {
         "aws-sdk": "^2.841.0",
+        "axios": "^0.21.4",
         "cookie-parser": "^1.4.6",
         "cors": "^2.8.5",
         "express": "^4.17.1",
         "express-fileupload": "^1.2.1",
+        "ioredis": "^5.2.0",
         "node-cron": "^3.0.1",
         "node-schedule": "^2.1.0",
         "parseurl": "^1.3.3",
@@ -28,12 +30,10 @@
         "randomstring": "^1.2.2",
         "redlock": "^5.0.0-beta.2",
         "reflect-metadata": "^0.1.13",
-        "ws": "^7.5.5",
-        "ioredis": "^5.2.0",
-        "axios": "^0.21.4"
+        "ws": "^7.5.5"
     },
     "peerDependencies": {
-        "@clairejs/core": "^3.6.1",
+        "@clairejs/core": "^3.7.1",
         "@clairejs/orm": "^3.11.0"
     },
     "devDependencies": {

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

@@ -1,40 +0,0 @@
-import { Constructor, DtoMetadata, HttpMethod, SocketMethod, ObjectFieldMetadata } from "@clairejs/core";
-import { RequestDataSource } from "./types";
-import { AbstractAccessCondition } from "../../http/security/AbstractAccessCondition";
-export interface EndpointMetadata extends ObjectFieldMetadata {
-    /**
-     * Basic HTTP information, name property is handler function name.
-     */
-    httpMethod: HttpMethod | SocketMethod;
-    url: string;
-    /**
-     * User-friendly display name of endpoint.
-     */
-    displayName?: string;
-    bodyValidationDto?: DtoMetadata;
-    queriesValidationDto?: DtoMetadata;
-    paramsValidationDto?: DtoMetadata;
-    responseValidationDto?: DtoMetadata;
-    params?: {
-        [index: number]: {
-            source?: RequestDataSource;
-            diClass?: Constructor<any>;
-        };
-    };
-    /**
-     * This endpoint requires tfa
-     */
-    tfaRequired?: boolean;
-    /**
-     * Allow public access to this endpoint.
-     */
-    openAccess?: boolean;
-    /**
-     * Metadata of access condition to allow a conditional access to the endpoint.
-     */
-    accessConditions?: Constructor<AbstractAccessCondition>[];
-    /**
-     * Group of permission of this endpoint.
-     */
-    permissionGroup?: string;
-}

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

@@ -1,7 +0,0 @@
-import { HttpMethod, SocketMethod } from "@clairejs/core";
-export interface HttpEndpoint {
-    mount?: string;
-    httpMethod?: HttpMethod | SocketMethod;
-    controller: any;
-    handlerFunctionName: string;
-}

package/dist/common/request/HttpEndpoint.js

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

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

@@ -1,6 +0,0 @@
-import { EndpointMetadata } from "./EndpointMetadata";
-import { HttpEndpoint } from "./HttpEndpoint";
-export interface MountedEndpointInfo {
-    endpointMetadata: EndpointMetadata;
-    endpoint: HttpEndpoint;
-}

package/dist/common/request/MountedEndpointInfo.js

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

package/dist/http/security/AbstractAccessCondition.d.ts

@@ -1,7 +0,0 @@
-import { AccessConditionMetadata } from "@clairejs/core";
-import { HttpRequest } from "../common/HttpRequest";
-export declare abstract class AbstractAccessCondition<T = any> {
-    abstract resolveConditionValue(request: HttpRequest): Promise<T>;
-    abstract validate(conditionValue: T, permittedConditionValue: any): Promise<boolean>;
-    abstract getConditionMetadata(): AccessConditionMetadata;
-}

package/dist/http/security/AbstractAccessCondition.js

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

package/dist/http/security/access-conditions/FilterModelFieldAccessCondition.d.ts

@@ -1,4 +0,0 @@
-import { Constructor } from "@clairejs/core";
-import { HttpRequest } from "../../common/HttpRequest";
-import { AbstractAccessCondition } from "../AbstractAccessCondition";
-export declare const FilterModelFieldAccessCondition: <T extends Constructor<any>>(model: T, name: string, requestedConditionValueResolver: (request: HttpRequest) => string[] | undefined) => Constructor<AbstractAccessCondition<string[] | undefined>>;

package/dist/http/security/access-conditions/FilterModelFieldAccessCondition.js

@@ -1,30 +0,0 @@
-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;
-};
-import { AccessConditionValueType, getObjectMetadata, Register, } from "@clairejs/core";
-import { AbstractAccessCondition } from "../AbstractAccessCondition";
-export const FilterModelFieldAccessCondition = (model, name, requestedConditionValueResolver) => {
-    let _ = class _ extends AbstractAccessCondition {
-        async resolveConditionValue(request) {
-            return requestedConditionValueResolver(request);
-        }
-        getConditionMetadata() {
-            return {
-                name,
-                valueType: AccessConditionValueType.CHOICES,
-                valueConstraint: getObjectMetadata(model).fields.map((f) => f.name),
-            };
-        }
-        async validate(requestedConditionValue, permittedConditionValue) {
-            return (!!requestedConditionValue &&
-                requestedConditionValue.every((value) => permittedConditionValue.includes(value)));
-        }
-    };
-    _ = __decorate([
-        Register()
-    ], _);
-    return _;
-};

package/dist/http/security/access-conditions/MaximumQueryLimit.d.ts

@@ -1,8 +0,0 @@
-import { AccessConditionMetadata } from "@clairejs/core";
-import { HttpRequest } from "../../common/HttpRequest";
-import { AbstractAccessCondition } from "../AbstractAccessCondition";
-export declare class MaximumQueryLimit extends AbstractAccessCondition {
-    resolveConditionValue(request: HttpRequest): Promise<any>;
-    validate(conditionValue: number, permittedConditionValue: number): Promise<boolean>;
-    getConditionMetadata(): AccessConditionMetadata;
-}

package/dist/http/security/access-conditions/MaximumQueryLimit.js

@@ -1,31 +0,0 @@
-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;
-};
-import { AccessConditionValueType, Register } from "@clairejs/core";
-import { AbstractAccessCondition } from "../AbstractAccessCondition";
-let MaximumQueryLimit = class MaximumQueryLimit extends AbstractAccessCondition {
-    async resolveConditionValue(request) {
-        let limit = request.getQuery().limit;
-        if (limit) {
-            limit = parseInt(limit);
-        }
-        return limit || 0;
-    }
-    async validate(conditionValue, permittedConditionValue) {
-        return conditionValue > 0 && conditionValue <= permittedConditionValue;
-    }
-    getConditionMetadata() {
-        return {
-            name: "maximum_query_limit",
-            valueType: AccessConditionValueType.NUMBER,
-            valueConstraint: JSON.stringify({ min: 1 }),
-        };
-    }
-};
-MaximumQueryLimit = __decorate([
-    Register()
-], MaximumQueryLimit);
-export { MaximumQueryLimit };