@tramvai/module-server 2.21.0 → 2.24.0

package/lib/modules/papi/api/index.d.ts

@@ -1,9 +1,10 @@
+import type { FastifyInstance } from 'fastify';
 import type { Papi } from '@tramvai/papi';
-import type express from 'express';
 import type { DI_TOKEN } from '@tramvai/core';
 import type { LOGGER_TOKEN } from '@tramvai/tokens-common';
 export interface CreateOptions {
+    baseUrl: string;
     di: typeof DI_TOKEN;
     logger: typeof LOGGER_TOKEN;
 }
-export declare function createApi(papiList: Papi[], { di, logger }: CreateOptions): express.RequestHandler;
+export declare function createApi(rootApp: FastifyInstance, papiList: Papi[], { baseUrl, di, logger }: CreateOptions): void;

package/lib/modules/papi/server/executor.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+export declare const papiExecutorProvider: import("@tinkoff/dippy").Provider<{
+    di: import("@tinkoff/dippy").BaseTokenInterface<import("@tinkoff/dippy").Container>;
+    logger: import("@tinkoff/dippy").BaseTokenInterface<import("@tramvai/tokens-common").LoggerFactory>;
+    fastifyRequest: import("@tinkoff/dippy").BaseTokenInterface<import("fastify").FastifyRequest<import("fastify/types/route").RouteGenericInterface, import("fastify").RawServerDefault, import("http").IncomingMessage, unknown, import("fastify").FastifyLoggerInstance> & {
+        cookies: Record<string, string>;
+        query: Record<string, string>;
+    }>;
+    requestManager: import("@tinkoff/dippy").BaseTokenInterface<import("@tramvai/tokens-common").RequestManager>;
+    responseManager: import("@tinkoff/dippy").BaseTokenInterface<import("@tramvai/tokens-common").ResponseManager>;
+}, import("@tinkoff/dippy").BaseTokenInterface<import("@tramvai/tokens-server-private").PapiExecutor>>;

package/lib/modules/papi/server/fileApi.d.ts

@@ -0,0 +1,2 @@
+import type { Provider } from '@tramvai/core';
+export declare const fileApiProvider: Provider;

package/lib/server/express-compatibility.d.ts

@@ -1,7 +1,6 @@
 /**
  * Fork of https://github.com/fastify/fastify-express
  */
-/// <reference types="node" />
 import express from 'express';
 import type { FastifyPluginCallback } from 'fastify';
 declare module 'fastify' {
@@ -21,5 +20,5 @@ interface Options {
         instance: express.Application;
     };
 }
-export declare const fastifyExpressCompatibility: FastifyPluginCallback<Options, import("http").Server>;
+export declare const fastifyExpressCompatibility: FastifyPluginCallback<Options, import("fastify").RawServerDefault>;
 export {};

package/lib/server/server.d.ts

@@ -3,7 +3,7 @@ import http from 'http';
 import type { SERVER_TOKEN } from '@tramvai/tokens-server';
 import type { LOGGER_TOKEN } from '@tramvai/tokens-common';
 import type { ENV_MANAGER_TOKEN } from '@tramvai/module-environment';
