starta.microservice 0.1.4874 → 0.1.4879

package/lib/services/ServiceExecutorHandler.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -73,319 +64,309 @@ class ServiceExecutorHandler {
         __classPrivateFieldSet(this, _ServiceExecutorHandler_serviceExecutor, serviceExecutor, "f");
         __classPrivateFieldSet(this, _ServiceExecutorHandler_serviceFactory, serviceFactory, "f");
     }
-    execute(originalRequest, response) {
-        var _a, _b, _c, _d, _e;
-        return __awaiter(this, void 0, void 0, function* () {
-            const request = {
-                originalRequest,
-                contextType: '',
-                currentOrgPermissions: {},
-                session: null,
-                correlationId: ((_a = originalRequest.headers['x-correlation-id']) === null || _a === void 0 ? void 0 : _a.toString()) || crypto_1.default.randomBytes(10).toString('hex')
-            };
-            response.setHeader('x-correlation-id', request.correlationId);
-            executionContext_1.default.setCorrelationId(request.correlationId);
-            __classPrivateFieldSet(this, _ServiceExecutorHandler_logger, __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").withParams({
-                correlationId: request.correlationId,
-                clientIp: (_b = dataSelectors_1.default.selectClientIp(request)) === null || _b === void 0 ? void 0 : _b.clientIp,
-                clientCountry: (_c = dataSelectors_1.default.selectClientCountry(request)) === null || _c === void 0 ? void 0 : _c.clientCountry,
-                clientUA: (_d = dataSelectors_1.default.selectUserAgent(request)) === null || _d === void 0 ? void 0 : _d.userAgent,
-                request: {
-                    url: request.originalRequest.url,
-                    method: request.originalRequest.method,
-                }
-            }), "f");
-            loggerContext_1.default.setLogger(__classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f"));
-            let startTime = process.hrtime();
-            __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").generic.info("Request started");
-            try {
-                if (__classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").isAuthorized()) {
-                    yield this.checkAuth(request, response, __classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").allowAnonymous());
-                }
-                if (request.originalRequest.method !== 'GET' && (__classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").getBodyParser && __classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").getBodyParser()) !== 'raw') {
-                    request.originalRequest.body.createdAt = timeProvider_1.default.jsDate();
-                    request.originalRequest.body.createdBy = ((_e = request.session) === null || _e === void 0 ? void 0 : _e.account.login) || '%anonymous';
-                }
-                yield this.checkPermissions(request);
-                const executionResult = yield this.executeRequest(request);
-                if (executionResult === null || executionResult === void 0 ? void 0 : executionResult._cookies) {
-                    executionResult._cookies.forEach(cookie => response.cookie(cookie.name, cookie.value, cookie.options));
-                    delete executionResult._cookies;
-                }
-                if (executionResult === null || executionResult === void 0 ? void 0 : executionResult._clearCookies) {
-                    executionResult._clearCookies.forEach(cookie => response.clearCookie(cookie.name, cookie.options));
-                    delete executionResult._clearCookies;
-                }
-                if ((executionResult === null || executionResult === void 0 ? void 0 : executionResult._filePath) && executionResult._filePathToReplace) {
-                    let diff = process.hrtime(startTime);
-                    let timeInMilliseconds = diff[0] * 1000 + diff[1] / 1000000;
-                    __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").generic.info("Request finished with download file, status: 200", { taskDuration: timeInMilliseconds, statusCode: 200 });
-                    return response.download(path.resolve(executionResult._filePath), executionResult._filePathToReplace);
-                }
-                if (executionResult === null || executionResult === void 0 ? void 0 : executionResult._filePath) {
-                    const s3 = aws_1.default.getS3();
-                    var options = {
-                        Bucket: config_1.default.aws.bucketname,
-                        Key: executionResult === null || executionResult === void 0 ? void 0 : executionResult._filePath,
-                    };
-                    try {
-                        yield s3.headObject(options).promise();
-                        response.set('Cache-control', 'public, max-age=100000');
-                        response.attachment(executionResult === null || executionResult === void 0 ? void 0 : executionResult._filePath);
-                        var fileStream = s3.getObject(options).createReadStream();
-                        let diff = process.hrtime(startTime);
-                        let timeInMilliseconds = diff[0] * 1000 + diff[1] / 1000000;
-                        __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").generic.info("Request finished with pipe file from s3, status: 200", { taskDuration: timeInMilliseconds, statusCode: 200 });
-                        return fileStream.pipe(response);
-                    }
-                    catch (error) {
-                        let diff = process.hrtime(startTime);
-                        let timeInMilliseconds = diff[0] * 1000 + diff[1] / 1000000;
-                        __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").generic.info("Request finished file not found, status: 404", { taskDuration: timeInMilliseconds, statusCode: 404 });
-                        return response
-                            .status(404)
-                            .send(null);
-                    }
-                }
-                if (executionResult === null || executionResult === void 0 ? void 0 : executionResult._fileStream) {
-                    let diff = process.hrtime(startTime);
-                    let timeInMilliseconds = diff[0] * 1000 + diff[1] / 1000000;
-                    __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").generic.info("Request finished with pipe file, status: 200", { taskDuration: timeInMilliseconds, statusCode: 200 });
-                    return executionResult._fileStream.pipe(response);
-                }
-                const statusCode = request.originalRequest.method === 'POST' ? 201 : 200;
+    async execute(originalRequest, response) {
+        const request = {
+            originalRequest,
+            contextType: '',
+            currentOrgPermissions: {},
+            session: null,
+            correlationId: originalRequest.headers['x-correlation-id']?.toString() || crypto_1.default.randomBytes(10).toString('hex')
+        };
+        response.setHeader('x-correlation-id', request.correlationId);
+        executionContext_1.default.setCorrelationId(request.correlationId);
+        __classPrivateFieldSet(this, _ServiceExecutorHandler_logger, __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").withParams({
+            correlationId: request.correlationId,
+            clientIp: dataSelectors_1.default.selectClientIp(request)?.clientIp,
+            clientCountry: dataSelectors_1.default.selectClientCountry(request)?.clientCountry,
+            clientUA: dataSelectors_1.default.selectUserAgent(request)?.userAgent,
+            request: {
+                url: request.originalRequest.url,
+                method: request.originalRequest.method,
+            }
+        }), "f");
+        loggerContext_1.default.setLogger(__classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f"));
+        let startTime = process.hrtime();
+        __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").generic.info("Request started");
+        try {
+            if (__classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").isAuthorized()) {
+                await this.checkAuth(request, response, __classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").allowAnonymous());
+            }
+            if (request.originalRequest.method !== 'GET' && (__classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").getBodyParser && __classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").getBodyParser()) !== 'raw') {
+                request.originalRequest.body.createdAt = timeProvider_1.default.jsDate();
+                request.originalRequest.body.createdBy = request.session?.account.login || '%anonymous';
+            }
+            await this.checkPermissions(request);
+            const executionResult = await this.executeRequest(request);
+            if (executionResult?._cookies) {
+                executionResult._cookies.forEach(cookie => response.cookie(cookie.name, cookie.value, cookie.options));
+                delete executionResult._cookies;
+            }
+            if (executionResult?._clearCookies) {
+                executionResult._clearCookies.forEach(cookie => response.clearCookie(cookie.name, cookie.options));
+                delete executionResult._clearCookies;
+            }
+            if (executionResult?._filePath && executionResult._filePathToReplace) {
                 let diff = process.hrtime(startTime);
                 let timeInMilliseconds = diff[0] * 1000 + diff[1] / 1000000;
-                __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").generic.info("Request finished, status: " + statusCode, { taskDuration: timeInMilliseconds, statusCode });
-                return response
-                    .status(statusCode)
-                    .send(executionResult);
+                __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").generic.info("Request finished with download file, status: 200", { taskDuration: timeInMilliseconds, statusCode: 200 });
+                return response.download(path.resolve(executionResult._filePath), executionResult._filePathToReplace);
             }
-            catch (err) {
-                if (err instanceof Exception_1.default) {
-                    __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").debugBadRequest(err, request);
-                    const errorHash = err.toHash();
-                    delete errorHash.statusCode;
+            if (executionResult?._filePath) {
+                const s3 = aws_1.default.getS3();
+                var options = {
+                    Bucket: config_1.default.aws.bucketname,
+                    Key: executionResult?._filePath,
+                };
+                try {
+                    await s3.headObject(options).promise();
+                    response.set('Cache-control', 'public, max-age=100000');
+                    response.attachment(executionResult?._filePath);
+                    var fileStream = s3.getObject(options).createReadStream();
                     let diff = process.hrtime(startTime);
                     let timeInMilliseconds = diff[0] * 1000 + diff[1] / 1000000;
-                    __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").generic.info("Request finished, status: " + (err.statusCode || 400), { taskDuration: timeInMilliseconds, statusCode: err.statusCode || 400 });
-                    response.status(err.statusCode || 400).send(errorHash);
+                    __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").generic.info("Request finished with pipe file from s3, status: 200", { taskDuration: timeInMilliseconds, statusCode: 200 });
+                    return fileStream.pipe(response);
                 }
-                else {
+                catch (error) {
                     let diff = process.hrtime(startTime);
                     let timeInMilliseconds = diff[0] * 1000 + diff[1] / 1000000;
-                    __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").generic.error("Request finished, status: 500", { taskDuration: timeInMilliseconds, statusCode: 500 });
-                    __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").internalServerError(err, request);
-                    response.status(500).send(err);
+                    __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").generic.info("Request finished file not found, status: 404", { taskDuration: timeInMilliseconds, statusCode: 404 });
+                    return response
+                        .status(404)
+                        .send(null);
                 }
             }
-        });
-    }
-    checkPermissions(request) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const requestedAccountLogin = request.originalRequest.params._login;
-            request.contextType = requestedAccountLogin && (yield __classPrivateFieldGet(this, _ServiceExecutorHandler_redis, "f").getAccountType(requestedAccountLogin));
-            const endpointContext = __classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").getEndpointContext();
-            if (requestedAccountLogin && !request.contextType) {
-                throw new Exception_1.default({
-                    code: 'NOT_FOUND',
-                    statusCode: 404,
-                    fields: {
-                        login: {
-                            code: 'NOT_FOUND',
-                        },
-                    },
-                });
-            }
-            if (endpointContext !== 'any' && endpointContext !== request.contextType) {
-                throw new Exception_1.default({
-                    code: 'NOT_FOUND',
-                    statusCode: 404,
-                    fields: {
-                        login: {
-                            code: 'NOT_FOUND',
-                        },
-                    },
-                });
-            }
-            if (!request.session) {
-                return;
+            if (executionResult?._fileStream) {
+                let diff = process.hrtime(startTime);
+                let timeInMilliseconds = diff[0] * 1000 + diff[1] / 1000000;
+                __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").generic.info("Request finished with pipe file, status: 200", { taskDuration: timeInMilliseconds, statusCode: 200 });
+                return executionResult._fileStream.pipe(response);
             }
-            if (request.contextType == "organization") {
-                request.currentOrgPermissions = yield __classPrivateFieldGet(this, _ServiceExecutorHandler_redis, "f").getOrganizationMemberPermissions(requestedAccountLogin, request.session.account.login);
+            const statusCode = request.originalRequest.method === 'POST' ? 201 : 200;
+            let diff = process.hrtime(startTime);
+            let timeInMilliseconds = diff[0] * 1000 + diff[1] / 1000000;
+            __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").generic.info("Request finished, status: " + statusCode, { taskDuration: timeInMilliseconds, statusCode });
+            return response
+                .status(statusCode)
+                .send(executionResult);
+        }
+        catch (err) {
+            if (err instanceof Exception_1.default) {
+                __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").debugBadRequest(err, request);
+                const errorHash = err.toHash();
+                delete errorHash.statusCode;
+                let diff = process.hrtime(startTime);
+                let timeInMilliseconds = diff[0] * 1000 + diff[1] / 1000000;
+                __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").generic.info("Request finished, status: " + (err.statusCode || 400), { taskDuration: timeInMilliseconds, statusCode: err.statusCode || 400 });
+                response.status(err.statusCode || 400).send(errorHash);
             }
-            const requiredPermissionsSchemas = __classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").getRequiredPermissions();
-            if (!requiredPermissionsSchemas) {
-                return;
+            else {
+                let diff = process.hrtime(startTime);
+                let timeInMilliseconds = diff[0] * 1000 + diff[1] / 1000000;
+                __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").generic.error("Request finished, status: 500", { taskDuration: timeInMilliseconds, statusCode: 500 });
+                __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").internalServerError(err, request);
+                response.status(500).send(err);
             }
-            let hasPermissions = false;
-            if (requiredPermissionsSchemas.adminonly) {
-                hasPermissions = request.session.account.login === 'admin';
-                if (!hasPermissions) {
-                    const permissions = yield __classPrivateFieldGet(this, _ServiceExecutorHandler_redis, "f").getAdminPermissions(request.session.account.login);
-                    if (permissions === null || permissions === void 0 ? void 0 : permissions.isAdmin) {
-                        if (permissions.role === 'sale') {
-                            hasPermissions = requiredPermissionsSchemas.salesadmins;
-                        }
-                        else {
-                            hasPermissions = true;
-                        }
+        }
+    }
+    async checkPermissions(request) {
+        const requestedAccountLogin = request.originalRequest.params._login;
+        request.contextType = requestedAccountLogin && await __classPrivateFieldGet(this, _ServiceExecutorHandler_redis, "f").getAccountType(requestedAccountLogin);
+        const endpointContext = __classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").getEndpointContext();
+        if (requestedAccountLogin && !request.contextType) {
+            throw new Exception_1.default({
+                code: 'NOT_FOUND',
+                statusCode: 404,
+                fields: {
+                    login: {
+                        code: 'NOT_FOUND',
+                    },
+                },
+            });
+        }
+        if (endpointContext !== 'any' && endpointContext !== request.contextType) {
+            throw new Exception_1.default({
+                code: 'NOT_FOUND',
+                statusCode: 404,
+                fields: {
+                    login: {
+                        code: 'NOT_FOUND',
+                    },
+                },
+            });
+        }
+        if (!request.session) {
+            return;
+        }
+        if (request.contextType == "organization") {
+            request.currentOrgPermissions = await __classPrivateFieldGet(this, _ServiceExecutorHandler_redis, "f").getOrganizationMemberPermissions(requestedAccountLogin, request.session.account.login);
+        }
+        const requiredPermissionsSchemas = __classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").getRequiredPermissions();
+        if (!requiredPermissionsSchemas) {
+            return;
+        }
+        let hasPermissions = false;
+        if (requiredPermissionsSchemas.adminonly) {
+            hasPermissions = request.session.account.login === 'admin';
+            if (!hasPermissions) {
+                const permissions = await __classPrivateFieldGet(this, _ServiceExecutorHandler_redis, "f").getAdminPermissions(request.session.account.login);
+                if (permissions?.isAdmin) {
+                    if (permissions.role === 'sale') {
+                        hasPermissions = requiredPermissionsSchemas.salesadmins;
                     }
-                }
-            }
-            else if (request.contextType == "user") {
-                if ((_a = requiredPermissionsSchemas.user) === null || _a === void 0 ? void 0 : _a.myaccount) {
-                    if (request.session.account.login === requestedAccountLogin || request.session.account.login === 'admin') {
+                    else {
                         hasPermissions = true;
                     }
                 }
-                else {
-                    hasPermissions = true;
-                }
             }
-            else if (request.contextType == "organization") {
-                if (!requiredPermissionsSchemas.organization) {
+        }
+        else if (request.contextType == "user") {
+            if (requiredPermissionsSchemas.user?.myaccount) {
+                if (request.session.account.login === requestedAccountLogin || request.session.account.login === 'admin') {
                     hasPermissions = true;
                 }
-                else {
-                    if (request.currentOrgPermissions) {
-                        let missingAnyPermission = false;
-                        let hasAnyPrmission = false;
-                        requiredPermissionsSchemas.organization.forEach(permission => {
-                            if (!request.currentOrgPermissions[permission]) {
-                                missingAnyPermission = true;
-                            }
-                            else {
-                                hasAnyPrmission = true;
-                            }
-                        });
-                        if (requiredPermissionsSchemas.organizationPermissionsFilter === 'oneOf') {
-                            hasPermissions = hasAnyPrmission;
+            }
+            else {
+                hasPermissions = true;
+            }
+        }
+        else if (request.contextType == "organization") {
+            if (!requiredPermissionsSchemas.organization) {
+                hasPermissions = true;
+            }
+            else {
+                if (request.currentOrgPermissions) {
+                    let missingAnyPermission = false;
+                    let hasAnyPrmission = false;
+                    requiredPermissionsSchemas.organization.forEach(permission => {
+                        if (!request.currentOrgPermissions[permission]) {
+                            missingAnyPermission = true;
                         }
                         else {
-                            hasPermissions = !missingAnyPermission;
+                            hasAnyPrmission = true;
                         }
+                    });
+                    if (requiredPermissionsSchemas.organizationPermissionsFilter === 'oneOf') {
+                        hasPermissions = hasAnyPrmission;
+                    }
+                    else {
+                        hasPermissions = !missingAnyPermission;
                     }
-                    if (!hasPermissions && requiredPermissionsSchemas.organizationAllowForStartaAdmins) {
-                        const permissions = yield __classPrivateFieldGet(this, _ServiceExecutorHandler_redis, "f").getAdminPermissions(request.session.account.login);
-                        if (permissions === null || permissions === void 0 ? void 0 : permissions.isAdmin) {
+                    if (!hasAnyPrmission && requiredPermissionsSchemas.organizationAllowForStartaAdmins) {
+                        const permissions = await __classPrivateFieldGet(this, _ServiceExecutorHandler_redis, "f").getAdminPermissions(request.session.account.login);
+                        if (permissions?.isAdmin) {
                             hasPermissions = true;
                         }
                     }
                 }
             }
-            if (!hasPermissions) {
-                throw new Exception_1.default({
-                    code: 'FORBIDDEN',
-                    statusCode: 403,
-                });
-            }
-        });
+        }
+        if (!hasPermissions) {
+            throw new Exception_1.default({
+                code: 'FORBIDDEN',
+                statusCode: 403,
+            });
+        }
     }
-    checkAuth(request, response, allowAnonymous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const unauthorized = function (e) {
-                if (!allowAnonymous) {
-                    e = e || new Exception_1.default({
-                        code: 'UNAUTHORIZED',
-                        statusCode: 401,
-                        fields: {
-                            scheme: 'BAD_SCHEME',
-                        },
-                    });
-                    throw e;
-                }
-            };
-            let auth = null;
-            if (request.originalRequest.get('authorization')) {
-                try {
-                    auth = authorization.parse(request.originalRequest.get('authorization'));
-                }
-                catch (e) {
-                    return unauthorized();
-                }
-                if (auth.scheme !== 'Basic') {
-                    return unauthorized();
-                }
-            }
-            if (!auth && request.originalRequest.cookies && request.originalRequest.cookies.Authorization) {
-                auth = { token: request.originalRequest.cookies.Authorization };
-            }
-            if (!auth) {
-                return unauthorized();
-            }
-            const [sessionId] = helpers_1.default.getSessionId(auth.token);
-            const sessionData = yield __classPrivateFieldGet(this, _ServiceExecutorHandler_redis, "f").getSession(sessionId);
-            if (!sessionData) {
-                return unauthorized(new Exception_1.default({
+    async checkAuth(request, response, allowAnonymous) {
+        const unauthorized = function (e) {
+            if (!allowAnonymous) {
+                e = e || new Exception_1.default({
                     code: 'UNAUTHORIZED',
                     statusCode: 401,
                     fields: {
-                        token: 'BAD_TOKEN',
+                        scheme: 'BAD_SCHEME',
                     },
-                }));
-            }
-            if (sessionData.clientIp !== request.originalRequest.connection.remoteAddress) {
-                //this.#logger.generic.warn('WRONG_CLIENT_IP_ADDRESS %s %s', sessionData.clientIp, request.connection.remoteAddress);
-                // return Promise.reject(new Exception({
-                //   code: 'WRONG_CLIENT_IP_ADDRESS',
-                //   statusCode: 400,
-                //   fields: {
-                //     remoteAddress: 'BAD_IP',
-                //   },
-                // }));
-            }
-            request.session = {
-                sessionId,
-                account: new Account_1.default(sessionData.account),
-                date: timeProvider_1.default.jsDate(),
-            };
-            if (sessionData.account) {
-                response.cookie('Authorization', auth.token, { httpOnly: true, maxAge: sessionData.expirationTime * 1000, domain: new URL(config_1.default.siteUrl).hostname });
-                yield __classPrivateFieldGet(this, _ServiceExecutorHandler_redis, "f").resetSessionExpireTimeout(sessionId, sessionData.expirationTime);
-            }
-            __classPrivateFieldSet(this, _ServiceExecutorHandler_logger, __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").withParams({
-                login: request.session.account.login
-            }), "f");
-            executionContext_1.default.setAuthorizedUserLogin(request.session.account.login);
-        });
-    }
-    executeRequest(request, requestData = undefined, permissions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const serviceHandler = __classPrivateFieldGet(this, _ServiceExecutorHandler_serviceFactory, "f").createHandler(__classPrivateFieldGet(this, _ServiceExecutorHandler_serviceExecutor, "f"), request, __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f"));
-            if (permissions) {
-                serviceHandler.Permissions = permissions;
+                });
+                throw e;
             }
-            if (request) {
-                requestData = serviceHandler.selectData();
+        };
+        let auth = null;
+        if (request.originalRequest.get('authorization')) {
+            try {
+                auth = authorization.parse(request.originalRequest.get('authorization'));
             }
-            let objectRules = null;
-            if (__classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").getValidationRules) {
-                objectRules = __classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").getValidationRules(request);
+            catch (e) {
+                return unauthorized();
             }
-            else if (__classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").getValidationRulesPerContext && (request === null || request === void 0 ? void 0 : request.contextType)) {
-                objectRules = __classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").getValidationRulesPerContext(request)[request.contextType];
+            if (auth.scheme !== 'Basic') {
+                return unauthorized();
             }
-            if (objectRules) {
-                const rules = {
-                    type: 'object',
-                    rules: objectRules,
-                };
-                const validationResult = covalidation.createValidation(rules)(requestData);
-                if (validationResult.errors) {
-                    throw new Exception_1.default({
-                        code: 'FORMAT_ERROR',
-                        fields: validationResult.errors,
-                    });
-                }
-                requestData = validationResult.data;
+        }
+        if (!auth && request.originalRequest.cookies && request.originalRequest.cookies.Authorization) {
+            auth = { token: request.originalRequest.cookies.Authorization };
+        }
+        if (!auth) {
+            return unauthorized();
+        }
+        const [sessionId] = helpers_1.default.getSessionId(auth.token);
+        const sessionData = await __classPrivateFieldGet(this, _ServiceExecutorHandler_redis, "f").getSession(sessionId);
+        if (!sessionData) {
+            return unauthorized(new Exception_1.default({
+                code: 'UNAUTHORIZED',
+                statusCode: 401,
+                fields: {
+                    token: 'BAD_TOKEN',
+                },
+            }));
+        }
+        if (sessionData.clientIp !== request.originalRequest.connection.remoteAddress) {
+            //this.#logger.generic.warn('WRONG_CLIENT_IP_ADDRESS %s %s', sessionData.clientIp, request.connection.remoteAddress);
+            // return Promise.reject(new Exception({
+            //   code: 'WRONG_CLIENT_IP_ADDRESS',
+            //   statusCode: 400,
+            //   fields: {
+            //     remoteAddress: 'BAD_IP',
+            //   },
+            // }));
+        }
+        request.session = {
+            sessionId,
+            account: new Account_1.default(sessionData.account),
+            date: timeProvider_1.default.jsDate(),
+        };
+        if (sessionData.account) {
+            response.cookie('Authorization', auth.token, { httpOnly: true, maxAge: sessionData.expirationTime * 1000, domain: new URL(config_1.default.siteUrl).hostname });
+            await __classPrivateFieldGet(this, _ServiceExecutorHandler_redis, "f").resetSessionExpireTimeout(sessionId, sessionData.expirationTime);
+        }
+        __classPrivateFieldSet(this, _ServiceExecutorHandler_logger, __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f").withParams({
+            login: request.session.account.login
+        }), "f");
+        executionContext_1.default.setAuthorizedUserLogin(request.session.account.login);
+    }
+    async executeRequest(request, requestData = undefined, permissions) {
+        const serviceHandler = __classPrivateFieldGet(this, _ServiceExecutorHandler_serviceFactory, "f").createHandler(__classPrivateFieldGet(this, _ServiceExecutorHandler_serviceExecutor, "f"), request, __classPrivateFieldGet(this, _ServiceExecutorHandler_logger, "f"));
+        if (permissions) {
+            serviceHandler.Permissions = permissions;
+        }
+        if (request) {
+            requestData = serviceHandler.selectData();
+        }
+        let objectRules = null;
+        if (__classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").getValidationRules) {
+            objectRules = __classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").getValidationRules(request);
+        }
+        else if (__classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").getValidationRulesPerContext && request?.contextType) {
+            objectRules = __classPrivateFieldGet(this, _ServiceExecutorHandler_serviceDescription, "f").getValidationRulesPerContext(request)[request.contextType];
+        }
+        if (objectRules) {
+            const rules = {
+                type: 'object',
+                rules: objectRules,
+            };
+            const validationResult = covalidation.createValidation(rules)(requestData);
+            if (validationResult.errors) {
+                throw new Exception_1.default({
+                    code: 'FORMAT_ERROR',
+                    fields: validationResult.errors,
+                });
             }
-            //refactor
-            serviceHandler.requestData = requestData;
-            const executionResult = yield serviceHandler.execute(requestData);
-            return executionResult;
-        });
+            requestData = validationResult.data;
+        }
+        //refactor
+        serviceHandler.requestData = requestData;
+        const executionResult = await serviceHandler.execute(requestData);
+        return executionResult;
     }
 }
 _ServiceExecutorHandler_redis = new WeakMap(), _ServiceExecutorHandler_logger = new WeakMap(), _ServiceExecutorHandler_serviceDescription = new WeakMap(), _ServiceExecutorHandler_serviceFactory = new WeakMap(), _ServiceExecutorHandler_serviceExecutor = new WeakMap();