@naturalcycles/backend-lib 2.73.3 → 3.0.0

package/src/index.ts

@@ -10,57 +10,60 @@ import { FirebaseSharedService } from './admin/firebase.shared.service'
 import { createSecureHeaderMiddleware, SecureHeaderMiddlewareCfg } from './admin/secureHeader.mw'
 import { BaseEnv } from './env/env.model'
 import { EnvSharedService, EnvSharedServiceCfg } from './env/env.shared.service'
-import { isGAE } from './gae/appEngine.util'
+export * from './gae/appEngine.util'
 import { SentrySharedService, SentrySharedServiceCfg } from './sentry/sentry.shared.service'
-import { catchWrapper } from './server/catchWrapper'
-import { createDefaultApp } from './server/createDefaultApp'
+export * from './server/catchWrapper'
+export * from './server/createDefaultApp'
 import {
   DefaultAppCfg,
-  RequestHandlerCfg,
-  RequestHandlerWithPath,
+  BackendRequestHandlerCfg,
+  BackendRequestHandlerWithPath,
 } from './server/createDefaultApp.model'
-import { getDeployInfo } from './server/deployInfo.util'
-import { getDefaultRouter } from './server/getDefaultRouter'
+export * from './server/deployInfo.util'
+export * from './server/getDefaultRouter'
 import {
-  bodyParserTimeout,
-  BodyParserTimeoutCfg,
+  bodyParserTimeoutMiddleware,
+  BodyParserTimeoutMiddlewareCfg,
   clearBodyParserTimeout,
-} from './server/handlers/bodyParserTimeout.mw'
-import { genericErrorHandler, respondWithError } from './server/handlers/genericErrorHandler.mw'
+} from './server/bodyParserTimeoutMiddleware'
+export * from './server/genericErrorMiddleware'
+export * from './server/serverStatsMiddleware'
 import {
-  serverStatsHTMLHandler,
-  serverStatsMiddleware,
-} from './server/handlers/serverStatsMiddleware'
-import { methodOverride, MethodOverrideCfg } from './server/handlers/methodOverride.mw'
-import { notFoundHandler } from './server/handlers/notFoundHandler.mw'
-import { okHandler } from './server/handlers/okHandler.mw'
-import { requestTimeout, RequestTimeoutCfg } from './server/handlers/requestTimeout.mw'
-import { reqValidation, ReqValidationOptions } from './server/handlers/reqValidation.mw'
+  methodOverrideMiddleware,
+  MethodOverrideMiddlewareCfg,
+} from './server/methodOverrideMiddleware'
+export * from './server/notFoundMiddleware'
+export * from './server/okMiddleware'
+import { RequestTimeoutMiddlewareCfg } from './server/requestTimeoutMiddleware'
+export * from './server/requestTimeoutMiddleware'
+import { reqValidation, ReqValidationOptions } from './server/reqValidationMiddleware'
 import {
-  simpleRequestLogger,
-  SimpleRequestLoggerCfg,
-} from './server/handlers/simpleRequestLogger.mw'
-import { statusHandler, statusHandlerData } from './server/handlers/statusHandler'
-import { validateBody, validateParams, validateQuery } from './server/handlers/validate.mw'
-import { coloredHttpCode, logRequest } from './server/request.log.util'
+  simpleRequestLoggerMiddleware,
+  SimpleRequestLoggerMiddlewareCfg,
+} from './server/simpleRequestLoggerMiddleware'
+import { serverStatusMiddleware, getServerStatusData } from './server/serverStatusMiddleware'
+export * from './server/validateMiddleware'
+export * from './server/request.log.util'
 import { BackendServer, startServer } from './server/startServer'
 import { StartServerCfg, StartServerData } from './server/startServer.model'