-export declare const serverFactory: () => http.Server;
+export declare const serverFactory: () => http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
 export declare const serverListenCommand: ({ server, logger, envManager, }: {
     server: typeof SERVER_TOKEN;
     logger: typeof LOGGER_TOKEN;

package/lib/server/webApp.d.ts

@@ -6,7 +6,7 @@ import type { WEB_FASTIFY_APP_TOKEN, WEB_FASTIFY_APP_AFTER_INIT_TOKEN, WEB_FASTI
 import type { ExtractDependencyType } from '@tinkoff/dippy';
 export declare const webAppFactory: ({ server }: {
     server: typeof SERVER_TOKEN;
-}) => import("fastify").FastifyInstance<import("http").Server, import("http").IncomingMessage, import("http").ServerResponse, import("fastify").FastifyLoggerInstance> & PromiseLike<import("fastify").FastifyInstance<import("http").Server, import("http").IncomingMessage, import("http").ServerResponse, import("fastify").FastifyLoggerInstance>>;
+}) => import("fastify").FastifyInstance<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyLoggerInstance> & PromiseLike<import("fastify").FastifyInstance<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyLoggerInstance>>;
 export declare const webAppExpressFactory: ({ webApp }: {
     webApp: typeof WEB_FASTIFY_APP_TOKEN;
 }) => import("express-serve-static-core").Express;

package/lib/server.es.js

@@ -1,11 +1,11 @@
 import { __decorate } from 'tslib';
 import { setDefaultResultOrder } from 'dns';
 import EventEmitter$1, { EventEmitter } from 'events';
-import { Scope, APP_INFO_TOKEN, Module, provide as provide$1, DI_TOKEN, COMMAND_LINE_RUNNER_TOKEN, commandLineListTokens, createToken } from '@tramvai/core';
-import { SERVER_MODULE_PAPI_PUBLIC_ROUTE, SERVER_MODULE_PAPI_PUBLIC_URL, SERVER_MODULE_PAPI_PRIVATE_URL, WEB_APP_BEFORE_INIT_TOKEN, WEB_APP_TOKEN, SERVER_MODULE_PAPI_PRIVATE_ROUTE, SERVER_MODULE_STATICS_OPTIONS, SERVER_TOKEN, READINESS_PROBE_TOKEN, LIVENESS_PROBE_TOKEN, UTILITY_SERVER_PATHS, PROXY_CONFIG_TOKEN, DEPENDENCIES_VERSION_FILTER_TOKEN, UTILITY_SERVER_PORT_TOKEN, WEB_APP_INIT_TOKEN, WEB_APP_AFTER_INIT_TOKEN, WEB_APP_LIMITER_TOKEN } from '@tramvai/tokens-server';
+import { Scope, APP_INFO_TOKEN, Module, provide as provide$1, DI_TOKEN as DI_TOKEN$1, COMMAND_LINE_RUNNER_TOKEN, commandLineListTokens, createToken } from '@tramvai/core';
+import { SERVER_MODULE_PAPI_PUBLIC_ROUTE, SERVER_MODULE_PAPI_PUBLIC_URL, SERVER_MODULE_PAPI_PRIVATE_URL, SERVER_MODULE_PAPI_PRIVATE_ROUTE, SERVER_MODULE_STATICS_OPTIONS, SERVER_TOKEN, READINESS_PROBE_TOKEN, LIVENESS_PROBE_TOKEN, UTILITY_SERVER_PATHS, WEB_APP_BEFORE_INIT_TOKEN, WEB_APP_TOKEN, PROXY_CONFIG_TOKEN, DEPENDENCIES_VERSION_FILTER_TOKEN, UTILITY_SERVER_PORT_TOKEN, WEB_APP_INIT_TOKEN, WEB_APP_AFTER_INIT_TOKEN, WEB_APP_LIMITER_TOKEN } from '@tramvai/tokens-server';
 export * from '@tramvai/tokens-server';
-import { WEB_FASTIFY_APP_BEFORE_INIT_TOKEN, UTILITY_WEB_FASTIFY_APP_TOKEN, UTILITY_SERVER_TOKEN, SERVER_FACTORY_TOKEN, WEB_FASTIFY_APP_TOKEN, WEB_FASTIFY_APP_FACTORY_TOKEN, WEB_FASTIFY_APP_INIT_TOKEN, WEB_FASTIFY_APP_AFTER_INIT_TOKEN, WEB_FASTIFY_APP_METRICS_TOKEN, WEB_FASTIFY_APP_LIMITER_TOKEN, WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN, WEB_FASTIFY_APP_PROCESS_ERROR_TOKEN, WEB_FASTIFY_APP_AFTER_ERROR_TOKEN } from '@tramvai/tokens-server-private';
-import { ROOT_EXECUTION_CONTEXT_TOKEN, REQUEST, RESPONSE, FASTIFY_REQUEST, FASTIFY_RESPONSE, RESPONSE_MANAGER_TOKEN, LOGGER_TOKEN, ENV_MANAGER_TOKEN, ENV_USED_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN } from '@tramvai/tokens-common';
+import { PAPI_EXECUTOR, WEB_FASTIFY_APP_BEFORE_INIT_TOKEN, UTILITY_WEB_FASTIFY_APP_TOKEN, UTILITY_SERVER_TOKEN, SERVER_FACTORY_TOKEN, WEB_FASTIFY_APP_TOKEN, WEB_FASTIFY_APP_FACTORY_TOKEN, WEB_FASTIFY_APP_INIT_TOKEN, WEB_FASTIFY_APP_AFTER_INIT_TOKEN, WEB_FASTIFY_APP_METRICS_TOKEN, WEB_FASTIFY_APP_LIMITER_TOKEN, WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN, WEB_FASTIFY_APP_PROCESS_ERROR_TOKEN, WEB_FASTIFY_APP_AFTER_ERROR_TOKEN } from '@tramvai/tokens-server-private';
+import { ROOT_EXECUTION_CONTEXT_TOKEN, REQUEST, RESPONSE, FASTIFY_REQUEST, FASTIFY_RESPONSE, RESPONSE_MANAGER_TOKEN, LOGGER_TOKEN, REQUEST_MANAGER_TOKEN, ENV_MANAGER_TOKEN, ENV_USED_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN } from '@tramvai/tokens-common';
 import { MetricsModule } from '@tramvai/module-metrics';
 import { CacheWarmupModule } from '@tramvai/module-cache-warmup';
 import http from 'http';
@@ -13,18 +13,18 @@ import fastify from 'fastify';
 import express from 'express';
 import { fastifyCookie } from '@fastify/cookie';
 import fastifyFormBody from '@fastify/formbody';
-import { provide, createChildContainer } from '@tinkoff/dippy';
+import { provide, createChildContainer, Scope as Scope$1, DI_TOKEN } from '@tinkoff/dippy';
 import fp from 'fastify-plugin';
 import symbols from 'fastify/lib/symbols';
 import isNil from '@tinkoff/utils/is/nil';
-import { isRedirectFoundError, isNotFoundError, isHttpError } from '@tinkoff/errors';
+import { isRedirectFoundError, isNotFoundError, isHttpError, HttpError } from '@tinkoff/errors';
 import zlib from 'zlib';
 import compression from 'compression';
 import os from 'os';
 import filterObj from '@tinkoff/utils/object/filter';
 import flatten from '@tinkoff/utils/array/flatten';
 import toArray from '@tinkoff/utils/array/toArray';
-import { create, middlewares, getPapiParameters, createPapiMethod } from '@tramvai/papi';
+import { getPapiParameters, isPapiMethod, createPapiMethod } from '@tramvai/papi';
 import eachObj from '@tinkoff/utils/object/each';
 import { resolve } from 'path';
 import FastifyStatic from '@fastify/static';
@@ -188,6 +188,7 @@ const errorHandler = (app, { log, beforeError, processError, afterError, }) => {
 
 const webAppFactory = ({ server }) => {
     const app = fastify({
+        ignoreTrailingSlash: true,
         serverFactory: (handler) => {
             server.on('request', handler);
             return server;
@@ -347,51 +348,102 @@ const xHeadersFactory = ({ app, envManager, appInfo, }) => {
     };
 };
 
-function createApi(papiList, { di, logger }) {
-    return create(papiList, [
-        middlewares.timeout(),
-        middlewares.cookie(),
-        middlewares.validate(),
-        middlewares.fillPapiState({
-            fillState: (papi) => {
-                let rootDeps = {};
-                if (papi.rootDeps) {
-                    rootDeps = di.getOfDeps(papi.rootDeps);
-                    rootDeps = papi.mapRootDeps ? papi.mapRootDeps(rootDeps) : rootDeps;
-                }
-                return (req, res) => {
+function createApi(rootApp, papiList, { baseUrl, di, logger }) {
+    const paths = new Set();
+    const papiLog = logger('papi');
+    rootApp.register(async (app) => {
+        await app.register(fastifyCookie);
+        await app.register(fastifyFormBody, { bodyLimit: 2097152 }); // 2mb
+        for (const papi of papiList) {
+            const papiParams = getPapiParameters(papi);
+            if (!papiParams) {
+                throw new Error(`papi should be created using createPapiMethod from @tramvai/papi,
+        got: ${JSON.stringify(papi)}`);
+            }
+            const { method, path, options } = papiParams;
+            const { timeout, schema } = options;
+            if (!path) {
+                throw new Error(`No path in papi handler, got: ${JSON.stringify(papi)}`);
+            }
+            const key = `${method} ${path}`;
+            if (paths.has(key)) {
+                throw new Error(`papi: route '${key}' already registered`);
+            }
+            paths.add(key);
+            const childLog = papiLog.child(`${papiParams.method}_${papiParams.path}`);
+            app[method](path, {
+                schema,
+                errorHandler: async (error, req, res) => {
                     var _a;
-                    const childDI = createChildContainer(di);
-                    childDI.register({
-                        provide: REQUEST,
+                    res.status(error.validation ? 400 : 503);
+                    childLog.error(error);
+                    return {
+                        resultCode: 'INTERNAL_ERROR',
+                        errorMessage: (_a = error.message) !== null && _a !== void 0 ? _a : 'internal error',
+                    };
+                },
+            }, async (req, res) => {
+                const childDi = createChildContainer(di, [
+                    {
+                        provide: FASTIFY_REQUEST,
+                        scope: Scope$1.REQUEST,
                         useValue: req,
-                    });
-                    childDI.register({
-                        provide: RESPONSE,
+                    },
+                    {
+                        provide: FASTIFY_RESPONSE,
+                        scope: Scope$1.REQUEST,
                         useValue: res,
-                    });
-                    return { ...rootDeps, ...childDI.getOfDeps((_a = papi.deps) !== null && _a !== void 0 ? _a : {}), req, res };
+                    },
+                    // TODO: remove deprecated after removing express compatibility layer
+                    {
+                        provide: REQUEST,
+                        scope: Scope$1.REQUEST,
+                        useValue: req.raw,
+                    },
+                    {
+                        provide: RESPONSE,
+                        scope: Scope$1.REQUEST,
+                        useValue: res.raw,
+                    },
+                ]);
+                const papiExecutor = childDi.get(PAPI_EXECUTOR);
+                // TODO: use abortSignal
+                const payload = await Promise.race([
+                    papiExecutor(papi),
+                    new Promise((resolve, reject) => setTimeout(() => reject(new HttpError({ httpStatus: 503, message: 'Execution timeout' })), timeout)),
+                ]);
+                const responseManager = childDi.get(RESPONSE_MANAGER_TOKEN);
+                res.headers(responseManager.getHeaders()).status(responseManager.getStatus());
+                if (res.sent) {
+                    return;
+                }
+                if (!payload && responseManager.getBody()) {
+                    res.send(responseManager.getBody());
+                    return res;
+                }
+                return {
+                    resultCode: 'OK',
+                    payload,
                 };
-            },
-        }),
-        middlewares.handler(),
-        middlewares.error({ logger }),
-    ]);
+            });
+        }
+    }, { prefix: baseUrl });
 }
 
-let Api;
+let papis;
 try {
     // eslint-disable-next-line import/no-extraneous-dependencies
-    Api = require('@tramvai/cli/lib/external/api').default; // eslint-disable-line import/no-unresolved
+    papis = require('@tramvai/cli/lib/external/api').default; // eslint-disable-line import/no-unresolved
 }
 catch (e) { }
 const getFileApi = ({ logger }) => {
     const log = logger('papi:fileApi');
     const result = [];
-    eachObj((v, k) => {
-        const handler = (v.handler || v.default);
-        if (!handler) {
+    eachObj(({ default: entry }, path) => {
+        if (!isPapiMethod(entry)) {
             log.error({
+                path,
+                entry,
                 message: `Cannot resolve a papi handler.
 Check that you are using file based papi right way by docs https://tramvai.dev/docs/how-to/how-create-papi#automatic-handler-creation
 In case you have not added any file papi handler, consider renaming directory ./src/api (by default) to the other name to resolve conflicts with papi, or
@@ -399,14 +451,12 @@ change settings application.commands.build.options.serverApiDir in tramvai.json`
             });
             throw new Error('Not a papi');
         }
-        const papiParameters = getPapiParameters(handler);
+        const papiParameters = getPapiParameters(entry);
         result.push(createPapiMethod({
-            ...v,
-            ...(papiParameters !== null && papiParameters !== void 0 ? papiParameters : {}),
-            path: `/${k}`,
-            handler,
+            ...papiParameters,
+            path: `/${path}`,
         }));
-    }, Api);
+    }, papis);
     return result;
 };
 const fileApiProvider = {
@@ -439,16 +489,50 @@ const sharedProviders = [
     },
 ];
 
+const papiExecutorProvider = provide({
+    provide: PAPI_EXECUTOR,
+    scope: Scope$1.REQUEST,
+    useFactory: ({ di, logger, fastifyRequest, requestManager, responseManager }) => {
+        var _a;
+        const papiLog = logger('papi');
+        const papiOptions = {
+            requestManager,
+            responseManager,
+            params: (_a = fastifyRequest.params) !== null && _a !== void 0 ? _a : {},
+            cookies: requestManager.getCookies(),
+            headers: requestManager.getHeaders(),
+            body: requestManager.getBody(),
+            parsedUrl: requestManager.getParsedUrl(),
+        };
+        return (papi) => {
+            const { handler, deps, method, path } = getPapiParameters(papi);
+            const papiContext = {
+                deps: di.getOfDeps(deps),
+                log: papiLog.child(`${method}_${path}`),
+            };
+            return handler.call(papiContext, papiOptions);
+        };
+    },
+    deps: {
+        di: DI_TOKEN,
+        logger: LOGGER_TOKEN,
+        fastifyRequest: FASTIFY_REQUEST,
+        requestManager: REQUEST_MANAGER_TOKEN,
+        responseManager: RESPONSE_MANAGER_TOKEN,
+    },
+});
+
 let ServerPapiModule = class ServerPapiModule {
 };
 ServerPapiModule = __decorate([
     Module({
         providers: [
+            papiExecutorProvider,
             fileApiProvider,
             ...sharedProviders,
             provide$1({
-                provide: WEB_APP_BEFORE_INIT_TOKEN,
-                useFactory: ({ di, app, logger, privateRoutes, publicRoutes, publicBaseUrl, privateBaseUrl, }) => () => {
+                provide: WEB_FASTIFY_APP_BEFORE_INIT_TOKEN,
+                useFactory: ({ di, logger, privateRoutes, publicRoutes, publicBaseUrl, privateBaseUrl }) => (app) => {
                     if (process.env.NODE_ENV === 'development') {
                         const papiListRoute = createPapiMethod({
                             method: 'get',
@@ -482,23 +566,22 @@ ServerPapiModule = __decorate([
                             : [papiListRoute];
                     }
                     if (privateRoutes) {
-                        const apiPrivate = createApi(flatten(privateRoutes), {
+                        createApi(app, flatten(privateRoutes), {
+                            baseUrl: privateBaseUrl,
                             di,
                             logger,
                         });
-                        app.use(privateBaseUrl, apiPrivate);
                     }
                     if (publicRoutes) {
-                        const apiPublic = createApi(flatten(publicRoutes), {
+                        createApi(app, flatten(publicRoutes), {
+                            baseUrl: publicBaseUrl,
                             di,
                             logger,
                         });
-                        app.use(publicBaseUrl, apiPublic);
                     }
                 },
                 deps: {
-                    app: WEB_APP_TOKEN,
-                    di: DI_TOKEN,
+                    di: DI_TOKEN$1,
                     logger: LOGGER_TOKEN,
                     privateRoutes: {
                         token: SERVER_MODULE_PAPI_PRIVATE_ROUTE,
@@ -522,14 +605,14 @@ ServerPapiModule = __decorate([
                 useValue: createPapiMethod({
                     method: 'get',
                     path: '/version',
-                    deps: {
-                        envManager: ENV_MANAGER_TOKEN,
-                    },
-                    async handler(req, res, { envManager }) {
+                    async handler() {
                         return {
-                            version: envManager.get('APP_VERSION'),
+                            version: this.deps.envManager.get('APP_VERSION'),
                         };
                     },
+                    deps: {
+                        envManager: ENV_MANAGER_TOKEN,
+                    },
                 }),
             }),
         ],
@@ -751,8 +834,8 @@ ${parsed.href || `${parsed.protocol}//${parsed.hostname}${parsed.path}`}
                     return createPapiMethod({
                         method: 'post',
                         path: '/debug-http-request',
-                        async handler({ req }) {
-                            const { delay = 10000 } = req.body;
+                        async handler({ body }) {
+                            const { delay = 10000 } = body;
                             if (delay) {
                                 interceptor.setDelay(delay);
                             }

package/lib/server.js

@@ -214,6 +214,7 @@ const errorHandler = (app, { log, beforeError, processError, afterError, }) => {
 
 const webAppFactory = ({ server }) => {
     const app = fastify__default["default"]({
+        ignoreTrailingSlash: true,
         serverFactory: (handler) => {
             server.on('request', handler);
             return server;
@@ -373,51 +374,102 @@ const xHeadersFactory = ({ app, envManager, appInfo, }) => {
     };
 };
 
-function createApi(papiList, { di, logger }) {
-    return papi.create(papiList, [
-        papi.middlewares.timeout(),
-        papi.middlewares.cookie(),
-        papi.middlewares.validate(),
-        papi.middlewares.fillPapiState({
-            fillState: (papi) => {
-                let rootDeps = {};
-                if (papi.rootDeps) {
-                    rootDeps = di.getOfDeps(papi.rootDeps);
-                    rootDeps = papi.mapRootDeps ? papi.mapRootDeps(rootDeps) : rootDeps;
-                }
-                return (req, res) => {
+function createApi(rootApp, papiList, { baseUrl, di, logger }) {
+    const paths = new Set();
+    const papiLog = logger('papi');
+    rootApp.register(async (app) => {
+        await app.register(cookie.fastifyCookie);
+        await app.register(fastifyFormBody__default["default"], { bodyLimit: 2097152 }); // 2mb
+        for (const papi$1 of papiList) {
+            const papiParams = papi.getPapiParameters(papi$1);
+            if (!papiParams) {
+                throw new Error(`papi should be created using createPapiMethod from @tramvai/papi,
+        got: ${JSON.stringify(papi$1)}`);
+            }
+            const { method, path, options } = papiParams;
+            const { timeout, schema } = options;
+            if (!path) {
+                throw new Error(`No path in papi handler, got: ${JSON.stringify(papi$1)}`);
+            }
+            const key = `${method} ${path}`;
+            if (paths.has(key)) {
+                throw new Error(`papi: route '${key}' already registered`);
+            }
+            paths.add(key);
+            const childLog = papiLog.child(`${papiParams.method}_${papiParams.path}`);
+            app[method](path, {
+                schema,
+                errorHandler: async (error, req, res) => {
                     var _a;
-                    const childDI = dippy.createChildContainer(di);
-                    childDI.register({
-                        provide: tokensCommon.REQUEST,
+                    res.status(error.validation ? 400 : 503);
+                    childLog.error(error);
+                    return {
+                        resultCode: 'INTERNAL_ERROR',
+                        errorMessage: (_a = error.message) !== null && _a !== void 0 ? _a : 'internal error',
+                    };
+                },
+            }, async (req, res) => {
+                const childDi = dippy.createChildContainer(di, [
+                    {
+                        provide: tokensCommon.FASTIFY_REQUEST,
+                        scope: dippy.Scope.REQUEST,
                         useValue: req,
-                    });
-                    childDI.register({
-                        provide: tokensCommon.RESPONSE,
+                    },
+                    {
+                        provide: tokensCommon.FASTIFY_RESPONSE,
+                        scope: dippy.Scope.REQUEST,
                         useValue: res,
-                    });
-                    return { ...rootDeps, ...childDI.getOfDeps((_a = papi.deps) !== null && _a !== void 0 ? _a : {}), req, res };
+                    },
+                    // TODO: remove deprecated after removing express compatibility layer
+                    {
+                        provide: tokensCommon.REQUEST,
+                        scope: dippy.Scope.REQUEST,
+                        useValue: req.raw,
+                    },
+                    {
+                        provide: tokensCommon.RESPONSE,
+                        scope: dippy.Scope.REQUEST,
+                        useValue: res.raw,
+                    },
+                ]);
+                const papiExecutor = childDi.get(tokensServerPrivate.PAPI_EXECUTOR);
+                // TODO: use abortSignal
+                const payload = await Promise.race([
+                    papiExecutor(papi$1),
+                    new Promise((resolve, reject) => setTimeout(() => reject(new errors.HttpError({ httpStatus: 503, message: 'Execution timeout' })), timeout)),
+                ]);
+                const responseManager = childDi.get(tokensCommon.RESPONSE_MANAGER_TOKEN);
+                res.headers(responseManager.getHeaders()).status(responseManager.getStatus());
+                if (res.sent) {
+                    return;
+                }
+                if (!payload && responseManager.getBody()) {
+                    res.send(responseManager.getBody());
+                    return res;
+                }
+                return {
+                    resultCode: 'OK',
+                    payload,
                 };
-            },
-        }),
-        papi.middlewares.handler(),
-        papi.middlewares.error({ logger }),
-    ]);
+            });
+        }
+    }, { prefix: baseUrl });
 }
 
-let Api;
+let papis;
 try {
     // eslint-disable-next-line import/no-extraneous-dependencies
-    Api = require('@tramvai/cli/lib/external/api').default; // eslint-disable-line import/no-unresolved
+    papis = require('@tramvai/cli/lib/external/api').default; // eslint-disable-line import/no-unresolved
 }
 catch (e) { }
 const getFileApi = ({ logger }) => {
     const log = logger('papi:fileApi');
     const result = [];
-    eachObj__default["default"]((v, k) => {
-        const handler = (v.handler || v.default);
-        if (!handler) {
+    eachObj__default["default"](({ default: entry }, path) => {
+        if (!papi.isPapiMethod(entry)) {
             log.error({
+                path,
+                entry,
                 message: `Cannot resolve a papi handler.
 Check that you are using file based papi right way by docs https://tramvai.dev/docs/how-to/how-create-papi#automatic-handler-creation
 In case you have not added any file papi handler, consider renaming directory ./src/api (by default) to the other name to resolve conflicts with papi, or
@@ -425,14 +477,12 @@ change settings application.commands.build.options.serverApiDir in tramvai.json`
             });
             throw new Error('Not a papi');
         }
-        const papiParameters = papi.getPapiParameters(handler);
+        const papiParameters = papi.getPapiParameters(entry);
         result.push(papi.createPapiMethod({
-            ...v,
-            ...(papiParameters !== null && papiParameters !== void 0 ? papiParameters : {}),
-            path: `/${k}`,
-            handler,
+            ...papiParameters,
+            path: `/${path}`,
         }));
-    }, Api);
+    }, papis);
     return result;
 };
 const fileApiProvider = {
@@ -465,16 +515,50 @@ const sharedProviders = [
     },
 ];
 
+const papiExecutorProvider = dippy.provide({
+    provide: tokensServerPrivate.PAPI_EXECUTOR,
+    scope: dippy.Scope.REQUEST,
+    useFactory: ({ di, logger, fastifyRequest, requestManager, responseManager }) => {
+        var _a;
+        const papiLog = logger('papi');
+        const papiOptions = {
+            requestManager,
+            responseManager,
+            params: (_a = fastifyRequest.params) !== null && _a !== void 0 ? _a : {},
+            cookies: requestManager.getCookies(),
+            headers: requestManager.getHeaders(),
+            body: requestManager.getBody(),
+            parsedUrl: requestManager.getParsedUrl(),
+        };
+        return (papi$1) => {
+            const { handler, deps, method, path } = papi.getPapiParameters(papi$1);
+            const papiContext = {
+                deps: di.getOfDeps(deps),
+                log: papiLog.child(`${method}_${path}`),
+            };
+            return handler.call(papiContext, papiOptions);
+        };
+    },
+    deps: {
+        di: dippy.DI_TOKEN,
+        logger: tokensCommon.LOGGER_TOKEN,
+        fastifyRequest: tokensCommon.FASTIFY_REQUEST,
+        requestManager: tokensCommon.REQUEST_MANAGER_TOKEN,
+        responseManager: tokensCommon.RESPONSE_MANAGER_TOKEN,
+    },
+});
+
 let ServerPapiModule = class ServerPapiModule {
 };
 ServerPapiModule = tslib.__decorate([
     core.Module({
         providers: [
+            papiExecutorProvider,
             fileApiProvider,
             ...sharedProviders,
             core.provide({
-                provide: tokensServer.WEB_APP_BEFORE_INIT_TOKEN,
-                useFactory: ({ di, app, logger, privateRoutes, publicRoutes, publicBaseUrl, privateBaseUrl, }) => () => {
+                provide: tokensServerPrivate.WEB_FASTIFY_APP_BEFORE_INIT_TOKEN,
+                useFactory: ({ di, logger, privateRoutes, publicRoutes, publicBaseUrl, privateBaseUrl }) => (app) => {
                     if (process.env.NODE_ENV === 'development') {
                         const papiListRoute = papi.createPapiMethod({
                             method: 'get',
@@ -508,22 +592,21 @@ ServerPapiModule = tslib.__decorate([
                             : [papiListRoute];
                     }
                     if (privateRoutes) {
-                        const apiPrivate = createApi(flatten__default["default"](privateRoutes), {
+                        createApi(app, flatten__default["default"](privateRoutes), {
+                            baseUrl: privateBaseUrl,
                             di,
                             logger,
                         });
-                        app.use(privateBaseUrl, apiPrivate);
                     }
                     if (publicRoutes) {
-                        const apiPublic = createApi(flatten__default["default"](publicRoutes), {
+                        createApi(app, flatten__default["default"](publicRoutes), {
+                            baseUrl: publicBaseUrl,
                             di,
                             logger,
                         });
-                        app.use(publicBaseUrl, apiPublic);
                     }
                 },
                 deps: {
-                    app: tokensServer.WEB_APP_TOKEN,
                     di: core.DI_TOKEN,
                     logger: tokensCommon.LOGGER_TOKEN,
                     privateRoutes: {
@@ -548,14 +631,14 @@ ServerPapiModule = tslib.__decorate([
                 useValue: papi.createPapiMethod({
                     method: 'get',
                     path: '/version',
-                    deps: {
-                        envManager: tokensCommon.ENV_MANAGER_TOKEN,
-                    },
-                    async handler(req, res, { envManager }) {
+                    async handler() {
                         return {
-                            version: envManager.get('APP_VERSION'),
+                            version: this.deps.envManager.get('APP_VERSION'),
                         };
                     },
+                    deps: {
+                        envManager: tokensCommon.ENV_MANAGER_TOKEN,
+                    },
                 }),
             }),
         ],
@@ -777,8 +860,8 @@ ${parsed.href || `${parsed.protocol}//${parsed.hostname}${parsed.path}`}
                     return papi.createPapiMethod({
                         method: 'post',
                         path: '/debug-http-request',
-                        async handler({ req }) {
-                            const { delay = 10000 } = req.body;
+                        async handler({ body }) {
+                            const { delay = 10000 } = body;
                             if (delay) {
                                 interceptor.setDelay(delay);
                             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-server",
-  "version": "2.21.0",
+  "version": "2.24.0",
   "description": "",
   "browser": "lib/browser.js",
   "main": "lib/server.js",
@@ -22,15 +22,15 @@
     "build-for-publish": "true"
   },
   "dependencies": {
-    "@tinkoff/errors": "0.3.2",
+    "@tinkoff/errors": "0.3.3",
     "@tinkoff/monkeypatch": "2.0.2",
     "@tinkoff/terminus": "0.1.2",
     "@tinkoff/url": "0.8.2",
-    "@tramvai/module-cache-warmup": "2.21.0",
-    "@tramvai/module-metrics": "2.21.0",
-    "@tramvai/papi": "2.21.0",
-    "@tramvai/tokens-server": "2.21.0",
-    "@tramvai/tokens-server-private": "2.21.0",
+    "@tramvai/module-cache-warmup": "2.24.0",
+    "@tramvai/module-metrics": "2.24.0",
+    "@tramvai/papi": "2.24.0",
+    "@tramvai/tokens-server": "2.24.0",
+    "@tramvai/tokens-server-private": "2.24.0",
     "compression": "^1.7.4",
     "express": "^4.17.1",
     "fastify": "^3.29.0",
@@ -43,11 +43,11 @@
   "peerDependencies": {
     "@tinkoff/dippy": "0.8.2",
     "@tinkoff/utils": "^2.1.2",
-    "@tramvai/cli": "2.21.0",
-    "@tramvai/core": "2.21.0",
-    "@tramvai/module-common": "2.21.0",
-    "@tramvai/module-environment": "2.21.0",
-    "@tramvai/tokens-common": "2.21.0",
+    "@tramvai/cli": "2.24.0",
+    "@tramvai/core": "2.24.0",
+    "@tramvai/module-common": "2.24.0",
+    "@tramvai/module-environment": "2.24.0",
+    "@tramvai/tokens-common": "2.24.0",
     "tslib": "^2.0.3"
   },
   "devDependencies": {

package/lib/modules/papi/fileApi.d.ts

@@ -1,8 +0,0 @@
-import type { Provider } from '@tramvai/core';
-declare module '@tramvai/papi/lib/types' {
-    interface PapiParameters<Deps, Result> {
-        rootDeps?: Record<string, any>;
-        mapRootDeps?: (rootDeps: Record<string, any>) => Record<string, any>;
-    }
-}
-export declare const fileApiProvider: Provider;