@naturalcycles/backend-lib 2.73.2 → 3.2.0

package/src/admin/base.admin.service.ts

@@ -1,8 +1,7 @@
 import { _assert, Admin401ErrorData, Admin403ErrorData, HttpError } from '@naturalcycles/js-lib'
 import { dimGrey, green, red } from '@naturalcycles/nodejs-lib/dist/colors'
-import { Request, RequestHandler } from 'express'
 import type * as FirebaseAdmin from 'firebase-admin'
-import { RequestWithLog } from '../server/handlers/createGaeLogMiddleware'
+import { BackendRequest, BackendRequestHandler } from '../server/server.model'
 
 export interface AdminServiceCfg {
   /**
@@ -70,7 +69,7 @@ export class BaseAdminService {
    * To be extended.
    */
   protected async onPermissionCheck(
-    req: RequestWithLog,
+    req: BackendRequest,
     email: string,
     reqPermissions: string[],
     required: boolean,
@@ -85,7 +84,7 @@ export class BaseAdminService {
     )
   }
 
-  async getEmailByToken(req: RequestWithLog, adminToken?: string): Promise<string | undefined> {
+  async getEmailByToken(req: BackendRequest, adminToken?: string): Promise<string | undefined> {
     if (!adminToken) return
 
     try {
@@ -112,7 +111,7 @@ export class BaseAdminService {
    * Current implementation is based on req=Request (from Express).
    * Override if needed.
    */
-  async getAdminToken(req: Request): Promise<string | undefined> {
+  async getAdminToken(req: BackendRequest): Promise<string | undefined> {
     return (
       (req.cookies || {})[this.cfg.adminTokenKey] ||
       req.header(this.cfg.adminTokenKey) ||
@@ -120,13 +119,13 @@ export class BaseAdminService {
     )
   }
 
-  async isAdmin(req: Request): Promise<boolean> {
+  async isAdmin(req: BackendRequest): Promise<boolean> {
     const adminToken = await this.getAdminToken(req)
     const email = await this.getEmailByToken(req, adminToken)
     return !!this.getEmailPermissions(email)
   }
 
-  async getAdminInfo(req: Request): Promise<AdminInfo | undefined> {
+  async getAdminInfo(req: BackendRequest): Promise<AdminInfo | undefined> {
     return await this.hasPermissions(req)
   }
 
@@ -140,7 +139,7 @@ export class BaseAdminService {
    * Otherwise returns undefined
    */
   async hasPermissions(
-    req: Request,
+    req: BackendRequest,
     reqPermissions: string[] = [],
     meta: Record<string, any> = {},
   ): Promise<AdminInfo | undefined> {
@@ -164,7 +163,7 @@ export class BaseAdminService {
   }
 
   async requirePermissions(
-    req: Request,
+    req: BackendRequest,
     reqPermissions: string[] = [],
     meta: Record<string, any> = {},
     andComparison: boolean = true,
@@ -221,7 +220,7 @@ export class BaseAdminService {
 
   // convenience method
   async hasPermission(
-    req: Request,
+    req: BackendRequest,
     reqPermission: string,
     meta?: Record<string, any>,
   ): Promise<boolean> {
@@ -229,7 +228,7 @@ export class BaseAdminService {
   }
 
   async requirePermission(
-    req: Request,
+    req: BackendRequest,
     reqPermission: string,
     meta?: Record<string, any>,
   ): Promise<AdminInfo> {
@@ -245,7 +244,7 @@ export class BaseAdminService {
    *
    * Same endpoint is used to logout, but the `Authentication` header should contain `logout` magic string.
    */
-  getFirebaseAuthLoginHandler(): RequestHandler {
+  getFirebaseAuthLoginHandler(): BackendRequestHandler {
     return async (req, res) => {
       const token = req.header('authentication')
       _assert(token, `401 Unauthenticated`, {

package/src/admin/secureHeader.mw.ts

@@ -1,5 +1,5 @@
 import { Admin401ErrorData, HttpError } from '@naturalcycles/js-lib'
-import { RequestHandler } from 'express'
+import { BackendRequestHandler } from '../server/server.model'
 import { AdminMiddleware, RequireAdminCfg, requireAdminPermissions } from './admin.mw'
 import { BaseAdminService } from './base.admin.service'
 
@@ -19,7 +19,7 @@ export function createSecureHeaderMiddleware(cfg: SecureHeaderMiddlewareCfg): Ad
 function requireSecureHeaderOrAdmin(
   cfg: SecureHeaderMiddlewareCfg,
   reqPermissions?: string[],
-): RequestHandler {
+): BackendRequestHandler {
   const requireAdmin = requireAdminPermissions(cfg.adminService, reqPermissions, cfg)
 
   return async (req, res, next) => {

package/src/db/httpDBRequestHandler.ts

@@ -12,8 +12,7 @@ import {
 } from '@naturalcycles/db-lib/dist/validation'
 import { ObjectWithId } from '@naturalcycles/js-lib'
 import { anyObjectSchema, arraySchema, objectSchema, stringSchema } from '@naturalcycles/nodejs-lib'
-import { Router } from 'express'
-import { getDefaultRouter, reqValidation } from '..'
+import { BackendRouter, getDefaultRouter, reqValidation } from '..'
 
 export interface GetByIdsInput {
   table: string
@@ -52,7 +51,7 @@ const saveBatchInputSchema = objectSchema<SaveBatchInput>({
 /**
  * Exposes CommonDB interface from provided CommonDB as HTTP endpoint (Express RequestHandler).
  */
-export function httpDBRequestHandler(db: CommonDB): Router {
+export function httpDBRequestHandler(db: CommonDB): BackendRouter {
   const router = getDefaultRouter()
 
   // resetCache, only applicable to InMemoryDB

package/src/index.ts

@@ -10,56 +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,
@@ -70,11 +74,16 @@ export type {
   AdminInfo,
   RequireAdminCfg,
   SecureHeaderMiddlewareCfg,
-  BodyParserTimeoutCfg,
-  RequestTimeoutCfg,
-  SimpleRequestLoggerCfg,
+  BodyParserTimeoutMiddlewareCfg,
+  RequestTimeoutMiddlewareCfg,
+  SimpleRequestLoggerMiddlewareCfg,
   ReqValidationOptions,
-  RequestWithLog,
+  BackendRequest,
+  BackendRequestHandler,
+  BackendResponse,
+  BackendErrorRequestHandler,
+  BackendRouter,
+  BackendApplication,
 }
 
 export {
@@ -82,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,16 +63,14 @@ export function createGAELogMiddleware(): RequestHandler {
 
   // Otherwise, we're in AppEngine
 
-  return function gaeLogMiddleware(req, res, next) {
-    const meta: AnyObject = {}
-
+  return function appEngineLogHandler(req, res, next) {
     const traceHeader = req.header('x-cloud-trace-context')
     if (traceHeader) {
       const [trace] = traceHeader.split('/')
-      Object.assign(meta, {
+      const meta = {
         'logging.googleapis.com/trace': `projects/${GOOGLE_CLOUD_PROJECT}/traces/${trace}`,
         'appengine.googleapis.com/request_id': req.header('x-appengine-request-log-id'),
-      })
+      }
       Object.assign(req, {
         log: (...args: any[]) => logToAppEngine({ ...meta, severity: 'INFO' }, args),
         warn: (...args: any[]) => logToAppEngine({ ...meta, severity: 'WARNING' }, args),

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`