@clairejs/server 3.15.2 → 3.16.1

package/dist/http/controller/AbstractHttpRequestHandler.js

@@ -0,0 +1,69 @@
+import { getObjectMetadata, getServiceProvider, SocketMethod } from "@clairejs/core";
+import { getEndpointId } from "../utils";
+import { AbstractHttpController } from "./AbstractHttpController";
+export class AbstractHttpRequestHandler {
+    mountPoint;
+    logger;
+    mountedEndpointInfo;
+    corsConfig;
+    constructor(mountPoint, logger) {
+        this.mountPoint = mountPoint;
+        this.logger = logger;
+    }
+    resolverMountPoint(controllerMetadata, mappingUrls) {
+        if (!controllerMetadata) {
+            return "";
+        }
+        const urlParts = [];
+        urlParts.push(...mappingUrls);
+        let finalUrl = urlParts.reduce((collector, part) => `${collector}/${part}`, "");
+        //-- replace double slashes
+        return finalUrl.replace(/(\/)\/+/g, "$1");
+    }
+    async getMountedEndpointInfo() {
+        if (!this.mountedEndpointInfo) {
+            const result = [];
+            const injector = getServiceProvider().getInjector();
+            //-- get all controllers from registry and resolve endpoints
+            const controllers = injector.resolveMultiple(AbstractHttpController);
+            await injector.initInstances();
+            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({
+                        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);
+                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}`);
+                }
+                else {
+                    mountedEndpointInfo.push(endpointInfo);
+                }
+            }
+            this.mountedEndpointInfo = mountedEndpointInfo;
+        }
+        return this.mountedEndpointInfo;
+    }
+}

package/dist/http/controller/CrudHttpController.js

@@ -0,0 +1,303 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { getObjectMetadata, HttpMethod, getServiceProvider, leanData, getCreateManyBodyValidator, getCreateManyResponseValidator, getGetManyQueryValidator, getGetManyResponseValidator, getUpdateManyQueryValidator, getUpdateManyBodyValidator, getUpdateManyResponseValidator, uniqueReducer, omitData, getUpdateRecordsQueryValidator, getUpdateRecordsBodyValidator, } 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 { AbstractHttpController } from "./AbstractHttpController";
+import { MaximumQueryLimit } from "../security/access-conditions/MaximumQueryLimit";
+import { FilterModelFieldAccessCondition } from "../security/access-conditions/FilterModelFieldAccessCondition";
+export class CrudHttpController extends AbstractHttpController {
+    model;
+    crudRepository;
+    databaseAdapter;
+    modelMetadata;
+    principalResolver;
+    constructor(model, crudRepository, databaseAdapter) {
+        super(databaseAdapter);
+        this.model = model;
+        this.crudRepository = crudRepository;
+        this.databaseAdapter = databaseAdapter;
+        this.modelMetadata = getObjectMetadata(model);
+    }
+    getMountedUrl() {
+        return `/${this.model.name.toLowerCase()}`;
+    }
+    async getAuthProvider() {
+        if (this.principalResolver === undefined) {
+            const injector = getServiceProvider().getInjector();
+            this.principalResolver = injector.resolveOptional(AbstractPrincipalResolver) || null;
+            await injector.initInstances();
+        }
+        return this.principalResolver;
+    }
+    /**
+     * This provides endpoint metadata for mounting /POST request.
+     */
+    createManyEndpoinMetadata() {
+        const endpointMetadata = {};
+        endpointMetadata.httpMethod = HttpMethod.POST;
+        endpointMetadata.url = this.getMountedUrl();
+        endpointMetadata.name = CrudHttpController.prototype.createMany.name;
+        endpointMetadata.displayName = "createMany" + this.model.name;
+        //-- body dto ------------------------------------
+        endpointMetadata.bodyValidationDto = getCreateManyBodyValidator(this.modelMetadata);
+        //-- response dto ------------------------------------
+        endpointMetadata.responseValidationDto = getCreateManyResponseValidator(this.modelMetadata);
+        endpointMetadata.accessConditions = [];
+        endpointMetadata.params = { 0: { source: "raw" } };
+        return endpointMetadata;
+    }
+    /**
+     * This provides endpoint metadata for mounting /GET request.
+     */
+    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;
+        //-- query dto
+        endpointMetadata.queriesValidationDto = 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.params = { 0: { source: "raw" } };
+        return endpointMetadata;
+    }
+    /**
+     * This provides endpoint metadata for mounting /PUT request.
+     */
+    updateManyEndpointMetadata() {
+        const endpointMetadata = {};
+        endpointMetadata.httpMethod = HttpMethod.PUT;
+        endpointMetadata.url = this.getMountedUrl();
+        endpointMetadata.name = CrudHttpController.prototype.updateMany.name;
+        endpointMetadata.displayName = "update" + this.model.name;
+        //-- queries dto ---------------------------------
+        endpointMetadata.queriesValidationDto = getUpdateManyQueryValidator(this.modelMetadata);
+        //-- body dto ------------------------------------
+        endpointMetadata.bodyValidationDto = 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.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;
+        //-- queries dto ---------------------------------
+        endpointMetadata.queriesValidationDto = getUpdateRecordsQueryValidator();
+        //-- body dto ------------------------------------
+        endpointMetadata.bodyValidationDto = 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, []);
+            }),
+        ];
+        return endpointMetadata;
+    }
+    /**
+     * This provides endpoint metadata for mounting /DELETE request.
+     */
+    deleteManyEndpoinMetadata() {
+        const endpointMetadata = {};
+        endpointMetadata.httpMethod = HttpMethod.DEL;
+        endpointMetadata.url = this.getMountedUrl();
+        endpointMetadata.name = CrudHttpController.prototype.deleteMany.name;
+        endpointMetadata.displayName = "delete" + this.model.name;
+        //-- queries ---------------------------------
+        endpointMetadata.queriesValidationDto = getUpdateManyQueryValidator(this.modelMetadata);
+        endpointMetadata.responseValidationDto = getUpdateManyResponseValidator(this.modelMetadata);
+        endpointMetadata.params = { 0: { source: "raw" } };
+        //-- access condition
+        endpointMetadata.accessConditions = [];
+        return endpointMetadata;
+    }
+    /**
+     * Handler functions
+     */
+    getEndpointMetadata() {
+        let allEndpoints = super.getEndpointMetadata();
+        const crudEnpointMetadata = [];
+        if (!this.modelMetadata.ignoreCrud?.includes(HttpMethod.GET)) {
+            crudEnpointMetadata.push(this.getManyEndpointMetadata());
+        }
+        else {
+            allEndpoints = allEndpoints.filter((e) => e.name !== CrudHttpController.prototype.getMany.name);
+        }
+        if (!this.modelMetadata.ignoreCrud?.includes(HttpMethod.POST)) {
+            crudEnpointMetadata.push(this.createManyEndpoinMetadata());
+        }
+        else {
+            allEndpoints = allEndpoints.filter((e) => e.name !== CrudHttpController.prototype.createMany.name);
+        }
+        if (!this.modelMetadata.ignoreCrud?.includes(HttpMethod.PUT)) {
+            crudEnpointMetadata.push(this.updateManyEndpointMetadata());
+            crudEnpointMetadata.push(this.updateRecordsEndpointMetadata());
+        }
+        else {
+            allEndpoints = allEndpoints.filter((e) => e.name !== CrudHttpController.prototype.updateMany.name &&
+                e.name !== CrudHttpController.prototype.updateRecords.name);
+        }
+        if (!this.modelMetadata.ignoreCrud?.includes(HttpMethod.DEL)) {
+            crudEnpointMetadata.push(this.deleteManyEndpoinMetadata());
+        }
+        else {
+            allEndpoints = allEndpoints.filter((e) => e.name !== CrudHttpController.prototype.deleteMany.name);
+        }
+        //-- 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)));
+            if (index >= 0) {
+                allEndpoints[index] = {
+                    ...endpoint,
+                    ...allEndpoints[index],
+                    accessConditions: [
+                        ...(endpoint.accessConditions || []),
+                        ...(allEndpoints[index].accessConditions || []),
+                    ],
+                };
+            }
+            else {
+                allEndpoints.push(endpoint);
+            }
+        }
+        return allEndpoints;
+    }
+    async updateRecords(req) {
+        const tx = await this.getCurrentTransaction();
+        const authProvider = await this.getAuthProvider();
+        const principal = authProvider && (await authProvider.resolvePrincipal(req));
+        const body = req.getBody();
+        const queries = req.getQuery();
+        const updatedRecords = await Promise.all(body.records.map((record) => this.crudRepository.updateMany({
+            principal,
+            queries: { ...queries, fields: { id: [record.id] } },
+            body: { update: omitData(record, ["id"]) },
+            tx,
+        })));
+        const response = {
+            modified: updatedRecords.map((re) => re.modified[0]),
+        };
+        return ResponseBuilder.json(response).get();
+    }
+    async createMany(req) {
+        const tx = await this.getCurrentTransaction();
+        const authProvider = await this.getAuthProvider();
+        const principal = authProvider && (await authProvider.resolvePrincipal(req));
+        const result = await this.crudRepository.createMany({
+            principal,
+            body: req.getBody(),
+            tx,
+        });
+        return ResponseBuilder.json(result).get();
+    }
+    async getMany(req) {
+        const result = await this.crudRepository.getMany({
+            queries: req.getQuery(),
+            queryProvider: this.databaseAdapter,
+        });
+        return ResponseBuilder.json(result).get();
+    }
+    async updateMany(req) {
+        const tx = await this.getCurrentTransaction();
+        const authProvider = await this.getAuthProvider();
+        const principal = authProvider && (await authProvider.resolvePrincipal(req));
+        const result = await this.crudRepository.updateMany({
+            principal,
+            queries: req.getQuery(),
+            body: req.getBody(),
+            tx,
+        });
+        return ResponseBuilder.json(result).get();
+    }
+    async deleteMany(req) {
+        const tx = await this.getCurrentTransaction();
+        const result = await this.crudRepository.deleteMany({ queries: req.getQuery(), tx });
+        return ResponseBuilder.json({
+            modified: result.modified.map((instance) => instance.id).map((id) => ({ id })),
+        }).get();
+    }
+}
+__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: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: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: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: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:returntype", Promise)
+], CrudHttpController.prototype, "deleteMany", null);

package/dist/http/controller/DefaultHttpRequestHandler.js

@@ -0,0 +1,143 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { AbstractLogger, stripData, Injectable, getServiceProvider, Errors, LogContext } from "@clairejs/core";
+import randomstring from "randomstring";
+import parseurl from "parseurl";
+import { match } from "path-to-regexp";
+import queryString from "query-string";
+import { HttpResponse, ResponseBuilder } from "../common/HttpResponse";
+import { AbstractPrincipalResolver } from "../../common/auth/AbstractPrincipalResolver";
+import { HttpRequest } from "../common/HttpRequest";
+import { AbstractRequestAuthorizer } from "../auth/AbstractHttpAuthorizer";
+import { AbstractHttpMiddleware } from "./AbstractHttpMiddleware";
+import { AbstractHttpRequestHandler } from "./AbstractHttpRequestHandler";
+let DefaultHttpRequestHandler = class DefaultHttpRequestHandler extends AbstractHttpRequestHandler {
+    logger;
+    authorizationProvider;
+    principalResolver;
+    _middleware = null;
+    constructor(logger, authorizationProvider, principalResolver) {
+        super("", logger);
+        this.logger = logger;
+        this.authorizationProvider = authorizationProvider;
+        this.principalResolver = principalResolver;
+    }
+    async handleRequest(endpoint, req) {
+        //-- supply correct order of params into handler
+        const params = Object.values(endpoint.endpointMetadata.params || {}).map((p) => {
+            switch (p.source) {
+                case "body":
+                    return req.getBody();
+                case "params":
+                    return req.getParams();
+                case "queries":
+                    return req.getQuery();
+                case "headers":
+                    return req.headers;
+                case "raw":
+                    return req;
+            }
+        });
+        const response = await endpoint.endpoint.controller[endpoint.endpointMetadata.name](...params);
+        //-- validate response value against response dto
+        if (endpoint.endpointMetadata.responseValidationDto) {
+            response.value = stripData(response.value, endpoint.endpointMetadata.responseValidationDto);
+        }
+        return response;
+    }
+    exit() { }
+    async getResponse(httpData) {
+        let response = new HttpResponse();
+        //-- match options with handler
+        const method = httpData.method;
+        const result = parseurl({ url: httpData.fullPath });
+        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 || "/");
+            if (!parsedParams) {
+                return false;
+            }
+            params = parsedParams;
+            return true;
+        });
+        if (!info) {
+            this.logger.debug(httpData);
+            throw Errors.NOT_FOUND(`Handler not found`);
+        }
+        const request = new HttpRequest({
+            clientIP: httpData.clientIP,
+            method,
+            headers: httpData.headers,
+            pathName: result.pathname || "",
+            hash: result.hash || "",
+            query: queryString.parse(decodeURIComponent(result.search || "")),
+            params: params.params,
+            body: httpData.body,
+            cookies: httpData.cookies,
+        }, info.endpointMetadata);
+        const authInfo = await this.principalResolver.resolvePrincipal(request);
+        request.setAuthInfo(authInfo);
+        if (!info.endpointMetadata.openAccess) {
+            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);
+            if (!next) {
+                return response;
+            }
+        }
+        const finalResponse = await this.handleRequest(info, request);
+        //-- merge response data
+        finalResponse.code = finalResponse.code || response.code || 200;
+        finalResponse.value = finalResponse.value || response.value;
+        finalResponse.headers = { ...response.headers, ...finalResponse.headers };
+        finalResponse.cookies = { ...response.cookies, ...finalResponse.cookies };
+        return finalResponse;
+    }
+    async handle(httpData) {
+        const requestId = randomstring.generate();
+        this.logger.info(`===== HANDLING REQUEST: ${requestId} - ${httpData.method}:${httpData.fullPath}`);
+        try {
+            const response = await this.getResponse(httpData);
+            if (!response || !(response instanceof HttpResponse)) {
+                throw Errors.SYSTEM_ERROR(`Invalid response value returned, required instance of ${HttpResponse.name}, found ${response ? response?.constructor.name : response}`);
+            }
+            this.logger.info(`===== REQUEST SUCCESS: ${requestId} - ${httpData.method}:${httpData.fullPath}`);
+            return response;
+        }
+        catch (err) {
+            this.logger.error(err);
+            const response = ResponseBuilder.json({ name: err.name, message: err.message })
+                .status(err.code || 500)
+                .get();
+            this.logger.info(`===== REQUEST FAILED: ${requestId} - ${httpData.method}:${httpData.fullPath}, code: ${response.code}`, response.value);
+            return response;
+        }
+    }
+    async getMiddleware() {
+        if (this._middleware === null) {
+            const injector = getServiceProvider().getInjector();
+            this._middleware = injector.resolveMultiple(AbstractHttpMiddleware);
+            await injector.initInstances();
+        }
+        return this._middleware;
+    }
+};
+DefaultHttpRequestHandler = __decorate([
+    Injectable(),
+    LogContext(),
+    __metadata("design:paramtypes", [AbstractLogger,
+        AbstractRequestAuthorizer,
+        AbstractPrincipalResolver])
+], DefaultHttpRequestHandler);
+export { DefaultHttpRequestHandler };

package/dist/http/decorators.d.ts

@@ -4,7 +4,7 @@ import { AbstractAccessCondition } from "./security/AbstractAccessCondition";
 import { HttpResponse } from "./common/HttpResponse";
 import { UriMapperHandler } from "./file-upload/types";
 import { IPrincipal } from "../common/auth/IPrincipal";
-declare type HttpFunctionMethod<T> = (...args: any[]) => Promise<HttpResponse<T>>;
+type HttpFunctionMethod<T> = (...args: any[]) => Promise<HttpResponse<T>>;
 export declare const ApiDescription: (description: string) => (prototype: AbstractHttpController, propertyKey: string) => void;
 export declare const Endpoint: (config: {
     method: HttpMethod;

package/dist/http/decorators.js

@@ -0,0 +1,86 @@
+import { initFieldMetadata, getObjectMetadata, HttpMethod, DataType, } 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;
+    //-- default to "/" if empty string is provided
+    endpointMetadata.url = config.url || "/";
+};
+const HttpMethodDecoratorFactory = (method) => (url) => (prototype, propertyKey, _descriptor) => Endpoint({ method, url })(prototype, propertyKey);
+export const Post = HttpMethodDecoratorFactory(HttpMethod.POST);
+export const Put = HttpMethodDecoratorFactory(HttpMethod.PUT);
+export const Del = HttpMethodDecoratorFactory(HttpMethod.DEL);
+export const Get = HttpMethodDecoratorFactory(HttpMethod.GET);
+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: [] };
+    }
+    else if (responseClass === Number) {
+        endpointMetadata.responseValidationDto = { id: "", primitiveType: DataType.NUMBER, fields: [] };
+    }
+    else if (responseClass === Boolean) {
+        endpointMetadata.responseValidationDto = { id: "", primitiveType: DataType.BOOLEAN, fields: [] };
+    }
+    else {
+        endpointMetadata.responseValidationDto = 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]);
+            break;
+        case "params":
+            endpointMetadata.paramsValidationDto = getObjectMetadata(paramClasses[paramIndex]);
+            break;
+        case "queries":
+            endpointMetadata.queriesValidationDto = getObjectMetadata(paramClasses[paramIndex]);
+            break;
+        default:
+            break;
+    }
+    if (!endpointMetadata.params) {
+        endpointMetadata.params = {};
+    }
+    endpointMetadata.params[paramIndex] = {
+        source,
+        diClass: paramClasses[paramIndex],
+    };
+};
+export const Body = () => RequestDeco("body");
+export const Params = () => RequestDeco("params");
+export const Queries = () => RequestDeco("queries");
+export const Headers = () => RequestDeco("headers");
+export const Socket = () => RequestDeco("socket");
+export const Raw = () => RequestDeco("raw");
+export const UriMapper = (mapper) => (prototype, propertyKey) => {
+    const field = initFieldMetadata(prototype, propertyKey);
+    field.uriMapper = mapper;
+};
+/**
+ * Current User decorator only has effect when being used with ICrudRepository.
+ *  */
+export const CurrentUser = (resolver) => (prototype, propertyKey) => {
+    const field = initFieldMetadata(prototype, propertyKey);
+    field.userResolver = resolver;
+    field.serverValue = true;
+};

package/dist/http/file-upload/AbstractFileUploadHandler.js

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

package/dist/http/file-upload/FileUploadHandler.js

@@ -0,0 +1,41 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Injectable } from "@clairejs/core";
+import { AbstractFileService } from "../../services/AbstractFileService";
+import { AbstractFileUploadHandler } from "./AbstractFileUploadHandler";
+let FileUploadHandler = class FileUploadHandler extends AbstractFileUploadHandler {
+    fileService;
+    constructor(fileService) {
+        super();
+        this.fileService = fileService;
+    }
+    async moveFile(fromURI, toURI) {
+        await this.fileService.moveObject([{ fromURI, toURI }]);
+    }
+    async copyFile(fromURI, toURI) {
+        await this.fileService.copyObject([{ fromURI, toURI }]);
+    }
+    async removeFile(uri) {
+        await this.fileService.removeObject([uri]);
+    }
+    async resolvePublicUrl(uri) {
+        const result = await this.fileService.getAccessUrls([uri], true);
+        return result[0];
+    }
+    async resolvePrivateUrl(uri) {
+        const result = await this.fileService.getAccessUrls([uri], false);
+        return result[0];
+    }
+};
+FileUploadHandler = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [AbstractFileService])
+], FileUploadHandler);
+export { FileUploadHandler };

package/dist/http/file-upload/types.d.ts

@@ -1 +1 @@
-export declare type UriMapperHandler = (tmpUri: string, locale?: string) => string;
+export type UriMapperHandler = (tmpUri: string, locale?: string) => string;

package/dist/http/file-upload/types.js

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