@tramvai/module-server 2.70.0 → 2.72.0

package/lib/modules/keepAlive.es.js

@@ -0,0 +1,47 @@
+import { __decorate } from 'tslib';
+import { Module, provide, commandLineListTokens } from '@tramvai/core';
+import { ENV_USED_TOKEN } from '@tramvai/tokens-common';
+import { ENV_MANAGER_TOKEN } from '@tramvai/module-common';
+import { SERVER_TOKEN } from '@tramvai/tokens-server';
+
+let KeepAliveModule = class KeepAliveModule {
+};
+KeepAliveModule = __decorate([
+    Module({
+        providers: [
+            provide({
+                provide: ENV_USED_TOKEN,
+                useValue: [
+                    {
+                        key: 'NODE_KEEPALIVE_TIMEOUT',
+                        optional: true,
+                        validator(keepAliveTimeout) {
+                            const value = Number(keepAliveTimeout);
+                            if (Number.isNaN(value)) {
+                                return 'Env variable NODE_KEEPALIVE_TIMEOUT should be a number';
+                            }
+                            if (value < 0) {
+                                return 'Env variable NODE_KEEPALIVE_TIMEOUT should be greater or equal than 0';
+                            }
+                            return true;
+                        },
+                    },
+                ],
+            }),
+            provide({
+                provide: commandLineListTokens.init,
+                useFactory: ({ server, envManager, }) => () => {
+                    const externalKeepAliveTimeout = envManager.get('NODE_KEEPALIVE_TIMEOUT');
+                    if (externalKeepAliveTimeout !== 'undefined') {
+                        // eslint-disable-next-line no-param-reassign
+                        server.keepAliveTimeout = Number(externalKeepAliveTimeout);
+                    }
+                },
+                multi: true,
+                deps: { server: SERVER_TOKEN, envManager: ENV_MANAGER_TOKEN },
+            }),
+        ],
+    })
+], KeepAliveModule);
+
+export { KeepAliveModule };

package/lib/modules/keepAlive.js

@@ -0,0 +1,49 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('@tramvai/core');
+var tokensCommon = require('@tramvai/tokens-common');
+var moduleCommon = require('@tramvai/module-common');
+var tokensServer = require('@tramvai/tokens-server');
+
+exports.KeepAliveModule = class KeepAliveModule {
+};
+exports.KeepAliveModule = tslib.__decorate([
+    core.Module({
+        providers: [
+            core.provide({
+                provide: tokensCommon.ENV_USED_TOKEN,
+                useValue: [
+                    {
+                        key: 'NODE_KEEPALIVE_TIMEOUT',
+                        optional: true,
+                        validator(keepAliveTimeout) {
+                            const value = Number(keepAliveTimeout);
+                            if (Number.isNaN(value)) {
+                                return 'Env variable NODE_KEEPALIVE_TIMEOUT should be a number';
+                            }
+                            if (value < 0) {
+                                return 'Env variable NODE_KEEPALIVE_TIMEOUT should be greater or equal than 0';
+                            }
+                            return true;
+                        },
+                    },
+                ],
+            }),
+            core.provide({
+                provide: core.commandLineListTokens.init,
+                useFactory: ({ server, envManager, }) => () => {
+                    const externalKeepAliveTimeout = envManager.get('NODE_KEEPALIVE_TIMEOUT');
+                    if (externalKeepAliveTimeout !== 'undefined') {
+                        // eslint-disable-next-line no-param-reassign
+                        server.keepAliveTimeout = Number(externalKeepAliveTimeout);
+                    }
+                },
+                multi: true,
+                deps: { server: tokensServer.SERVER_TOKEN, envManager: moduleCommon.ENV_MANAGER_TOKEN },
+            }),
+        ],
+    })
+], exports.KeepAliveModule);

package/lib/modules/papi/api/index.es.js

@@ -0,0 +1,80 @@
+import { fastifyCookie } from '@fastify/cookie';
+import fastifyFormBody from '@fastify/formbody';
+import { getPapiParameters } from '@tramvai/papi';
+import { RESPONSE_MANAGER_TOKEN } from '@tramvai/tokens-common';
+import { FASTIFY_REQUEST, FASTIFY_RESPONSE, PAPI_EXECUTOR } from '@tramvai/tokens-server-private';
+import { createChildContainer, Scope } from '@tinkoff/dippy';
+import { HttpError } from '@tinkoff/errors';
+
+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;
+                    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.REQUEST,
+                        useValue: req,
+                    },
+                    {
+                        provide: FASTIFY_RESPONSE,
+                        scope: Scope.REQUEST,
+                        useValue: res,
+                    },
+                ]);
+                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,
+                };
+            });
+        }
+    }, { prefix: baseUrl });
+}
+
+export { createApi };

