@naturalcycles/backend-lib 2.73.3 → 3.3.0

package/dist/server/{handlers/genericErrorHandler.mw.js → genericErrorMiddleware.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.respondWithError = exports.genericErrorHandler = void 0;
+exports.respondWithError = exports.genericErrorMiddleware = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const { APP_ENV } = process.env;
@@ -12,7 +12,7 @@ let sentryService;
  * Returns HTTP code based on err.data.httpStatusCode (default to 500).
  * Sends json payload as ErrorResponse, transformed via errorSharedUtil.
  */
-function genericErrorHandler(cfg = {}) {
+function genericErrorMiddleware(cfg = {}) {
     sentryService || (sentryService = cfg.sentryService);
     return (err, req, res, _next) => {
         // if (res.headersSent) {
@@ -29,14 +29,19 @@ function genericErrorHandler(cfg = {}) {
         respondWithError(req, res, err);
     };
 }
-exports.genericErrorHandler = genericErrorHandler;
+exports.genericErrorMiddleware = genericErrorMiddleware;
 // export interface ResponseWithError extends Response {
 //   __err?: any
 // }
 function respondWithError(req, res, err) {
     var _a, _b;
     const { headersSent } = res;
-    req.error(`genericErrorHandler${headersSent ? ' after headersSent' : ''}:\n`, err);
+    if (headersSent) {
+        req.error(`after headersSent`, err);
+    }
+    else {
+        req.error(err);
+    }
     const originalError = (0, js_lib_1._anyToError)(err, Error, {
         stringifyFn: nodejs_lib_1.inspectAnyStringifyFn,
     });
@@ -58,8 +63,15 @@ function respondWithError(req, res, err) {
 }
 exports.respondWithError = respondWithError;
 function shouldReportToSentry(err) {
-    // Only report 5xx
-    return (err?.data?.report ||
-        !err?.data ||
-        err.data.httpStatusCode >= 500);
+    const e = err;
+    // By default - report
+    if (!e?.data)
+        return true;
+    // If `report` is set - do as it says
+    if (e.data.report === true)
+        return true;
+    if (e.data.report === false)
+        return false;
+    // Report if http 5xx, otherwise not
+    return !e.data.httpStatusCode || e.data.httpStatusCode >= 500;
 }

package/dist/server/getDefaultRouter.d.ts

@@ -1,5 +1,5 @@
-import { RequestHandler, Router } from 'express';
+import { BackendRequestHandler, BackendRouter } from './server.model';
 /**
  * Convenience method.
  */
-export declare function getDefaultRouter(defaultHandlers?: RequestHandler[]): Router;
+export declare function getDefaultRouter(defaultHandlers?: BackendRequestHandler[]): BackendRouter;

package/dist/server/methodOverrideMiddleware.d.ts

@@ -0,0 +1,8 @@
+import { BackendRequestHandler } from './server.model';
+export interface MethodOverrideMiddlewareCfg {
+    /**
+     * @default _method
+     */
+    methodKey?: string;
+}
+export declare function methodOverrideMiddleware(cfg?: MethodOverrideMiddlewareCfg): BackendRequestHandler;

package/dist/server/{handlers/methodOverride.mw.js → methodOverrideMiddleware.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.methodOverride = void 0;
-function methodOverride(cfg = {}) {
+exports.methodOverrideMiddleware = void 0;
+function methodOverrideMiddleware(cfg = {}) {
     const { methodKey } = {
         methodKey: '_method',
         ...cfg,
@@ -14,4 +14,4 @@ function methodOverride(cfg = {}) {
         next();
     };
 }
-exports.methodOverride = methodOverride;
+exports.methodOverrideMiddleware = methodOverrideMiddleware;

package/dist/server/notFoundMiddleware.d.ts

@@ -0,0 +1,2 @@
+import { BackendRequestHandler } from './server.model';
+export declare function notFoundMiddleware(): BackendRequestHandler;

package/dist/server/notFoundMiddleware.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notFoundMiddleware = void 0;
+const request_util_1 = require("./request.util");
+function notFoundMiddleware() {
+    return (req, res) => {
+        res.status(404).send(`404 Not Found: ${(0, request_util_1.getRequestEndpoint)(req)}`);
+    };
+}
+exports.notFoundMiddleware = notFoundMiddleware;

package/dist/server/okMiddleware.d.ts

@@ -0,0 +1,2 @@
+import { BackendRequestHandler } from './server.model';
+export declare function okMiddleware(): BackendRequestHandler;

package/dist/server/{handlers/okHandler.mw.js → okMiddleware.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.okHandler = void 0;
-function okHandler() {
+exports.okMiddleware = void 0;
+function okMiddleware() {
     return (req, res) => {
         res.json({ ok: 1 });
     };
 }
-exports.okHandler = okHandler;
+exports.okMiddleware = okMiddleware;

package/dist/server/{handlers/reqValidation.mw.d.ts → reqValidationMiddleware.d.ts}

@@ -1,5 +1,5 @@
 import { AnySchema, JoiValidationError } from '@naturalcycles/nodejs-lib';
-import { RequestHandler } from 'express';
+import { BackendRequestHandler } from './server.model';
 export interface ReqValidationOptions<ERR extends Error> {
     /**
      * Pass a 'dot-paths' (e.g `pw`, or `input.pw`) that needs to be redacted from the output, in case of error.
@@ -12,4 +12,4 @@ export interface ReqValidationOptions<ERR extends Error> {
      */
     report?: boolean | ((err: ERR) => boolean);
 }
-export declare function reqValidation(reqProperty: 'body' | 'params' | 'query', schema: AnySchema, opt?: ReqValidationOptions<JoiValidationError>): RequestHandler;
+export declare function reqValidation(reqProperty: 'body' | 'params' | 'query', schema: AnySchema, opt?: ReqValidationOptions<JoiValidationError>): BackendRequestHandler;

package/dist/server/request.log.util.d.ts

@@ -1,3 +1,3 @@
-import { Request } from 'express';
-export declare function logRequest(req: Request, statusCode: number, ...tokens: any[]): void;
+import { BackendRequest } from './server.model';
+export declare function logRequest(req: BackendRequest, statusCode: number, ...tokens: any[]): void;
 export declare function coloredHttpCode(statusCode: number): string;

package/dist/server/request.util.d.ts

@@ -1,2 +1,10 @@
-import { Request } from 'express';
-export declare function getRequestEndpoint(req: Request): string;
+import { BackendRequest } from './server.model';
+/**
+ * Returns e.g:
+ *
+ * GET /some/endpoint
+ *
+ * Gets the correct full path when used from sub-router-resources.
+ * Strips away the queryString.
+ */
+export declare function getRequestEndpoint(req: BackendRequest): string;

package/dist/server/request.util.js

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRequestEndpoint = void 0;
+/**
+ * Returns e.g:
+ *
+ * GET /some/endpoint
+ *
+ * Gets the correct full path when used from sub-router-resources.
+ * Strips away the queryString.
+ */
 function getRequestEndpoint(req) {
     let path = (req.baseUrl + (req.route?.path || req.path)).toLowerCase();
     if (path.length > 1 && path.endsWith('/')) {

package/dist/server/requestTimeoutMiddleware.d.ts

@@ -0,0 +1,31 @@
+import { BackendRequest, BackendRequestHandler, BackendResponse } from '../index';
+export interface RequestTimeoutMiddlewareCfg {
+    /**
+     * @default 120
+     */
+    timeoutSeconds?: number;
+    /**
+     * @default 503
+     */
+    httpStatusCode?: number;
+    /**
+     * @default 'Request timed out'
+     */
+    httpErrorMessage?: string;
+}
+export declare function requestTimeoutMiddleware(cfg?: RequestTimeoutMiddlewareCfg): BackendRequestHandler;
+export interface CustomRequestTimeoutMiddlewareCfg {
+    /**
+     * @default 120
+     */
+    timeoutSeconds?: number;
+}
+/**
+ * Example:
+ *
+ * router.get('/', customRequestTimeoutMiddleware(
+ *   (req, res) => res.status(409).send('my custom message!'),
+ *   { timeoutSeconds: 30 },
+ * )
+ */
+export declare function customRequestTimeoutMiddleware(onTimeout: (req: BackendRequest, res: BackendResponse) => void | Promise<void>, cfg: CustomRequestTimeoutMiddlewareCfg): BackendRequestHandler;

package/dist/server/requestTimeoutMiddleware.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customRequestTimeoutMiddleware = exports.requestTimeoutMiddleware = void 0;
+const js_lib_1 = require("@naturalcycles/js-lib");
+const index_1 = require("../index");
+const code = 'REQUEST_TIMEOUT';
+const REQUEST_TIMEOUT_QUERY_KEY = 'requestTimeout';
+function requestTimeoutMiddleware(cfg = {}) {
+    const { timeoutSeconds: defTimeoutSeconds, httpStatusCode, httpErrorMessage, } = {
+        // Considerations about the default value of the timeout.
+        // Ideally the default value here would be HIGHER than the default timeout for getGot (in nodejs-lib),
+        // so, cross-service communication has a chance to fail SOONER than server times out,
+        // so, proper error from exact service is shown, rather than generic "503 request timed out"
+        timeoutSeconds: 120,
+        httpStatusCode: 503,
+        httpErrorMessage: 'Request timed out',
+        ...cfg,
+    };
+    return function requestTimeoutHandler(req, res, next) {
+        const timeoutSeconds = req.query[REQUEST_TIMEOUT_QUERY_KEY]
+            ? Number.parseInt(req.query[REQUEST_TIMEOUT_QUERY_KEY])
+            : defTimeoutSeconds;
+        // If requestTimeout was previously set - cancel it first
+        // Then set the new requestTimeout and handler
+        if (req.requestTimeout)
+            clearTimeout(req.requestTimeout);
+        req.requestTimeout = setTimeout(() => {
+            const endpoint = (0, index_1.getRequestEndpoint)(req);
+            const msg = `${httpErrorMessage} on ${endpoint} after ${(0, js_lib_1._ms)(timeoutSeconds * 1000)}`;
+            (0, index_1.respondWithError)(req, res, new js_lib_1.HttpError(msg, {
+                code,
+                httpStatusCode,
+                endpoint,
+                timeoutSeconds,
+                // userFriendly: true, // no, cause this error is not expected
+            }));
+        }, timeoutSeconds * 1000);
+        (0, index_1.onFinished)(res, () => clearTimeout(req.requestTimeout));
+        next();
+    };
+}
+exports.requestTimeoutMiddleware = requestTimeoutMiddleware;
+/**
+ * Example:
+ *
+ * router.get('/', customRequestTimeoutMiddleware(
+ *   (req, res) => res.status(409).send('my custom message!'),
+ *   { timeoutSeconds: 30 },
+ * )
+ */
+function customRequestTimeoutMiddleware(onTimeout, cfg) {
+    const { timeoutSeconds = 120 } = cfg;
+    return function customRequestTimeoutHandler(req, res, next) {
+        if (req.requestTimeout)
+            clearTimeout(req.requestTimeout);
+        req.requestTimeout = setTimeout(async () => {
+            try {
+                await onTimeout(req, res);
+            }
+            catch (err) {
+                next(err);
+            }
+        }, timeoutSeconds * 1000);
+        (0, index_1.onFinished)(res, () => clearTimeout(req.requestTimeout));
+        next();
+    };
+}
+exports.customRequestTimeoutMiddleware = customRequestTimeoutMiddleware;

package/dist/server/{handlers/safeJsonMiddleware.d.ts → safeJsonMiddleware.d.ts}

@@ -1,8 +1,8 @@
-import { RequestHandler } from 'express';
+import { BackendRequestHandler } from './server.model';
 /**
  * Replaces express's built-in req.json() function with the safe one,
  * protected from circular references.
  *
  * Original: https://github.com/expressjs/express/blob/master/lib/response.js
  */
-export declare function safeJsonMiddleware(): RequestHandler;
+export declare function safeJsonMiddleware(): BackendRequestHandler;

package/dist/server/server.model.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+import { CommonLogFunction } from '@naturalcycles/js-lib';
+import { IRouter, Request, NextFunction, Response, Application } from 'express';
+/**
+ * Use this interface instead of express.Request in cases when TypeScript gives an error, because it haven't "included" this very file.
+ *
+ * It's named like this to avoid clashes with other names.
+ * `BackendRequest` seems to not conflict with anything right now.
+ * Previous name `ExpressRequest` was clashing with Sentry.
+ */
+export interface BackendRequest extends Request {
+    log: CommonLogFunction;
+    warn: CommonLogFunction;
+    error: CommonLogFunction;
+    requestId?: string;
+    /**
+     * Set by requestTimeoutMiddleware.
+     * Can be used to cancel/override the timeout.
+     */
+    requestTimeout?: NodeJS.Timeout;
+    bodyParserTimeout?: NodeJS.Timeout;
+}
+export declare type BackendResponse = Response;
+export declare type BackendRequestHandler = (req: BackendRequest, res: BackendResponse, next: NextFunction) => void;
+export declare type BackendErrorRequestHandler = (err: any, req: BackendRequest, res: BackendResponse, next: NextFunction) => void;
+export declare type BackendRouter = IRouter;
+export declare type BackendApplication = Application;
+declare module 'http' {
+    interface IncomingMessage {
+        log: CommonLogFunction;
+        warn: CommonLogFunction;
+        error: CommonLogFunction;
+        requestId?: string;
+        requestTimeout?: NodeJS.Timeout;
+        bodyParserTimeout?: NodeJS.Timeout;
+    }
+}

package/dist/server/server.model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/serverStatsMiddleware.d.ts

@@ -0,0 +1,13 @@
+import { BackendRequestHandler } from '../index';
+/**
+ * Depends on serverStatsMiddleware to work.
+ *
+ * @example
+ *
+ * router.get('/stats', serverStatsHTMLHandler)
+ */
+export declare const serverStatsHTMLHandler: BackendRequestHandler;
+/**
+ * Unlocks serverStatsHTMLHandler
+ */
+export declare function serverStatsMiddleware(): BackendRequestHandler;

package/dist/server/{handlers/serverStatsMiddleware.js → serverStatsMiddleware.js}

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serverStatsMiddleware = exports.serverStatsHTMLHandler = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
-const index_1 = require("../../index");
-const request_util_1 = require("../request.util");
+const index_1 = require("../index");
+const request_util_1 = require("./request.util");
 const { GAE_INSTANCE } = process.env;
 const serverStatsMap = {};
 const percentiles = [50, 90, 99];

package/dist/server/serverStatusMiddleware.d.ts

@@ -0,0 +1,3 @@
+import { BackendRequestHandler } from './server.model';
+export declare function serverStatusMiddleware(projectDir?: string, extra?: any): BackendRequestHandler;
+export declare function getServerStatusData(projectDir?: string, extra?: any): Record<string, any>;

package/dist/server/{handlers/statusHandler.js → serverStatusMiddleware.js}

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.statusHandlerData = exports.statusHandler = void 0;
+exports.getServerStatusData = exports.serverStatusMiddleware = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const time_lib_1 = require("@naturalcycles/time-lib");
-const deployInfo_util_1 = require("../deployInfo.util");
+const deployInfo_util_1 = require("./deployInfo.util");
 const { versions } = process;
 const { GAE_APPLICATION, GAE_SERVICE, GAE_VERSION, APP_ENV } = process.env;
-function statusHandler(projectDir, extra) {
+function serverStatusMiddleware(projectDir, extra) {
     return async (req, res) => {
-        res.json(statusHandlerData(projectDir, extra));
+        res.json(getServerStatusData(projectDir, extra));
     };
 }
-exports.statusHandler = statusHandler;
-function statusHandlerData(projectDir = process.cwd(), extra) {
+exports.serverStatusMiddleware = serverStatusMiddleware;
+function getServerStatusData(projectDir = process.cwd(), extra) {
     const { gitRev, gitBranch, prod, ts } = (0, deployInfo_util_1.getDeployInfo)(projectDir);
     const deployBuildTimeUTC = time_lib_1.dayjs.unix(ts).toPretty();
     const buildInfo = [time_lib_1.dayjs.unix(ts).toCompactTime(), gitBranch, gitRev].filter(Boolean).join('_');
@@ -33,7 +33,7 @@ function statusHandlerData(projectDir = process.cwd(), extra) {
         ...extra,
     });
 }
-exports.statusHandlerData = statusHandlerData;
+exports.getServerStatusData = getServerStatusData;
 function getStartedStr() {
     const serverStarted = time_lib_1.dayjs.utc().subtract(process.uptime(), 's');
     const s1 = (0, time_lib_1.dayjs)(serverStarted).toPretty();

package/dist/server/simpleRequestLoggerMiddleware.d.ts

@@ -0,0 +1,12 @@
+import { BackendRequestHandler } from '../index';
+export interface SimpleRequestLoggerMiddlewareCfg {
+    /**
+     * @default false
+     */
+    logStart: boolean;
+    /**
+     * @default true
+     */
+    logFinish: boolean;
+}
+export declare function simpleRequestLoggerMiddleware(_cfg?: Partial<SimpleRequestLoggerMiddlewareCfg>): BackendRequestHandler;

package/dist/server/{handlers/simpleRequestLogger.mw.js → simpleRequestLoggerMiddleware.js}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.simpleRequestLogger = void 0;
+exports.simpleRequestLoggerMiddleware = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
 const colors_1 = require("@naturalcycles/nodejs-lib/dist/colors");
-const index_1 = require("../../index");
-const request_log_util_1 = require("../request.log.util");
+const index_1 = require("../index");
+const request_log_util_1 = require("./request.log.util");
 const { APP_ENV } = process.env;
-function simpleRequestLogger(_cfg = {}) {
+function simpleRequestLoggerMiddleware(_cfg = {}) {
     // Disable logger in AppEngine, as it doesn't make sense there
     // UPD: Only log in dev environment
     if (APP_ENV !== 'dev')
@@ -36,4 +36,4 @@ function simpleRequestLogger(_cfg = {}) {
         next();
     };
 }
-exports.simpleRequestLogger = simpleRequestLogger;
+exports.simpleRequestLoggerMiddleware = simpleRequestLoggerMiddleware;

package/dist/server/startServer.model.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
 import { Server } from 'http';
-import { Application } from 'express';
 import { SentrySharedService } from '../sentry/sentry.shared.service';
 import { DefaultAppCfg } from './createDefaultApp.model';
+import { BackendApplication } from './server.model';
 /**
  * If DefaultAppCfg.resources is passed and `expressApp` is not passed - it will call createDefaultApp(cfg).
  */
@@ -11,7 +11,7 @@ export interface StartServerCfg extends DefaultAppCfg {
      * @default process.env.PORT || 8080
      */
     port?: number;
-    expressApp?: Application;
+    expressApp?: BackendApplication;
     /**
      * Server will wait for promise to resolve until shutting down.
      * (with a timeout)

package/dist/server/{handlers/validate.mw.d.ts → validateMiddleware.d.ts}

@@ -1,7 +1,7 @@
 import { JsonSchema, JsonSchemaBuilder } from '@naturalcycles/js-lib';
 import { AjvSchema, AjvValidationError } from '@naturalcycles/nodejs-lib';
-import { RequestHandler } from 'express';
-import { ReqValidationOptions } from './reqValidation.mw';
-export declare function validateBody(schema: JsonSchema | JsonSchemaBuilder | AjvSchema, opt?: ReqValidationOptions<AjvValidationError>): RequestHandler;
-export declare function validateParams(schema: JsonSchema | JsonSchemaBuilder | AjvSchema, opt?: ReqValidationOptions<AjvValidationError>): RequestHandler;
-export declare function validateQuery(schema: JsonSchema | JsonSchemaBuilder | AjvSchema, opt?: ReqValidationOptions<AjvValidationError>): RequestHandler;
+import { BackendRequestHandler } from './server.model';
+import { ReqValidationOptions } from './reqValidationMiddleware';
+export declare function validateBody(schema: JsonSchema | JsonSchemaBuilder | AjvSchema, opt?: ReqValidationOptions<AjvValidationError>): BackendRequestHandler;
+export declare function validateParams(schema: JsonSchema | JsonSchemaBuilder | AjvSchema, opt?: ReqValidationOptions<AjvValidationError>): BackendRequestHandler;
+export declare function validateQuery(schema: JsonSchema | JsonSchemaBuilder | AjvSchema, opt?: ReqValidationOptions<AjvValidationError>): BackendRequestHandler;

package/dist/testing/express.test.service.d.ts

@@ -1,13 +1,13 @@
-import { Application } from 'express';
-import { Got } from '@naturalcycles/nodejs-lib';
-import { RequestHandlerCfg } from '../server/createDefaultApp.model';
+import { GetGotOptions, Got } from '@naturalcycles/nodejs-lib';
+import { BackendApplication } from '../index';
+import { BackendRequestHandlerCfg } from '../server/createDefaultApp.model';
 export interface ExpressApp extends Got {
     close(): Promise<void>;
 }
 declare class ExpressTestService {
-    createAppFromResource(resource: RequestHandlerCfg): ExpressApp;
-    createAppFromResources(resources: RequestHandlerCfg[]): ExpressApp;
-    createApp(app: Application): ExpressApp;
+    createAppFromResource(resource: BackendRequestHandlerCfg, opt?: GetGotOptions): ExpressApp;
+    createAppFromResources(resources: BackendRequestHandlerCfg[], opt?: GetGotOptions): ExpressApp;
+    createApp(app: BackendApplication, opt?: GetGotOptions): ExpressApp;
     /**
      * Creates a "Default Express App" with provided resources.
      * Starts an http server on '127.0.0.1' and random available port.

package/dist/testing/express.test.service.js

@@ -9,17 +9,17 @@ const index_1 = require("../index");
 //   await app.close()
 // })
 class ExpressTestService {
-    createAppFromResource(resource) {
+    createAppFromResource(resource, opt) {
         return this.createApp((0, index_1.createDefaultApp)({
             resources: [resource],
-        }));
+        }), opt);
     }
-    createAppFromResources(resources) {
+    createAppFromResources(resources, opt) {
         return this.createApp((0, index_1.createDefaultApp)({
             resources,
-        }));
+        }), opt);
     }
-    createApp(app) {
+    createApp(app, opt) {
         const server = this.createTestServer(app);
         const { port } = server.address();
         const prefixUrl = `http://127.0.0.1:${port}`;
@@ -27,6 +27,9 @@ class ExpressTestService {
             prefixUrl,
             responseType: 'json',
             retry: 0,
+            logStart: true,
+            logFinished: true,
+            ...opt,
         });
         got.close = async () => {
             await new Promise(resolve => server.close(resolve));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/backend-lib",
-  "version": "2.73.3",
+  "version": "3.3.0",
   "scripts": {
     "prepare": "husky install && patch-package",
     "serve": "APP_ENV=dev nodemon",
@@ -45,7 +45,6 @@
     "@types/ejs": "^3.0.0",
     "@types/js-yaml": "^4.0.0",
     "@types/node": "^16.4.1",
-    "esbuild": "^0.13.13",
     "esbuild-register": "^3.1.2",
     "fastify": "^3.20.1",
     "jest": "^27.0.1",

package/src/admin/admin.mw.ts

@@ -1,7 +1,7 @@
 import * as fs from 'fs'
 import { Admin401ErrorData, HttpError, _memoFn } from '@naturalcycles/js-lib'
 import * as ejs from 'ejs'
-import { RequestHandler } from 'express'
+import { BackendRequestHandler } from '../server/server.model'
 import { BaseAdminService } from './base.admin.service'
 import { FirebaseSharedServiceCfg } from './firebase.shared.service'
 
@@ -26,7 +26,10 @@ export interface RequireAdminCfg {
   autoLogin?: boolean
 }
 
-export type AdminMiddleware = (reqPermissions?: string[], cfg?: RequireAdminCfg) => RequestHandler
+export type AdminMiddleware = (
+  reqPermissions?: string[],
+  cfg?: RequireAdminCfg,
+) => BackendRequestHandler
 
 export function createAdminMiddleware(
   adminService: BaseAdminService,
@@ -49,7 +52,7 @@ export function requireAdminPermissions(
   adminService: BaseAdminService,
   reqPermissions: string[] = [],
   cfg: RequireAdminCfg = {},
-): RequestHandler {
+): BackendRequestHandler {
   const { loginHtmlPath = '/login.html', urlStartsWith, apiHost, autoLogin = true } = cfg
 
   return async (req, res, next) => {
@@ -78,7 +81,7 @@ interface LoginHtmlCfg {
   firebaseAuthProvider: string
 }
 
-export function loginHtml(firebaseServiceCfg: FirebaseSharedServiceCfg): RequestHandler {
+export function loginHtml(firebaseServiceCfg: FirebaseSharedServiceCfg): BackendRequestHandler {
   const {
     apiKey: firebaseApiKey,
     authDomain: firebaseAuthDomain,