@naturalcycles/backend-lib 2.73.1 → 3.1.0

package/dist/admin/admin.mw.d.ts

@@ -1,4 +1,4 @@
-import { RequestHandler } from 'express';
+import { BackendRequestHandler } from '../server/server.model';
 import { BaseAdminService } from './base.admin.service';
 import { FirebaseSharedServiceCfg } from './firebase.shared.service';
 export interface RequireAdminCfg {
@@ -18,7 +18,7 @@ export interface RequireAdminCfg {
      */
     autoLogin?: boolean;
 }
-export declare type AdminMiddleware = (reqPermissions?: string[], cfg?: RequireAdminCfg) => RequestHandler;
+export declare type AdminMiddleware = (reqPermissions?: string[], cfg?: RequireAdminCfg) => BackendRequestHandler;
 export declare function createAdminMiddleware(adminService: BaseAdminService, cfgDefaults?: RequireAdminCfg): AdminMiddleware;
 /**
  * Require Admin permission.
@@ -26,6 +26,6 @@ export declare function createAdminMiddleware(adminService: BaseAdminService, cf
  * If authenticated, but not authorized - will throw 403.
  * Otherwise will just pass.
  */
-export declare function requireAdminPermissions(adminService: BaseAdminService, reqPermissions?: string[], cfg?: RequireAdminCfg): RequestHandler;
-export declare function loginHtml(firebaseServiceCfg: FirebaseSharedServiceCfg): RequestHandler;
+export declare function requireAdminPermissions(adminService: BaseAdminService, reqPermissions?: string[], cfg?: RequireAdminCfg): BackendRequestHandler;
+export declare function loginHtml(firebaseServiceCfg: FirebaseSharedServiceCfg): BackendRequestHandler;
 export declare function getLoginHtmlRedirect(href: string): string;

package/dist/admin/base.admin.service.d.ts

@@ -1,6 +1,5 @@
-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 {
     /**
      * @default 'admin_token'
@@ -36,23 +35,23 @@ export declare class BaseAdminService {
     /**
      * To be extended.
      */
-    protected onPermissionCheck(req: RequestWithLog, email: string, reqPermissions: string[], required: boolean, granted: boolean, meta?: Record<string, any>): Promise<void>;
-    getEmailByToken(req: RequestWithLog, adminToken?: string): Promise<string | undefined>;
+    protected onPermissionCheck(req: BackendRequest, email: string, reqPermissions: string[], required: boolean, granted: boolean, meta?: Record<string, any>): Promise<void>;
+    getEmailByToken(req: BackendRequest, adminToken?: string): Promise<string | undefined>;
     /**
      * Current implementation is based on req=Request (from Express).
      * Override if needed.
      */
-    getAdminToken(req: Request): Promise<string | undefined>;
-    isAdmin(req: Request): Promise<boolean>;
-    getAdminInfo(req: Request): Promise<AdminInfo | undefined>;
+    getAdminToken(req: BackendRequest): Promise<string | undefined>;
+    isAdmin(req: BackendRequest): Promise<boolean>;
+    getAdminInfo(req: BackendRequest): Promise<AdminInfo | undefined>;
     /**
      * Returns AdminInfo if it has all required permissions.
      * Otherwise returns undefined
      */
-    hasPermissions(req: Request, reqPermissions?: string[], meta?: Record<string, any>): Promise<AdminInfo | undefined>;
-    requirePermissions(req: Request, reqPermissions?: string[], meta?: Record<string, any>, andComparison?: boolean): Promise<AdminInfo>;
-    hasPermission(req: Request, reqPermission: string, meta?: Record<string, any>): Promise<boolean>;
-    requirePermission(req: Request, reqPermission: string, meta?: Record<string, any>): Promise<AdminInfo>;
+    hasPermissions(req: BackendRequest, reqPermissions?: string[], meta?: Record<string, any>): Promise<AdminInfo | undefined>;
+    requirePermissions(req: BackendRequest, reqPermissions?: string[], meta?: Record<string, any>, andComparison?: boolean): Promise<AdminInfo>;
+    hasPermission(req: BackendRequest, reqPermission: string, meta?: Record<string, any>): Promise<boolean>;
+    requirePermission(req: BackendRequest, reqPermission: string, meta?: Record<string, any>): Promise<AdminInfo>;
     /**
      * Install it on POST /admin/login url
      *
@@ -62,5 +61,5 @@ export declare class BaseAdminService {
      *
      * Same endpoint is used to logout, but the `Authentication` header should contain `logout` magic string.
      */
-    getFirebaseAuthLoginHandler(): RequestHandler;
+    getFirebaseAuthLoginHandler(): BackendRequestHandler;
 }

package/dist/db/httpDBRequestHandler.d.ts

@@ -1,6 +1,6 @@
 import { CommonDB, CommonDBOptions, CommonDBSaveOptions, DBQuery } from '@naturalcycles/db-lib';
 import { ObjectWithId } from '@naturalcycles/js-lib';
-import { Router } from 'express';
+import { BackendRouter } from '..';
 export interface GetByIdsInput {
     table: string;
     ids: string[];
@@ -20,4 +20,4 @@ export interface SaveBatchInput {
 /**
  * Exposes CommonDB interface from provided CommonDB as HTTP endpoint (Express RequestHandler).
  */
-export declare function httpDBRequestHandler(db: CommonDB): Router;
+export declare function httpDBRequestHandler(db: CommonDB): BackendRouter;

package/dist/index.d.ts

@@ -5,30 +5,32 @@ 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';
-import { DefaultAppCfg, RequestHandlerCfg, RequestHandlerWithPath } from './server/createDefaultApp.model';
-import { getDeployInfo } from './server/deployInfo.util';
-import { getDefaultRouter } from './server/getDefaultRouter';
-import { bodyParserTimeout, BodyParserTimeoutCfg, clearBodyParserTimeout } from './server/handlers/bodyParserTimeout.mw';
-import { genericErrorHandler, respondWithError } from './server/handlers/genericErrorHandler.mw';
-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';
-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';
+export * from './server/catchWrapper';
+export * from './server/createDefaultApp';
+import { DefaultAppCfg, BackendRequestHandlerCfg, BackendRequestHandlerWithPath } from './server/createDefaultApp.model';
+export * from './server/deployInfo.util';
+export * from './server/getDefaultRouter';
+import { bodyParserTimeoutMiddleware, BodyParserTimeoutMiddlewareCfg, clearBodyParserTimeout } from './server/bodyParserTimeoutMiddleware';
+export * from './server/genericErrorMiddleware';
+export * from './server/serverStatsMiddleware';
+import { 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 { 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 type { MethodOverrideCfg, SentrySharedServiceCfg, RequestHandlerWithPath, RequestHandlerCfg, DefaultAppCfg, StartServerCfg, StartServerData, EnvSharedServiceCfg, BaseEnv, AdminMiddleware, AdminServiceCfg, AdminInfo, RequireAdminCfg, SecureHeaderMiddlewareCfg, BodyParserTimeoutCfg, RequestTimeoutCfg, SimpleRequestLoggerCfg, ReqValidationOptions, RequestWithLog, };
-export { BackendServer, SentrySharedService, EnvSharedService, reqValidation, notFoundHandler, genericErrorHandler, methodOverride, createDefaultApp, startServer, catchWrapper, getDefaultRouter, isGAE, statusHandler, statusHandlerData, okHandler, getDeployInfo, onFinished, respondWithError, logRequest, FirebaseSharedService, createAdminMiddleware, BaseAdminService, loginHtml, createSecureHeaderMiddleware, bodyParserTimeout, clearBodyParserTimeout, requestTimeout, simpleRequestLogger, coloredHttpCode, validateBody, validateParams, validateQuery, createAsyncLocalStorage, getRequest, getRequestLogger, requestLogger, serverStatsHTMLHandler, serverStatsMiddleware, 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 { MethodOverrideMiddlewareCfg, SentrySharedServiceCfg, BackendRequestHandlerWithPath, BackendRequestHandlerCfg, DefaultAppCfg, StartServerCfg, StartServerData, EnvSharedServiceCfg, BaseEnv, AdminMiddleware, AdminServiceCfg, AdminInfo, RequireAdminCfg, SecureHeaderMiddlewareCfg, BodyParserTimeoutMiddlewareCfg, RequestTimeoutMiddlewareCfg, SimpleRequestLoggerMiddlewareCfg, ReqValidationOptions, BackendRequest, BackendRequestHandler, BackendResponse, BackendErrorRequestHandler, BackendRouter, BackendApplication, };
+export { BackendServer, SentrySharedService, EnvSharedService, reqValidation, methodOverrideMiddleware, startServer, serverStatusMiddleware, getServerStatusData, onFinished, FirebaseSharedService, createAdminMiddleware, BaseAdminService, loginHtml, createSecureHeaderMiddleware, bodyParserTimeoutMiddleware, clearBodyParserTimeout, simpleRequestLoggerMiddleware, };

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.safeJsonMiddleware = exports.serverStatsMiddleware = exports.serverStatsHTMLHandler = exports.requestLogger = exports.getRequestLogger = exports.getRequest = exports.createAsyncLocalStorage = exports.validateQuery = exports.validateParams = exports.validateBody = exports.coloredHttpCode = exports.simpleRequestLogger = exports.requestTimeout = exports.clearBodyParserTimeout = exports.bodyParserTimeout = exports.createSecureHeaderMiddleware = exports.loginHtml = exports.BaseAdminService = exports.createAdminMiddleware = exports.FirebaseSharedService = exports.logRequest = exports.respondWithError = exports.onFinished = exports.getDeployInfo = exports.okHandler = exports.statusHandlerData = exports.statusHandler = exports.isGAE = exports.getDefaultRouter = exports.catchWrapper = exports.startServer = exports.createDefaultApp = exports.methodOverride = exports.genericErrorHandler = exports.notFoundHandler = exports.reqValidation = exports.EnvSharedService = exports.SentrySharedService = exports.BackendServer = void 0;
+exports.simpleRequestLoggerMiddleware = exports.clearBodyParserTimeout = exports.bodyParserTimeoutMiddleware = exports.createSecureHeaderMiddleware = exports.loginHtml = exports.BaseAdminService = exports.createAdminMiddleware = exports.FirebaseSharedService = exports.onFinished = exports.getServerStatusData = exports.serverStatusMiddleware = exports.startServer = exports.methodOverrideMiddleware = exports.reqValidation = exports.EnvSharedService = exports.SentrySharedService = exports.BackendServer = void 0;
 const tslib_1 = require("tslib");
 const onFinished = require("on-finished");
 exports.onFinished = onFinished;
@@ -15,57 +15,36 @@ const secureHeader_mw_1 = require("./admin/secureHeader.mw");
 Object.defineProperty(exports, "createSecureHeaderMiddleware", { enumerable: true, get: function () { return secureHeader_mw_1.createSecureHeaderMiddleware; } });
 const env_shared_service_1 = require("./env/env.shared.service");
 Object.defineProperty(exports, "EnvSharedService", { enumerable: true, get: function () { return env_shared_service_1.EnvSharedService; } });
-const appEngine_util_1 = require("./gae/appEngine.util");
-Object.defineProperty(exports, "isGAE", { enumerable: true, get: function () { return appEngine_util_1.isGAE; } });
+(0, tslib_1.__exportStar)(require("./gae/appEngine.util"), exports);
 const sentry_shared_service_1 = require("./sentry/sentry.shared.service");
 Object.defineProperty(exports, "SentrySharedService", { enumerable: true, get: function () { return sentry_shared_service_1.SentrySharedService; } });
-const catchWrapper_1 = require("./server/catchWrapper");
-Object.defineProperty(exports, "catchWrapper", { enumerable: true, get: function () { return catchWrapper_1.catchWrapper; } });
-const createDefaultApp_1 = require("./server/createDefaultApp");
-Object.defineProperty(exports, "createDefaultApp", { enumerable: true, get: function () { return createDefaultApp_1.createDefaultApp; } });
-const deployInfo_util_1 = require("./server/deployInfo.util");
-Object.defineProperty(exports, "getDeployInfo", { enumerable: true, get: function () { return deployInfo_util_1.getDeployInfo; } });
-const getDefaultRouter_1 = require("./server/getDefaultRouter");
-Object.defineProperty(exports, "getDefaultRouter", { enumerable: true, get: function () { return getDefaultRouter_1.getDefaultRouter; } });
-const bodyParserTimeout_mw_1 = require("./server/handlers/bodyParserTimeout.mw");
-Object.defineProperty(exports, "bodyParserTimeout", { enumerable: true, get: function () { return bodyParserTimeout_mw_1.bodyParserTimeout; } });
-Object.defineProperty(exports, "clearBodyParserTimeout", { enumerable: true, get: function () { return bodyParserTimeout_mw_1.clearBodyParserTimeout; } });
-const genericErrorHandler_mw_1 = require("./server/handlers/genericErrorHandler.mw");
-Object.defineProperty(exports, "genericErrorHandler", { enumerable: true, get: function () { return genericErrorHandler_mw_1.genericErrorHandler; } });
-Object.defineProperty(exports, "respondWithError", { enumerable: true, get: function () { return genericErrorHandler_mw_1.respondWithError; } });
-const serverStatsMiddleware_1 = require("./server/handlers/serverStatsMiddleware");
-Object.defineProperty(exports, "serverStatsHTMLHandler", { enumerable: true, get: function () { return serverStatsMiddleware_1.serverStatsHTMLHandler; } });
-Object.defineProperty(exports, "serverStatsMiddleware", { enumerable: true, get: function () { return serverStatsMiddleware_1.serverStatsMiddleware; } });
-const methodOverride_mw_1 = require("./server/handlers/methodOverride.mw");
-Object.defineProperty(exports, "methodOverride", { enumerable: true, get: function () { return methodOverride_mw_1.methodOverride; } });
-const notFoundHandler_mw_1 = require("./server/handlers/notFoundHandler.mw");
-Object.defineProperty(exports, "notFoundHandler", { enumerable: true, get: function () { return notFoundHandler_mw_1.notFoundHandler; } });
-const okHandler_mw_1 = require("./server/handlers/okHandler.mw");
-Object.defineProperty(exports, "okHandler", { enumerable: true, get: function () { return okHandler_mw_1.okHandler; } });
-const requestTimeout_mw_1 = require("./server/handlers/requestTimeout.mw");
-Object.defineProperty(exports, "requestTimeout", { enumerable: true, get: function () { return requestTimeout_mw_1.requestTimeout; } });
-const reqValidation_mw_1 = require("./server/handlers/reqValidation.mw");
-Object.defineProperty(exports, "reqValidation", { enumerable: true, get: function () { return reqValidation_mw_1.reqValidation; } });
-const simpleRequestLogger_mw_1 = require("./server/handlers/simpleRequestLogger.mw");
-Object.defineProperty(exports, "simpleRequestLogger", { enumerable: true, get: function () { return simpleRequestLogger_mw_1.simpleRequestLogger; } });
-const statusHandler_1 = require("./server/handlers/statusHandler");
-Object.defineProperty(exports, "statusHandler", { enumerable: true, get: function () { return statusHandler_1.statusHandler; } });
-Object.defineProperty(exports, "statusHandlerData", { enumerable: true, get: function () { return statusHandler_1.statusHandlerData; } });
-const validate_mw_1 = require("./server/handlers/validate.mw");
-Object.defineProperty(exports, "validateBody", { enumerable: true, get: function () { return validate_mw_1.validateBody; } });
-Object.defineProperty(exports, "validateParams", { enumerable: true, get: function () { return validate_mw_1.validateParams; } });
-Object.defineProperty(exports, "validateQuery", { enumerable: true, get: function () { return validate_mw_1.validateQuery; } });
-const request_log_util_1 = require("./server/request.log.util");
-Object.defineProperty(exports, "coloredHttpCode", { enumerable: true, get: function () { return request_log_util_1.coloredHttpCode; } });
-Object.defineProperty(exports, "logRequest", { enumerable: true, get: function () { return request_log_util_1.logRequest; } });
+(0, tslib_1.__exportStar)(require("./server/catchWrapper"), exports);
+(0, tslib_1.__exportStar)(require("./server/createDefaultApp"), exports);
+(0, tslib_1.__exportStar)(require("./server/deployInfo.util"), exports);
+(0, tslib_1.__exportStar)(require("./server/getDefaultRouter"), exports);
+const bodyParserTimeoutMiddleware_1 = require("./server/bodyParserTimeoutMiddleware");
+Object.defineProperty(exports, "bodyParserTimeoutMiddleware", { enumerable: true, get: function () { return bodyParserTimeoutMiddleware_1.bodyParserTimeoutMiddleware; } });
+Object.defineProperty(exports, "clearBodyParserTimeout", { enumerable: true, get: function () { return bodyParserTimeoutMiddleware_1.clearBodyParserTimeout; } });
+(0, tslib_1.__exportStar)(require("./server/genericErrorMiddleware"), exports);
+(0, tslib_1.__exportStar)(require("./server/serverStatsMiddleware"), exports);
+const methodOverrideMiddleware_1 = require("./server/methodOverrideMiddleware");
+Object.defineProperty(exports, "methodOverrideMiddleware", { enumerable: true, get: function () { return methodOverrideMiddleware_1.methodOverrideMiddleware; } });
+(0, tslib_1.__exportStar)(require("./server/notFoundMiddleware"), exports);
+(0, tslib_1.__exportStar)(require("./server/okMiddleware"), exports);
+(0, tslib_1.__exportStar)(require("./server/requestTimeoutMiddleware"), exports);
+const reqValidationMiddleware_1 = require("./server/reqValidationMiddleware");
+Object.defineProperty(exports, "reqValidation", { enumerable: true, get: function () { return reqValidationMiddleware_1.reqValidation; } });
+const simpleRequestLoggerMiddleware_1 = require("./server/simpleRequestLoggerMiddleware");
+Object.defineProperty(exports, "simpleRequestLoggerMiddleware", { enumerable: true, get: function () { return simpleRequestLoggerMiddleware_1.simpleRequestLoggerMiddleware; } });
+const serverStatusMiddleware_1 = require("./server/serverStatusMiddleware");
+Object.defineProperty(exports, "serverStatusMiddleware", { enumerable: true, get: function () { return serverStatusMiddleware_1.serverStatusMiddleware; } });
+Object.defineProperty(exports, "getServerStatusData", { enumerable: true, get: function () { return serverStatusMiddleware_1.getServerStatusData; } });
+(0, tslib_1.__exportStar)(require("./server/validateMiddleware"), exports);
+(0, tslib_1.__exportStar)(require("./server/request.log.util"), exports);
 const startServer_1 = require("./server/startServer");
 Object.defineProperty(exports, "BackendServer", { enumerable: true, get: function () { return startServer_1.BackendServer; } });
 Object.defineProperty(exports, "startServer", { enumerable: true, get: function () { return startServer_1.startServer; } });
-const asyncLocalStorage_mw_1 = require("./server/handlers/asyncLocalStorage.mw");
-Object.defineProperty(exports, "createAsyncLocalStorage", { enumerable: true, get: function () { return asyncLocalStorage_mw_1.createAsyncLocalStorage; } });
-Object.defineProperty(exports, "getRequest", { enumerable: true, get: function () { return asyncLocalStorage_mw_1.getRequest; } });
-Object.defineProperty(exports, "getRequestLogger", { enumerable: true, get: function () { return asyncLocalStorage_mw_1.getRequestLogger; } });
-Object.defineProperty(exports, "requestLogger", { enumerable: true, get: function () { return asyncLocalStorage_mw_1.requestLogger; } });
-(0, tslib_1.__exportStar)(require("./server/handlers/createGaeLogMiddleware"), exports);
-const safeJsonMiddleware_1 = require("./server/handlers/safeJsonMiddleware");
-Object.defineProperty(exports, "safeJsonMiddleware", { enumerable: true, get: function () { return safeJsonMiddleware_1.safeJsonMiddleware; } });
+(0, tslib_1.__exportStar)(require("./server/asyncLocalStorageMiddleware"), exports);
+(0, tslib_1.__exportStar)(require("./server/appEngineLogMiddleware"), exports);
+(0, tslib_1.__exportStar)(require("./server/safeJsonMiddleware"), exports);
+(0, tslib_1.__exportStar)(require("./server/request.util"), exports);

package/dist/sentry/sentry.shared.service.d.ts

@@ -2,7 +2,7 @@ import { CommonLogger } from '@naturalcycles/js-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 { BackendErrorRequestHandler, BackendRequestHandler } from '../index';
 export interface SentrySharedServiceCfg extends NodeOptions {
 }
 export declare class SentrySharedService {
@@ -15,13 +15,13 @@ export declare class SentrySharedService {
      *
      * UPD: to be tested. Without it - request is not enriched and the error is less useful.
      */
-    getRequestHandler(): RequestHandler;
+    getRequestHandler(): BackendRequestHandler;
     /**
      * Currently not recommended, as it's replaced by our custom sentryErrorHandler.
      *
      * @deprecated
      */
-    getErrorHandler(): ErrorRequestHandler;
+    getErrorHandler(): BackendErrorRequestHandler;
     /**
      * For GDPR reasons we never send more information than just User ID.
      */

package/dist/server/appEngineLogMiddleware.d.ts

@@ -0,0 +1,13 @@
+import { CommonLogger } from '@naturalcycles/js-lib';
+import { BackendRequestHandler } from './server.model';
+/**
+ * Logger that logs in AppEngine format.
+ * To be used in outside-of-request situations (otherwise req.log should be used).
+ */
+export declare const gaeLogger: CommonLogger;
+/**
+ * Fancy development logger, to be used in outside-of-request situations
+ * (otherwise req.log should be used).
+ */
+export declare const devLogger: CommonLogger;
+export declare function appEngineLogMiddleware(): BackendRequestHandler;

package/dist/server/{handlers/createGaeLogMiddleware.js → appEngineLogMiddleware.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createGAELogMiddleware = exports.devLogger = exports.gaeLogger = void 0;
+exports.appEngineLogMiddleware = exports.devLogger = exports.gaeLogger = void 0;
 const util_1 = require("util");
 const colors_1 = require("@naturalcycles/nodejs-lib/dist/colors");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
@@ -40,7 +40,7 @@ function logToDev(requestId, args) {
         ...args.map(a => (0, nodejs_lib_1.inspectAny)(a, { includeErrorStack: true, colors: true })),
     ].join(' '));
 }
-function createGAELogMiddleware() {
+function appEngineLogMiddleware() {
     if (!isGAE || !GOOGLE_CLOUD_PROJECT) {
         // Local machine, return "simple" logToDev middleware with request numbering
         return function gaeLogMiddlewareDev(req, res, next) {
@@ -51,15 +51,14 @@ function createGAELogMiddleware() {
         };
     }
     // Otherwise, we're in AppEngine
-    return function gaeLogMiddleware(req, res, next) {
-        const meta = {};
+    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) => logToAppEngine({ ...meta, severity: 'INFO' }, args),
                 warn: (...args) => logToAppEngine({ ...meta, severity: 'WARNING' }, args),
@@ -73,4 +72,4 @@ function createGAELogMiddleware() {
         next();
     };
 }
-exports.createGAELogMiddleware = createGAELogMiddleware;
+exports.appEngineLogMiddleware = appEngineLogMiddleware;

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

@@ -1,10 +1,10 @@
 import { CommonLogger } from '@naturalcycles/js-lib';
-import { Request, RequestHandler } from 'express';
+import { BackendRequest, BackendRequestHandler } from './server.model';
 export interface RequestLocalStorage {
-    req: Request;
+    req: BackendRequest;
 }
-export declare function createAsyncLocalStorage(): RequestHandler;
-export declare function getRequest(): Request;
+export declare function asyncLocalStorageMiddleware(): BackendRequestHandler;
+export declare function getRequest(): BackendRequest | undefined;
 /**
  * It requires both `createAsyncLocalStorage` and `createGAELogMiddleware` to be in use to work.
  *

package/dist/server/{handlers/asyncLocalStorage.mw.js → asyncLocalStorageMiddleware.js}

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requestLogger = exports.getRequestLogger = exports.getRequest = exports.createAsyncLocalStorage = void 0;
+exports.requestLogger = exports.getRequestLogger = exports.getRequest = exports.asyncLocalStorageMiddleware = void 0;
 const async_hooks_1 = require("async_hooks");
 const js_lib_1 = require("@naturalcycles/js-lib");
-const createGaeLogMiddleware_1 = require("./createGaeLogMiddleware");
+const appEngineLogMiddleware_1 = require("./appEngineLogMiddleware");
 const { GAE_INSTANCE } = process.env;
 const isGAE = !!GAE_INSTANCE;
 // Singleton, for simplicity
 // Create it lazily (on demand)
 const storage = (0, js_lib_1._lazyValue)(() => new async_hooks_1.AsyncLocalStorage());
-function createAsyncLocalStorage() {
+function asyncLocalStorageMiddleware() {
     return (req, res, next) => {
         const store = {
             req,
@@ -17,9 +17,9 @@ function createAsyncLocalStorage() {
         storage().run(store, () => next());
     };
 }
-exports.createAsyncLocalStorage = createAsyncLocalStorage;
+exports.asyncLocalStorageMiddleware = asyncLocalStorageMiddleware;
 function getRequest() {
-    return storage().getStore().req;
+    return storage().getStore()?.req;
 }
 exports.getRequest = getRequest;
 /**
@@ -28,7 +28,7 @@ exports.getRequest = getRequest;
  * @experimental
  */
 function getRequestLogger() {
-    return storage().getStore()?.req || (isGAE ? createGaeLogMiddleware_1.gaeLogger : createGaeLogMiddleware_1.devLogger);
+    return storage().getStore()?.req || (isGAE ? appEngineLogMiddleware_1.gaeLogger : appEngineLogMiddleware_1.devLogger);
 }
 exports.getRequestLogger = getRequestLogger;
 /**

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

@@ -1,5 +1,5 @@
-import { RequestHandler } from 'express';
-export interface BodyParserTimeoutCfg {
+import { BackendRequestHandler } from '../index';
+export interface BodyParserTimeoutMiddlewareCfg {
     /**
      * @default 10
      */
@@ -16,8 +16,8 @@ export interface BodyParserTimeoutCfg {
 /**
  * Should be called BEFORE bodyParser
  */
-export declare function bodyParserTimeout(cfg?: BodyParserTimeoutCfg): RequestHandler;
+export declare function bodyParserTimeoutMiddleware(cfg?: BodyParserTimeoutMiddlewareCfg): BackendRequestHandler;
 /**
  * Should be called AFTER bodyParser
  */
-export declare function clearBodyParserTimeout(): RequestHandler;
+export declare function clearBodyParserTimeout(): BackendRequestHandler;

package/dist/server/{handlers/bodyParserTimeout.mw.js → bodyParserTimeoutMiddleware.js}

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearBodyParserTimeout = exports.bodyParserTimeout = void 0;
+exports.clearBodyParserTimeout = exports.bodyParserTimeoutMiddleware = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
-const index_1 = require("../../index");
+const index_1 = require("../index");
 const code = 'BODY_PARSER_TIMEOUT';
 /**
  * Should be called BEFORE bodyParser
  */
-function bodyParserTimeout(cfg = {}) {
+function bodyParserTimeoutMiddleware(cfg = {}) {
     const { timeoutSeconds, httpStatusCode, httpStatus } = {
         timeoutSeconds: 10,
         httpStatusCode: 400,
@@ -16,7 +16,11 @@ function bodyParserTimeout(cfg = {}) {
     };
     const timeout = timeoutSeconds * 1000;
     return (req, res, next) => {
-        req._bodyParserTimeout = setTimeout(() => {
+        // If requestTimeout was previously set - cancel it first
+        // Then set the new requestTimeout and handler
+        if (req.bodyParserTimeout)
+            clearTimeout(req.bodyParserTimeout);
+        req.bodyParserTimeout = setTimeout(() => {
             (0, index_1.respondWithError)(req, res, new js_lib_1.HttpError(httpStatus, {
                 code,
                 httpStatusCode,
@@ -26,14 +30,13 @@ function bodyParserTimeout(cfg = {}) {
         next();
     };
 }
-exports.bodyParserTimeout = bodyParserTimeout;
+exports.bodyParserTimeoutMiddleware = bodyParserTimeoutMiddleware;
 /**
  * Should be called AFTER bodyParser
  */
 function clearBodyParserTimeout() {
     return (req, res, next) => {
-        if (req._bodyParserTimeout)
-            clearTimeout(req._bodyParserTimeout);
+        clearTimeout(req.bodyParserTimeout);
         next();
     };
 }

package/dist/server/catchWrapper.d.ts

@@ -1,2 +1,2 @@
-import { RequestHandler } from 'express';
-export declare const catchWrapper: (fn: RequestHandler) => RequestHandler;
+import { BackendRequestHandler } from './server.model';
+export declare const catchWrapper: (fn: BackendRequestHandler) => BackendRequestHandler;

package/dist/server/createDefaultApp.d.ts

@@ -1,3 +1,3 @@
-import type { Application } from 'express';
+import { BackendApplication } from '..';
 import { DefaultAppCfg } from './createDefaultApp.model';
-export declare function createDefaultApp(cfg: DefaultAppCfg): Application;
+export declare function createDefaultApp(cfg: DefaultAppCfg): BackendApplication;

package/dist/server/createDefaultApp.js

@@ -5,12 +5,12 @@ const cookieParser = require("cookie-parser");
 const cors = require("cors");
 const express = require("express");
 const __1 = require("..");
-const asyncLocalStorage_mw_1 = require("./handlers/asyncLocalStorage.mw");
-const createGaeLogMiddleware_1 = require("./handlers/createGaeLogMiddleware");
-const genericErrorHandler_mw_1 = require("./handlers/genericErrorHandler.mw");
-const notFoundHandler_mw_1 = require("./handlers/notFoundHandler.mw");
-const requestTimeout_mw_1 = require("./handlers/requestTimeout.mw");
-const simpleRequestLogger_mw_1 = require("./handlers/simpleRequestLogger.mw");
+const asyncLocalStorageMiddleware_1 = require("./asyncLocalStorageMiddleware");
+const appEngineLogMiddleware_1 = require("./appEngineLogMiddleware");
+const genericErrorMiddleware_1 = require("./genericErrorMiddleware");
+const notFoundMiddleware_1 = require("./notFoundMiddleware");
+const requestTimeoutMiddleware_1 = require("./requestTimeoutMiddleware");
+const simpleRequestLoggerMiddleware_1 = require("./simpleRequestLoggerMiddleware");
 const isTest = process.env['APP_ENV'] === 'test';
 function createDefaultApp(cfg) {
     const { sentryService } = cfg;
@@ -20,9 +20,9 @@ function createDefaultApp(cfg) {
     app.set('trust proxy', true);
     // preHandlers
     useHandlers(app, cfg.preHandlers);
-    app.use((0, createGaeLogMiddleware_1.createGAELogMiddleware)());
+    app.use((0, appEngineLogMiddleware_1.appEngineLogMiddleware)());
     if (!isTest) {
-        app.use((0, asyncLocalStorage_mw_1.createAsyncLocalStorage)());
+        app.use((0, asyncLocalStorageMiddleware_1.asyncLocalStorageMiddleware)());
     }
     // The request handler must be the first middleware on the app
     if (sentryService) {
@@ -30,12 +30,12 @@ function createDefaultApp(cfg) {
         // which will trigger genericErrorHandler "headers already sent"
         app.use(sentryService.getRequestHandler());
     }
-    app.use((0, __1.methodOverride)());
-    app.use((0, requestTimeout_mw_1.requestTimeout)());
+    app.use((0, __1.methodOverrideMiddleware)());
+    app.use((0, requestTimeoutMiddleware_1.requestTimeoutMiddleware)());
     // app.use(serverStatsMiddleware()) // disabled by default
     // app.use(bodyParserTimeout()) // removed by default
     if (!(0, __1.isGAE)() && !isTest) {
-        app.use((0, simpleRequestLogger_mw_1.simpleRequestLogger)());
+        app.use((0, simpleRequestLoggerMiddleware_1.simpleRequestLoggerMiddleware)());
     }
     // app.use(safeJsonMiddleware()) // optional
     app.use(express.json({ limit: '1mb' }));
@@ -65,11 +65,11 @@ function createDefaultApp(cfg) {
     // postHandlers
     useHandlers(app, cfg.postHandlers);
     // Generic 404 handler
-    app.use((0, notFoundHandler_mw_1.notFoundHandler)());
+    app.use((0, notFoundMiddleware_1.notFoundMiddleware)());
     // Generic error handler
     // It handles errors, returns proper status, does sentry.captureException(),
     // assigns err.data.errorId from sentry
-    app.use((0, genericErrorHandler_mw_1.genericErrorHandler)({ sentryService }));
+    app.use((0, genericErrorMiddleware_1.genericErrorMiddleware)({ sentryService }));
     return app;
 }
 exports.createDefaultApp = createDefaultApp;

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

@@ -1,13 +1,13 @@
-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 declare type RequestHandlerCfg = RequestHandler | RequestHandlerWithPath;
-export interface RequestHandlerWithPath {
+export declare type BackendRequestHandlerCfg = BackendRequestHandler | BackendRequestHandlerWithPath;
+export interface BackendRequestHandlerWithPath {
     path: string;
-    handler: RequestHandler;
+    handler: BackendRequestHandler;
 }
 /**
  * Handlers are used in this order:
@@ -18,9 +18,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/dist/server/deployInfo.util.d.ts

@@ -1,2 +1,2 @@
-import type { DeployInfo } from '../deploy/deploy.model';
+import type { DeployInfo } from '../deploy';
 export declare const getDeployInfo: ((projectDir: string) => DeployInfo) & import("@naturalcycles/js-lib/dist/decorators/memoFn").MemoizedFunction;

package/dist/server/genericErrorMiddleware.d.ts

@@ -0,0 +1,12 @@
+import { SentrySharedService } from '../sentry/sentry.shared.service';
+import { BackendErrorRequestHandler, BackendRequest, BackendResponse } from './server.model';
+export interface GenericErrorMiddlewareCfg {
+    sentryService?: SentrySharedService;
+}
+/**
+ * Generic error handler.
+ * Returns HTTP code based on err.data.httpStatusCode (default to 500).
+ * Sends json payload as ErrorResponse, transformed via errorSharedUtil.
+ */
+export declare function genericErrorMiddleware(cfg?: GenericErrorMiddlewareCfg): BackendErrorRequestHandler;
+export declare function respondWithError(req: BackendRequest, res: BackendResponse, err: any): void;