-import {
-  createAsyncLocalStorage,
-  getRequest,
-  getRequestLogger,
-  requestLogger,
-} from './server/handlers/asyncLocalStorage.mw'
-import type { RequestWithLog } from './server/handlers/createGaeLogMiddleware'
-export * from './server/handlers/createGaeLogMiddleware'
-import { safeJsonMiddleware } from './server/handlers/safeJsonMiddleware'
+export * from './server/asyncLocalStorageMiddleware'
+import type {
+  BackendRequest,
+  BackendRequestHandler,
+  BackendResponse,
+  BackendErrorRequestHandler,
+  BackendRouter,
+  BackendApplication,
+} from './server/server.model'
+export * from './server/appEngineLogMiddleware'
+export * from './server/safeJsonMiddleware'
 export * from './server/request.util'
 
 export type {
-  MethodOverrideCfg,
+  MethodOverrideMiddlewareCfg,
   SentrySharedServiceCfg,
-  RequestHandlerWithPath,
-  RequestHandlerCfg,
+  BackendRequestHandlerWithPath,
+  BackendRequestHandlerCfg,
   DefaultAppCfg,
   StartServerCfg,
   StartServerData,
@@ -71,11 +74,16 @@ export type {
   AdminInfo,
   RequireAdminCfg,
   SecureHeaderMiddlewareCfg,
-  BodyParserTimeoutCfg,
-  RequestTimeoutCfg,
-  SimpleRequestLoggerCfg,
+  BodyParserTimeoutMiddlewareCfg,
+  RequestTimeoutMiddlewareCfg,
+  SimpleRequestLoggerMiddlewareCfg,
   ReqValidationOptions,
-  RequestWithLog,
+  BackendRequest,
+  BackendRequestHandler,
+  BackendResponse,
+  BackendErrorRequestHandler,
+  BackendRouter,
+  BackendApplication,
 }
 
 export {
@@ -83,39 +91,17 @@ export {
   SentrySharedService,
   EnvSharedService,
   reqValidation,
-  notFoundHandler,
-  genericErrorHandler,
-  methodOverride,
-  createDefaultApp,
+  methodOverrideMiddleware,
   startServer,
-  catchWrapper,
-  getDefaultRouter,
-  isGAE,
-  statusHandler,
-  statusHandlerData,
-  okHandler,
-  getDeployInfo,
+  serverStatusMiddleware,
+  getServerStatusData,
   onFinished,
-  respondWithError,
-  logRequest,
   FirebaseSharedService,
   createAdminMiddleware,
   BaseAdminService,
   loginHtml,
   createSecureHeaderMiddleware,
-  bodyParserTimeout,
+  bodyParserTimeoutMiddleware,
   clearBodyParserTimeout,
-  requestTimeout,
-  simpleRequestLogger,
-  coloredHttpCode,
-  validateBody,
-  validateParams,
-  validateQuery,
-  createAsyncLocalStorage,
-  getRequest,
-  getRequestLogger,
-  requestLogger,
-  serverStatsHTMLHandler,
-  serverStatsMiddleware,
-  safeJsonMiddleware,
+  simpleRequestLoggerMiddleware,
 }

package/src/sentry/sentry.shared.service.ts

@@ -3,8 +3,7 @@ import { inspectAny, inspectAnyStringifyFn } from '@naturalcycles/nodejs-lib'
 import { Severity } from '@sentry/node'
 import type { Breadcrumb, NodeOptions } from '@sentry/node'
 import type * as SentryLib from '@sentry/node'
-import { ErrorRequestHandler, RequestHandler } from 'express'
-import { getRequestLogger } from '../index'
+import { BackendErrorRequestHandler, BackendRequestHandler, getRequestLogger } from '../index'
 
 export interface SentrySharedServiceCfg extends NodeOptions {}
 
@@ -51,7 +50,7 @@ export class SentrySharedService {
    *
    * UPD: to be tested. Without it - request is not enriched and the error is less useful.
    */
-  getRequestHandler(): RequestHandler {
+  getRequestHandler(): BackendRequestHandler {
     return this.sentry().Handlers.requestHandler()
   }
 
@@ -60,7 +59,7 @@ export class SentrySharedService {
    *
    * @deprecated
    */
-  getErrorHandler(): ErrorRequestHandler {
+  getErrorHandler(): BackendErrorRequestHandler {
     return this.sentry().Handlers.errorHandler()
   }
 

package/src/server/{handlers/createGaeLogMiddleware.ts → appEngineLogMiddleware.ts}

@@ -1,29 +1,8 @@
 import { inspect } from 'util'
 import { dimGrey } from '@naturalcycles/nodejs-lib/dist/colors'
 import { inspectAny } from '@naturalcycles/nodejs-lib'
-import { AnyObject, CommonLogFunction, CommonLogger } from '@naturalcycles/js-lib'
-import { Request, RequestHandler } from 'express'
-
-/**
- * Use this interface instead of express.Request in cases when TypeScript gives an error, because it haven't "included" this very file
- */
-export interface RequestWithLog extends Request {
-  log: CommonLogFunction
-  warn: CommonLogFunction
-  error: CommonLogFunction
-
-  requestId?: string
-}
-
-declare module 'http' {
-  interface IncomingMessage {
-    log: CommonLogFunction
-    warn: CommonLogFunction
-    error: CommonLogFunction
-
-    requestId?: string
-  }
-}
+import { AnyObject, CommonLogger } from '@naturalcycles/js-lib'
+import { BackendRequestHandler } from './server.model'
 
 const { GOOGLE_CLOUD_PROJECT, GAE_INSTANCE } = process.env
 const isGAE = !!GAE_INSTANCE
@@ -71,7 +50,7 @@ function logToDev(requestId: string | null, args: any[]): void {
   )
 }
 
-export function createGAELogMiddleware(): RequestHandler {
+export function appEngineLogMiddleware(): BackendRequestHandler {
   if (!isGAE || !GOOGLE_CLOUD_PROJECT) {
     // Local machine, return "simple" logToDev middleware with request numbering
     return function gaeLogMiddlewareDev(req, res, next) {
@@ -84,7 +63,7 @@ export function createGAELogMiddleware(): RequestHandler {
 
   // Otherwise, we're in AppEngine
 
-  return function gaeLogMiddleware(req, res, next) {
+  return function appEngineLogHandler(req, res, next) {
     const traceHeader = req.header('x-cloud-trace-context')
     if (traceHeader) {
       const [trace] = traceHeader.split('/')

package/src/server/{handlers/asyncLocalStorage.mw.ts → asyncLocalStorageMiddleware.ts}

@@ -1,20 +1,20 @@
 import { AsyncLocalStorage } from 'async_hooks'
 import { _lazyValue, CommonLogger } from '@naturalcycles/js-lib'
-import { Request, RequestHandler } from 'express'
-import { gaeLogger, devLogger } from './createGaeLogMiddleware'
+import { BackendRequest, BackendRequestHandler } from './server.model'
+import { gaeLogger, devLogger } from './appEngineLogMiddleware'
 
 const { GAE_INSTANCE } = process.env
 const isGAE = !!GAE_INSTANCE
 
 export interface RequestLocalStorage {
-  req: Request
+  req: BackendRequest
 }
 
 // Singleton, for simplicity
 // Create it lazily (on demand)
 const storage = _lazyValue(() => new AsyncLocalStorage<RequestLocalStorage>())
 
-export function createAsyncLocalStorage(): RequestHandler {
+export function asyncLocalStorageMiddleware(): BackendRequestHandler {
   return (req, res, next) => {
     const store: RequestLocalStorage = {
       req,
@@ -24,7 +24,7 @@ export function createAsyncLocalStorage(): RequestHandler {
   }
 }
 
-export function getRequest(): Request | undefined {
+export function getRequest(): BackendRequest | undefined {
   return storage().getStore()?.req
 }
 

package/src/server/{handlers/bodyParserTimeout.mw.ts → bodyParserTimeoutMiddleware.ts}

@@ -1,8 +1,7 @@
 import { HttpError } from '@naturalcycles/js-lib'
-import { RequestHandler, Request } from 'express'
-import { respondWithError } from '../../index'
+import { BackendRequestHandler, respondWithError } from '../index'
 
-export interface BodyParserTimeoutCfg {
+export interface BodyParserTimeoutMiddlewareCfg {
   /**
    * @default 10
    */
@@ -19,16 +18,14 @@ export interface BodyParserTimeoutCfg {
   httpStatus?: string
 }
 
-interface RequestWithTimeout extends Request {
-  _bodyParserTimeout?: NodeJS.Timeout
-}
-
 const code = 'BODY_PARSER_TIMEOUT'
 
 /**
  * Should be called BEFORE bodyParser
  */
-export function bodyParserTimeout(cfg: BodyParserTimeoutCfg = {}): RequestHandler {
+export function bodyParserTimeoutMiddleware(
+  cfg: BodyParserTimeoutMiddlewareCfg = {},
+): BackendRequestHandler {
   const { timeoutSeconds, httpStatusCode, httpStatus } = {
     timeoutSeconds: 10,
     httpStatusCode: 400,
@@ -38,8 +35,12 @@ export function bodyParserTimeout(cfg: BodyParserTimeoutCfg = {}): RequestHandle
 
   const timeout = timeoutSeconds * 1000
 
-  return (req: RequestWithTimeout, res, next) => {
-    req._bodyParserTimeout = setTimeout(() => {
+  return (req, res, next) => {
+    // If requestTimeout was previously set - cancel it first
+    // Then set the new requestTimeout and handler
+    if (req.bodyParserTimeout) clearTimeout(req.bodyParserTimeout)
+
+    req.bodyParserTimeout = setTimeout(() => {
       respondWithError(
         req,
         res,
@@ -58,9 +59,9 @@ export function bodyParserTimeout(cfg: BodyParserTimeoutCfg = {}): RequestHandle
 /**
  * Should be called AFTER bodyParser
  */
-export function clearBodyParserTimeout(): RequestHandler {
-  return (req: RequestWithTimeout, res, next) => {
-    if (req._bodyParserTimeout) clearTimeout(req._bodyParserTimeout)
+export function clearBodyParserTimeout(): BackendRequestHandler {
+  return (req, res, next) => {
+    clearTimeout(req.bodyParserTimeout!)
     next()
   }
 }

package/src/server/catchWrapper.ts

@@ -1,9 +1,9 @@
-import { RequestHandler } from 'express'
+import { BackendRequestHandler } from './server.model'
 
 // https://strongloop.com/strongblog/async-error-handling-expressjs-es7-promises-generators/
 // https://stackoverflow.com/a/43564267/4919972
 export const catchWrapper =
-  (fn: RequestHandler): RequestHandler =>
+  (fn: BackendRequestHandler): BackendRequestHandler =>
   async (req, res, next) => {
     try {
       // eslint-disable-next-line @typescript-eslint/await-thenable

package/src/server/createDefaultApp.model.ts

@@ -1,15 +1,15 @@
-import { RequestHandler } from 'express'
 import { SentrySharedService } from '../sentry/sentry.shared.service'
+import { BackendRequestHandler } from './server.model'
 
 /**
  * Plain RequestHandler can be provided - then it's mounted to /
  * Otherwise `path` can be provided to specify mounting point.
  */
-export type RequestHandlerCfg = RequestHandler | RequestHandlerWithPath
+export type BackendRequestHandlerCfg = BackendRequestHandler | BackendRequestHandlerWithPath
 
-export interface RequestHandlerWithPath {
+export interface BackendRequestHandlerWithPath {
   path: string
-  handler: RequestHandler
+  handler: BackendRequestHandler
 }
 
 /**
@@ -21,9 +21,9 @@ export interface RequestHandlerWithPath {
  * 4. postHandlers
  */
 export interface DefaultAppCfg {
-  preHandlers?: RequestHandlerCfg[]
-  handlers?: RequestHandlerCfg[]
-  resources?: RequestHandlerCfg[]
-  postHandlers?: RequestHandlerCfg[]
+  preHandlers?: BackendRequestHandlerCfg[]
+  handlers?: BackendRequestHandlerCfg[]
+  resources?: BackendRequestHandlerCfg[]
+  postHandlers?: BackendRequestHandlerCfg[]
   sentryService?: SentrySharedService
 }

package/src/server/createDefaultApp.ts

@@ -1,19 +1,22 @@
 import cookieParser = require('cookie-parser')
 import cors = require('cors')
-import type { Application } from 'express'
 import express = require('express')
-import { isGAE, methodOverride } from '..'
-import { DefaultAppCfg, RequestHandlerCfg, RequestHandlerWithPath } from './createDefaultApp.model'
-import { createAsyncLocalStorage } from './handlers/asyncLocalStorage.mw'
-import { createGAELogMiddleware } from './handlers/createGaeLogMiddleware'
-import { genericErrorHandler } from './handlers/genericErrorHandler.mw'
-import { notFoundHandler } from './handlers/notFoundHandler.mw'
-import { requestTimeout } from './handlers/requestTimeout.mw'
-import { simpleRequestLogger } from './handlers/simpleRequestLogger.mw'
+import { BackendApplication, isGAE, methodOverrideMiddleware } from '..'
+import {
+  DefaultAppCfg,
+  BackendRequestHandlerCfg,
+  BackendRequestHandlerWithPath,
+} from './createDefaultApp.model'
+import { asyncLocalStorageMiddleware } from './asyncLocalStorageMiddleware'
+import { appEngineLogMiddleware } from './appEngineLogMiddleware'
+import { genericErrorMiddleware } from './genericErrorMiddleware'
+import { notFoundMiddleware } from './notFoundMiddleware'
+import { requestTimeoutMiddleware } from './requestTimeoutMiddleware'
+import { simpleRequestLoggerMiddleware } from './simpleRequestLoggerMiddleware'
 
 const isTest = process.env['APP_ENV'] === 'test'
 
-export function createDefaultApp(cfg: DefaultAppCfg): Application {
+export function createDefaultApp(cfg: DefaultAppCfg): BackendApplication {
   const { sentryService } = cfg
 
   const app = express()
@@ -25,10 +28,10 @@ export function createDefaultApp(cfg: DefaultAppCfg): Application {
   // preHandlers
   useHandlers(app, cfg.preHandlers)
 
-  app.use(createGAELogMiddleware())
+  app.use(appEngineLogMiddleware())
 
   if (!isTest) {
-    app.use(createAsyncLocalStorage())
+    app.use(asyncLocalStorageMiddleware())
   }
 
   // The request handler must be the first middleware on the app
@@ -38,13 +41,13 @@ export function createDefaultApp(cfg: DefaultAppCfg): Application {
     app.use(sentryService.getRequestHandler())
   }
 
-  app.use(methodOverride())
-  app.use(requestTimeout())
+  app.use(methodOverrideMiddleware())
+  app.use(requestTimeoutMiddleware())
   // app.use(serverStatsMiddleware()) // disabled by default
   // app.use(bodyParserTimeout()) // removed by default
 
   if (!isGAE() && !isTest) {
-    app.use(simpleRequestLogger())
+    app.use(simpleRequestLoggerMiddleware())
   }
 
   // app.use(safeJsonMiddleware()) // optional
@@ -86,19 +89,19 @@ export function createDefaultApp(cfg: DefaultAppCfg): Application {
   useHandlers(app, cfg.postHandlers)
 
   // Generic 404 handler
-  app.use(notFoundHandler())
+  app.use(notFoundMiddleware())
 
   // Generic error handler
   // It handles errors, returns proper status, does sentry.captureException(),
   // assigns err.data.errorId from sentry
-  app.use(genericErrorHandler({ sentryService }))
+  app.use(genericErrorMiddleware({ sentryService }))
 
   return app
 }
 
-function useHandlers(app: Application, handlers: RequestHandlerCfg[] = []): void {
+function useHandlers(app: BackendApplication, handlers: BackendRequestHandlerCfg[] = []): void {
   handlers
-    .map<RequestHandlerWithPath>(cfg => {
+    .map<BackendRequestHandlerWithPath>(cfg => {
       if (typeof cfg === 'function') {
         return {
           path: '/',

package/src/server/deployInfo.util.ts

@@ -1,6 +1,6 @@
 import * as fs from 'fs'
 import { _memoFn } from '@naturalcycles/js-lib'
-import type { DeployInfo } from '../deploy/deploy.model'
+import type { DeployInfo } from '../deploy'
 
 export const getDeployInfo = _memoFn((projectDir: string): DeployInfo => {
   const deployInfoPath = `${projectDir}/deployInfo.json`

package/src/server/{handlers/genericErrorHandler.mw.ts → genericErrorMiddleware.ts}

@@ -7,11 +7,10 @@ import {
   HttpErrorResponse,
 } from '@naturalcycles/js-lib'
 import { inspectAnyStringifyFn } from '@naturalcycles/nodejs-lib'
-import { ErrorRequestHandler, Response } from 'express'
-import { SentrySharedService } from '../../sentry/sentry.shared.service'
-import { RequestWithLog } from './createGaeLogMiddleware'
+import { SentrySharedService } from '../sentry/sentry.shared.service'
+import { BackendErrorRequestHandler, BackendRequest, BackendResponse } from './server.model'
 
-export interface GenericErrorHandlerCfg {
+export interface GenericErrorMiddlewareCfg {
   sentryService?: SentrySharedService
 }
 
@@ -26,10 +25,12 @@ let sentryService: SentrySharedService | undefined
  * Returns HTTP code based on err.data.httpStatusCode (default to 500).
  * Sends json payload as ErrorResponse, transformed via errorSharedUtil.
  */
-export function genericErrorHandler(cfg: GenericErrorHandlerCfg = {}): ErrorRequestHandler {
+export function genericErrorMiddleware(
+  cfg: GenericErrorMiddlewareCfg = {},
+): BackendErrorRequestHandler {
   sentryService ||= cfg.sentryService
 
-  return (err, req: RequestWithLog, res, _next) => {
+  return (err, req, res, _next) => {
     // if (res.headersSent) {
     // Here we don't even log this error
     // It's known that it comes from sentry.requestHandler()
@@ -49,7 +50,7 @@ export function genericErrorHandler(cfg: GenericErrorHandlerCfg = {}): ErrorRequ
 // export interface ResponseWithError extends Response {
 //   __err?: any
 // }
-export function respondWithError(req: RequestWithLog, res: Response, err: any): void {
+export function respondWithError(req: BackendRequest, res: BackendResponse, err: any): void {
   const { headersSent } = res
 
   req.error(`genericErrorHandler${headersSent ? ' after headersSent' : ''}:\n`, err)
@@ -80,10 +81,15 @@ export function respondWithError(req: RequestWithLog, res: Response, err: any):
 }
 
 function shouldReportToSentry(err: Error): boolean {
-  // Only report 5xx
-  return (
-    (err as HttpError)?.data?.report ||
-    !(err as HttpError)?.data ||
-    (err as HttpError).data.httpStatusCode >= 500
-  )
+  const e = err as HttpError
+
+  // 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/src/server/getDefaultRouter.ts

@@ -1,10 +1,10 @@
-import { RequestHandler, Router } from 'express'
 import PromiseRouter from 'express-promise-router'
+import { BackendRequestHandler, BackendRouter } from './server.model'
 
 /**
  * Convenience method.
  */
-export function getDefaultRouter(defaultHandlers: RequestHandler[] = []): Router {
+export function getDefaultRouter(defaultHandlers: BackendRequestHandler[] = []): BackendRouter {
   const router = PromiseRouter()
 
   // Use default handlers

package/src/server/{handlers/methodOverride.mw.ts → methodOverrideMiddleware.ts}

@@ -1,13 +1,15 @@
-import { RequestHandler } from 'express'
+import { BackendRequestHandler } from './server.model'
 
-export interface MethodOverrideCfg {
+export interface MethodOverrideMiddlewareCfg {
   /**
    * @default _method
    */
   methodKey?: string
 }
 
-export function methodOverride(cfg: MethodOverrideCfg = {}): RequestHandler {
+export function methodOverrideMiddleware(
+  cfg: MethodOverrideMiddlewareCfg = {},
+): BackendRequestHandler {
   const { methodKey } = {
     methodKey: '_method',
     ...cfg,

package/src/server/notFoundMiddleware.ts

@@ -0,0 +1,8 @@
+import { getRequestEndpoint } from './request.util'
+import { BackendRequestHandler } from './server.model'
+
+export function notFoundMiddleware(): BackendRequestHandler {
+  return (req, res) => {
+    res.status(404).send(`404 Not Found: ${getRequestEndpoint(req)}`)
+  }
+}

package/src/server/okMiddleware.ts

@@ -0,0 +1,7 @@
+import { BackendRequestHandler } from './server.model'
+
+export function okMiddleware(): BackendRequestHandler {
+  return (req, res) => {
+    res.json({ ok: 1 })
+  }
+}

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

@@ -1,6 +1,6 @@
 import { HttpError, _get } from '@naturalcycles/js-lib'
 import { AnySchema, getValidationResult, JoiValidationError } from '@naturalcycles/nodejs-lib'
-import { RequestHandler } from 'express'
+import { BackendRequestHandler } from './server.model'
 
 const REDACTED = 'REDACTED'
 
@@ -22,7 +22,7 @@ export function reqValidation(
   reqProperty: 'body' | 'params' | 'query',
   schema: AnySchema,
   opt: ReqValidationOptions<JoiValidationError> = {},
-): RequestHandler {
+): BackendRequestHandler {
   const reportPredicate = typeof opt.report === 'function' ? opt.report : () => !!opt.report
 
   return (req, res, next) => {

package/src/server/request.log.util.ts

@@ -1,8 +1,8 @@
 import { CommonLogLevel } from '@naturalcycles/js-lib'
 import { boldGrey, green, red, yellow } from '@naturalcycles/nodejs-lib/dist/colors'
-import { Request } from 'express'
+import { BackendRequest } from './server.model'
 
-export function logRequest(req: Request, statusCode: number, ...tokens: any[]): void {
+export function logRequest(req: BackendRequest, statusCode: number, ...tokens: any[]): void {
   req[logLevel(statusCode)](
     [coloredHttpCode(statusCode), req.method, boldGrey(req.url), ...tokens].join(' '),
   )

package/src/server/request.util.ts

@@ -1,6 +1,14 @@
-import { Request } from 'express'
+import { BackendRequest } from './server.model'
 
-export function getRequestEndpoint(req: Request): string {
+/**
+ * Returns e.g:
+ *
+ * GET /some/endpoint
+ *
+ * Gets the correct full path when used from sub-router-resources.
+ * Strips away the queryString.
+ */
+export function getRequestEndpoint(req: BackendRequest): string {
   let path = (req.baseUrl + (req.route?.path || req.path)).toLowerCase()
   if (path.length > 1 && path.endsWith('/')) {
     path = path.slice(0, path.length - 1)