package/lib/modules/papi/api/index.js

@@ -0,0 +1,88 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var cookie = require('@fastify/cookie');
+var fastifyFormBody = require('@fastify/formbody');
+var papi = require('@tramvai/papi');
+var tokensCommon = require('@tramvai/tokens-common');
+var tokensServerPrivate = require('@tramvai/tokens-server-private');
+var dippy = require('@tinkoff/dippy');
+var errors = require('@tinkoff/errors');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fastifyFormBody__default = /*#__PURE__*/_interopDefaultLegacy(fastifyFormBody);
+
+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;
+                    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: tokensServerPrivate.FASTIFY_REQUEST,
+                        scope: dippy.Scope.REQUEST,
+                        useValue: req,
+                    },
+                    {
+                        provide: tokensServerPrivate.FASTIFY_RESPONSE,
+                        scope: dippy.Scope.REQUEST,
+                        useValue: res,
+                    },
+                ]);
+                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,
+                };
+            });
+        }
+    }, { prefix: baseUrl });
+}
+
+exports.createApi = createApi;

package/lib/modules/papi/papi.browser.browser.js

@@ -0,0 +1,13 @@
+import { __decorate } from 'tslib';
+import { Module } from '@tramvai/core';
+import { sharedProviders } from './shared.browser.js';
+
+let BrowserPapiModule = class BrowserPapiModule {
+};
+BrowserPapiModule = __decorate([
+    Module({
+        providers: [...sharedProviders],
+    })
+], BrowserPapiModule);
+
+export { BrowserPapiModule };

package/lib/modules/papi/papi.browser.es.js

@@ -0,0 +1,13 @@
+import { __decorate } from 'tslib';
+import { Module } from '@tramvai/core';
+import { sharedProviders } from './shared.es.js';
+
+let BrowserPapiModule = class BrowserPapiModule {
+};
+BrowserPapiModule = __decorate([
+    Module({
+        providers: [...sharedProviders],
+    })
+], BrowserPapiModule);
+
+export { BrowserPapiModule };

package/lib/modules/papi/papi.browser.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('@tramvai/core');
+var shared = require('./shared.js');
+
+exports.BrowserPapiModule = class BrowserPapiModule {
+};
+exports.BrowserPapiModule = tslib.__decorate([
+    core.Module({
+        providers: [...shared.sharedProviders],
+    })
+], exports.BrowserPapiModule);

package/lib/modules/papi/papi.es.js

