@clairejs/server 3.16.19 → 3.17.1

package/README.md

@@ -1,5 +1,10 @@
 ## Change Log
 
+#### 3.17.1:
+
+-   refactor EndpointMetadata, remove MountedEndpointInfo
+-   add putFile in AbstractFileService
+
 #### 3.16.19:
 
 -   fix dependency

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;