@@ -0,0 +1,111 @@
+import { __decorate } from 'tslib';
+import flatten from '@tinkoff/utils/array/flatten';
+import { Module, provide, DI_TOKEN } from '@tramvai/core';
+import toArray from '@tinkoff/utils/array/toArray';
+import { LOGGER_TOKEN, ENV_MANAGER_TOKEN } from '@tramvai/tokens-common';
+import { SERVER_MODULE_PAPI_PRIVATE_ROUTE, SERVER_MODULE_PAPI_PUBLIC_ROUTE, SERVER_MODULE_PAPI_PRIVATE_URL, SERVER_MODULE_PAPI_PUBLIC_URL } from '@tramvai/tokens-server';
+import { WEB_FASTIFY_APP_BEFORE_INIT_TOKEN } from '@tramvai/tokens-server-private';
+import { createPapiMethod, getPapiParameters } from '@tramvai/papi';
+import { createApi } from './api/index.es.js';
+import { fileApiProvider } from './server/fileApi.es.js';
+import { sharedProviders } from './shared.es.js';
+import { papiExecutorProvider } from './server/executor.es.js';
+
+let ServerPapiModule = class ServerPapiModule {
+};
+ServerPapiModule = __decorate([
+    Module({
+        providers: [
+            papiExecutorProvider,
+            fileApiProvider,
+            ...sharedProviders,
+            provide({
+                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',
+                            path: '/papi-list',
+                            async handler() {
+                                return [
+                                    ...flatten(privateRoutes).map((papi) => {
+                                        const params = getPapiParameters(papi);
+                                        return {
+                                            path: params.path,
+                                            method: params.method,
+                                            options: params.options,
+                                            type: 'private',
+                                        };
+                                    }),
+                                    ...flatten(publicRoutes).map((papi) => {
+                                        const params = getPapiParameters(papi);
+                                        return {
+                                            path: params.path,
+                                            method: params.method,
+                                            options: params.options,
+                                            type: 'public',
+                                        };
+                                    }),
+                                ];
+                            },
+                        });
+                        // eslint-disable-next-line no-param-reassign
+                        privateRoutes = privateRoutes
+                            ? [...toArray(privateRoutes), papiListRoute]
+                            : [papiListRoute];
+                    }
+                    if (privateRoutes) {
+                        createApi(app, flatten(privateRoutes), {
+                            baseUrl: privateBaseUrl,
+                            di,
+                            logger,
+                        });
+                    }
+                    if (publicRoutes) {
+                        createApi(app, flatten(publicRoutes), {
+                            baseUrl: publicBaseUrl,
+                            di,
+                            logger,
+                        });
+                    }
+                },
+                deps: {
+                    di: DI_TOKEN,
+                    logger: LOGGER_TOKEN,
+                    privateRoutes: {
+                        token: SERVER_MODULE_PAPI_PRIVATE_ROUTE,
+                        optional: true,
+                        multi: true,
+                    },
+                    publicRoutes: {
+                        token: SERVER_MODULE_PAPI_PUBLIC_ROUTE,
+                        optional: true,
+                        multi: true,
+                    },
+                    privateBaseUrl: SERVER_MODULE_PAPI_PRIVATE_URL,
+                    publicBaseUrl: SERVER_MODULE_PAPI_PUBLIC_URL,
+                },
+                multi: true,
+            }),
+            // необходимо для утилит. Подумать как можно убрать в будующем. Если убрать не будет ломающим изменением
+            provide({
+                provide: SERVER_MODULE_PAPI_PUBLIC_ROUTE,
+                multi: true,
+                useValue: createPapiMethod({
+                    method: 'get',
+                    path: '/version',
+                    async handler() {
+                        return {
+                            version: this.deps.envManager.get('APP_VERSION'),
+                        };
+                    },
+                    deps: {
+                        envManager: ENV_MANAGER_TOKEN,
+                    },
+                }),
+            }),
+        ],
+    })
+], ServerPapiModule);
+
+export { ServerPapiModule };

package/lib/modules/papi/papi.js

@@ -0,0 +1,118 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var flatten = require('@tinkoff/utils/array/flatten');
+var core = require('@tramvai/core');
+var toArray = require('@tinkoff/utils/array/toArray');
+var tokensCommon = require('@tramvai/tokens-common');
+var tokensServer = require('@tramvai/tokens-server');
+var tokensServerPrivate = require('@tramvai/tokens-server-private');
+var papi = require('@tramvai/papi');
+var index = require('./api/index.js');
+var fileApi = require('./server/fileApi.js');
+var shared = require('./shared.js');
+var executor = require('./server/executor.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten);
+var toArray__default = /*#__PURE__*/_interopDefaultLegacy(toArray);
+
+exports.ServerPapiModule = class ServerPapiModule {
+};
+exports.ServerPapiModule = tslib.__decorate([
+    core.Module({
+        providers: [
+            executor.papiExecutorProvider,
+            fileApi.fileApiProvider,
+            ...shared.sharedProviders,
+            core.provide({
+                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',
+                            path: '/papi-list',
+                            async handler() {
+                                return [
+                                    ...flatten__default["default"](privateRoutes).map((papi$1) => {
+                                        const params = papi.getPapiParameters(papi$1);
+                                        return {
+                                            path: params.path,
+                                            method: params.method,
+                                            options: params.options,
+                                            type: 'private',
+                                        };
+                                    }),
+                                    ...flatten__default["default"](publicRoutes).map((papi$1) => {
+                                        const params = papi.getPapiParameters(papi$1);
+                                        return {
+                                            path: params.path,
+                                            method: params.method,
+                                            options: params.options,
+                                            type: 'public',
+                                        };
+                                    }),
+                                ];
+                            },
+                        });
+                        // eslint-disable-next-line no-param-reassign
+                        privateRoutes = privateRoutes
+                            ? [...toArray__default["default"](privateRoutes), papiListRoute]
+                            : [papiListRoute];
+                    }
+                    if (privateRoutes) {
+                        index.createApi(app, flatten__default["default"](privateRoutes), {
+                            baseUrl: privateBaseUrl,
+                            di,
+                            logger,
+                        });
+                    }
+                    if (publicRoutes) {
+                        index.createApi(app, flatten__default["default"](publicRoutes), {
+                            baseUrl: publicBaseUrl,
+                            di,
+                            logger,
+                        });
+                    }
+                },
+                deps: {
+                    di: core.DI_TOKEN,
+                    logger: tokensCommon.LOGGER_TOKEN,
+                    privateRoutes: {
+                        token: tokensServer.SERVER_MODULE_PAPI_PRIVATE_ROUTE,
+                        optional: true,
+                        multi: true,
+                    },
+                    publicRoutes: {
+                        token: tokensServer.SERVER_MODULE_PAPI_PUBLIC_ROUTE,
+                        optional: true,
+                        multi: true,
+                    },
+                    privateBaseUrl: tokensServer.SERVER_MODULE_PAPI_PRIVATE_URL,
+                    publicBaseUrl: tokensServer.SERVER_MODULE_PAPI_PUBLIC_URL,
+                },
+                multi: true,
+            }),
+            // необходимо для утилит. Подумать как можно убрать в будующем. Если убрать не будет ломающим изменением
+            core.provide({
+                provide: tokensServer.SERVER_MODULE_PAPI_PUBLIC_ROUTE,
+                multi: true,
+                useValue: papi.createPapiMethod({
+                    method: 'get',
+                    path: '/version',
+                    async handler() {
+                        return {
+                            version: this.deps.envManager.get('APP_VERSION'),
+                        };
+                    },
+                    deps: {
+                        envManager: tokensCommon.ENV_MANAGER_TOKEN,
+                    },
+                }),
+            }),
+        ],
+    })
+], exports.ServerPapiModule);

package/lib/modules/papi/server/executor.es.js

@@ -0,0 +1,39 @@
+import { provide, Scope, DI_TOKEN } from '@tinkoff/dippy';
+import { getPapiParameters } from '@tramvai/papi';
+import { LOGGER_TOKEN, REQUEST_MANAGER_TOKEN, RESPONSE_MANAGER_TOKEN } from '@tramvai/tokens-common';
+import { PAPI_EXECUTOR, FASTIFY_REQUEST } from '@tramvai/tokens-server-private';
+
+const papiExecutorProvider = provide({
+    provide: PAPI_EXECUTOR,
+    scope: 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) => {
+            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,
+    },
+});
+
+export { papiExecutorProvider };

package/lib/modules/papi/server/executor.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dippy = require('@tinkoff/dippy');
+var papi = require('@tramvai/papi');
+var tokensCommon = require('@tramvai/tokens-common');
+var tokensServerPrivate = require('@tramvai/tokens-server-private');
+
+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: tokensServerPrivate.FASTIFY_REQUEST,
+        requestManager: tokensCommon.REQUEST_MANAGER_TOKEN,
+        responseManager: tokensCommon.RESPONSE_MANAGER_TOKEN,
+    },
+});
+
+exports.papiExecutorProvider = papiExecutorProvider;

package/lib/modules/papi/server/fileApi.es.js

@@ -0,0 +1,44 @@
+import eachObj from '@tinkoff/utils/object/each';
+import { LOGGER_TOKEN } from '@tramvai/tokens-common';
+import { SERVER_MODULE_PAPI_PUBLIC_ROUTE } from '@tramvai/tokens-server';
+import { isPapiMethod, getPapiParameters, createPapiMethod } from '@tramvai/papi';
+
+let papis;
+try {
+    // eslint-disable-next-line import/no-extraneous-dependencies
+    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: 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
+change settings serverApiDir in tramvai.json`,
+            });
+            throw new Error('Not a papi');
+        }
+        const papiParameters = getPapiParameters(entry);
+        result.push(createPapiMethod({
+            ...papiParameters,
+            path: `/${path}`,
+        }));
+    }, papis);
+    return result;
+};
+const fileApiProvider = {
+    provide: SERVER_MODULE_PAPI_PUBLIC_ROUTE,
+    multi: true,
+    useFactory: getFileApi,
+    deps: {
+        logger: LOGGER_TOKEN,
+    },
+};
+
+export { fileApiProvider };