@naturalcycles/backend-lib 5.1.0 → 5.3.0

package/dist/db/httpDBRequestHandler.js

@@ -49,25 +49,25 @@ function httpDBRequestHandler(db) {
     //
     // })
     // getByIds
-    router.put('/getByIds', (0, __1.reqValidation)('body', getByIdsInputSchema), async (req, res) => {
-        const { table, ids, opt } = req.body;
+    router.put('/getByIds', async (req, res) => {
+        const { table, ids, opt } = __1.validateRequest.body(req, getByIdsInputSchema);
         res.json(await db.getByIds(table, ids, opt));
     });
     // runQuery
-    router.put('/runQuery', (0, __1.reqValidation)('body', runQueryInputSchema), async (req, res) => {
-        const { query, opt } = req.body;
+    router.put('/runQuery', async (req, res) => {
+        const { query, opt } = __1.validateRequest.body(req, runQueryInputSchema);
         const q = db_lib_1.DBQuery.fromPlainObject(query);
         res.json(await db.runQuery(q, opt));
     });
     // runQueryCount
-    router.put('/runQueryCount', (0, __1.reqValidation)('body', runQueryInputSchema), async (req, res) => {
-        const { query, opt } = req.body;
+    router.put('/runQueryCount', async (req, res) => {
+        const { query, opt } = __1.validateRequest.body(req, runQueryInputSchema);
         const q = db_lib_1.DBQuery.fromPlainObject(query);
         res.json(await db.runQueryCount(q, opt));
     });
     // saveBatch
-    router.put('/saveBatch', (0, __1.reqValidation)('body', saveBatchInputSchema), async (req, res) => {
-        const { table, rows, opt } = req.body;
+    router.put('/saveBatch', async (req, res) => {
+        const { table, rows, opt } = __1.validateRequest.body(req, saveBatchInputSchema);
         await db.saveBatch(table, rows, opt);
         res.end();
     });
@@ -77,8 +77,8 @@ function httpDBRequestHandler(db) {
     //   res.json(await db.deleteByIds(table, ids, opt))
     // })
     // deleteByQuery
-    router.put('/deleteByQuery', (0, __1.reqValidation)('body', runQueryInputSchema), async (req, res) => {
-        const { query, opt } = req.body;
+    router.put('/deleteByQuery', async (req, res) => {
+        const { query, opt } = __1.validateRequest.body(req, runQueryInputSchema);
         const q = db_lib_1.DBQuery.fromPlainObject(query);
         res.json(await db.deleteByQuery(q, opt));
     });

package/dist/index.d.ts

@@ -20,11 +20,11 @@ export * from './server/notFoundMiddleware';
 export * from './server/okMiddleware';
 export * from './server/basicAuthMiddleware';
 export * from './server/requestTimeoutMiddleware';
-export * from './server/reqValidationMiddleware';
+export * from './server/validation/validateRequest';
 export * from './server/simpleRequestLoggerMiddleware';
 export * from './server/serverStatusMiddleware';
-export * from './server/validateMiddleware';
-export * from './server/zodValidateMiddleware';
+export * from './server/validation/validateMiddleware';
+export * from './server/validation/zodValidateMiddleware';
 export * from './server/request.log.util';
 export * from './server/startServer';
 export * from './server/startServer.model';

package/dist/index.js

@@ -25,11 +25,11 @@ tslib_1.__exportStar(require("./server/notFoundMiddleware"), exports);
 tslib_1.__exportStar(require("./server/okMiddleware"), exports);
 tslib_1.__exportStar(require("./server/basicAuthMiddleware"), exports);
 tslib_1.__exportStar(require("./server/requestTimeoutMiddleware"), exports);
-tslib_1.__exportStar(require("./server/reqValidationMiddleware"), exports);
+tslib_1.__exportStar(require("./server/validation/validateRequest"), exports);
 tslib_1.__exportStar(require("./server/simpleRequestLoggerMiddleware"), exports);
 tslib_1.__exportStar(require("./server/serverStatusMiddleware"), exports);
-tslib_1.__exportStar(require("./server/validateMiddleware"), exports);
-tslib_1.__exportStar(require("./server/zodValidateMiddleware"), exports);
+tslib_1.__exportStar(require("./server/validation/validateMiddleware"), exports);
+tslib_1.__exportStar(require("./server/validation/zodValidateMiddleware"), exports);
 tslib_1.__exportStar(require("./server/request.log.util"), exports);
 tslib_1.__exportStar(require("./server/startServer"), exports);
 tslib_1.__exportStar(require("./server/startServer.model"), exports);

package/dist/server/genericErrorMiddleware.js

@@ -57,7 +57,6 @@ function respondWithError(req, res, err) {
     // Otherwise, it breaks the _isHttpErrorResponse function check, and error get formatted/detected wrongly
     httpError.data['httpStatusCode'] = httpError.data.backendResponseStatusCode;
     httpError.data.headersSent = headersSent || undefined;
-    httpError.data.report ||= undefined; // set to undefined if false
     (0, js_lib_1._filterUndefinedValues)(httpError.data, true);
     formatError?.(httpError); // Mutates
     res.status(httpError.data.backendResponseStatusCode).json({

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

@@ -1,3 +1,4 @@
+/// <reference types="cookie-parser" />
 /// <reference types="node" />
 import type { CommonLogFunction, Promisable } from '@naturalcycles/js-lib';
 import type { IRouter, Request, NextFunction, Response, Application } from 'express';

package/dist/server/{validateMiddleware.d.ts → validation/validateMiddleware.d.ts}

@@ -1,7 +1,7 @@
 import { JsonSchema, JsonSchemaBuilder } from '@naturalcycles/js-lib';
 import { AjvSchema, AjvValidationError } from '@naturalcycles/nodejs-lib';
-import { ReqValidationOptions } from './reqValidationMiddleware';
-import { BackendRequestHandler } from './server.model';
+import { BackendRequestHandler } from '../server.model';
+import { ReqValidationOptions } from './validateRequest';
 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/server/{validateMiddleware.js → validation/validateMiddleware.js}

@@ -26,7 +26,7 @@ function validateObject(prop, schema, opt = {}) {
     const ajvSchema = nodejs_lib_1.AjvSchema.create(schema, {
         objectName: `request ${prop}`,
     });
-    const reportPredicate = typeof opt.report === 'function' ? opt.report : () => !!opt.report;
+    const reportPredicate = typeof opt.report === 'function' ? opt.report : () => opt.report;
     return (req, res, next) => {
         const error = ajvSchema.getValidationError(req[prop]);
         if (error) {

package/dist/server/{reqValidationMiddleware.d.ts → validation/validateRequest.d.ts}

@@ -1,5 +1,5 @@
 import { AnySchema, JoiValidationError } from '@naturalcycles/nodejs-lib';
-import { BackendRequestHandler } from './server.model';
+import { BackendRequest } 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,11 @@ export interface ReqValidationOptions<ERR extends Error> {
      */
     report?: boolean | ((err: ERR) => boolean);
 }
-export declare function reqValidation(reqProperty: 'body' | 'params' | 'query', schema: AnySchema, opt?: ReqValidationOptions<JoiValidationError>): BackendRequestHandler;
+declare class ValidateRequest {
+    body<T>(req: BackendRequest, schema: AnySchema<T>, opt?: ReqValidationOptions<JoiValidationError>): T;
+    query<T>(req: BackendRequest, schema: AnySchema<T>, opt?: ReqValidationOptions<JoiValidationError>): T;
+    params<T>(req: BackendRequest, schema: AnySchema<T>, opt?: ReqValidationOptions<JoiValidationError>): T;
+    private validate;
+}
+export declare const validateRequest: ValidateRequest;
+export {};

package/dist/server/{reqValidationMiddleware.js → validation/validateRequest.js}

@@ -1,40 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.reqValidation = void 0;
+exports.validateRequest = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
 const REDACTED = 'REDACTED';
-function reqValidation(reqProperty, schema, opt = {}) {
-    const reportPredicate = typeof opt.report === 'function' ? opt.report : () => !!opt.report;
-    return (req, res, next) => {
+/**
+ * Mutates error
+ */
+function redact(redactPaths, obj, error) {
+    redactPaths
+        .map(path => (0, js_lib_1._get)(obj, path))
+        .filter(Boolean)
+        .forEach(secret => {
+        error.message = error.message.replace(secret, REDACTED);
+    });
+}
+class ValidateRequest {
+    body(req, schema, opt = {}) {
+        return this.validate(req, 'body', schema, opt);
+    }
+    query(req, schema, opt = {}) {
+        return this.validate(req, 'query', schema, opt);
+    }
+    params(req, schema, opt = {}) {
+        return this.validate(req, 'params', schema, opt);
+    }
+    validate(req, reqProperty, schema, opt = {}) {
         const { value, error } = (0, nodejs_lib_1.getValidationResult)(req[reqProperty], schema, `request ${reqProperty}`);
         if (error) {
-            const report = reportPredicate(error);
+            let report;
+            if (typeof opt.report === 'boolean') {
+                report = opt.report;
+            }
+            else if (typeof opt.report === 'function') {
+                report = opt.report(error);
+            }
             if (opt.redactPaths) {
                 redact(opt.redactPaths, req[reqProperty], error);
                 error.data.joiValidationErrorItems.length = 0; // clears the array
                 delete error.data.annotation;
             }
-            return next(new js_lib_1.AppError(error.message, {
+            throw new js_lib_1.AppError(error.message, {
                 backendResponseStatusCode: 400,
                 report,
                 ...error.data,
-            }));
+            });
         }
         // mutate req to replace the property with the value, converted by Joi
         req[reqProperty] = value;
-        next();
-    };
-}
-exports.reqValidation = reqValidation;
-/**
- * Mutates error
- */
-function redact(redactPaths, obj, error) {
-    redactPaths
-        .map(path => (0, js_lib_1._get)(obj, path))
-        .filter(Boolean)
-        .forEach(secret => {
-        error.message = error.message.replace(secret, REDACTED);
-    });
+        return value;
+    }
 }
+exports.validateRequest = new ValidateRequest();

package/dist/server/{zodValidateMiddleware.d.ts → validation/zodValidateMiddleware.d.ts}

@@ -1,6 +1,6 @@
 import { ZodSchema, ZodValidationError } from '@naturalcycles/js-lib';
-import { ReqValidationOptions } from './reqValidationMiddleware';
-import { BackendRequestHandler } from './server.model';
+import { BackendRequestHandler } from '../server.model';
+import { ReqValidationOptions } from './validateRequest';
 /**
  * Validates req property (body, params or query).
  * Supports Joi schema or AjvSchema (from nodejs-lib).

package/dist/server/{zodValidateMiddleware.js → validation/zodValidateMiddleware.js}

@@ -10,7 +10,7 @@ const REDACTED = 'REDACTED';
  * Throws http 400 on error.
  */
 function zodReqValidate(prop, schema, opt = {}) {
-    const reportPredicate = typeof opt.report === 'function' ? opt.report : () => !!opt.report;
+    const reportPredicate = typeof opt.report === 'function' ? opt.report : () => opt.report;
     return (req, res, next) => {
         const { error } = (0, js_lib_1.zSafeValidate)(req[prop], schema);
         if (!error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/backend-lib",
-  "version": "5.1.0",
+  "version": "5.3.0",
   "scripts": {
     "prepare": "husky",
     "dev": "APP_ENV=dev nodemon",
@@ -36,7 +36,7 @@
     "yargs": "^17.0.0"
   },
   "devDependencies": {
-    "@naturalcycles/bench-lib": "^1.0.7",
+    "@naturalcycles/bench-lib": "^2.0.0",
     "@naturalcycles/dev-lib": "^13.0.0",
     "@sentry/node": "^7.0.0",
     "@types/ejs": "^3.0.0",

package/src/db/httpDBRequestHandler.ts

@@ -12,7 +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 { BackendRouter, getDefaultRouter, reqValidation } from '..'
+import { BackendRouter, getDefaultRouter, validateRequest } from '..'
 
 export interface GetByIdsInput {
   table: string
@@ -84,28 +84,28 @@ export function httpDBRequestHandler(db: CommonDB): BackendRouter {
   // })
 
   // getByIds
-  router.put('/getByIds', reqValidation('body', getByIdsInputSchema), async (req, res) => {
-    const { table, ids, opt } = req.body as GetByIdsInput
+  router.put('/getByIds', async (req, res) => {
+    const { table, ids, opt } = validateRequest.body(req, getByIdsInputSchema)
     res.json(await db.getByIds(table, ids, opt))
   })
 
   // runQuery
-  router.put('/runQuery', reqValidation('body', runQueryInputSchema), async (req, res) => {
-    const { query, opt } = req.body as RunQueryInput
+  router.put('/runQuery', async (req, res) => {
+    const { query, opt } = validateRequest.body(req, runQueryInputSchema)
     const q = DBQuery.fromPlainObject(query)
     res.json(await db.runQuery(q, opt))
   })
 
   // runQueryCount
-  router.put('/runQueryCount', reqValidation('body', runQueryInputSchema), async (req, res) => {
-    const { query, opt } = req.body as RunQueryInput
+  router.put('/runQueryCount', async (req, res) => {
+    const { query, opt } = validateRequest.body(req, runQueryInputSchema)
     const q = DBQuery.fromPlainObject(query)
     res.json(await db.runQueryCount(q, opt))
   })
 
   // saveBatch
-  router.put('/saveBatch', reqValidation('body', saveBatchInputSchema), async (req, res) => {
-    const { table, rows, opt } = req.body as SaveBatchInput
+  router.put('/saveBatch', async (req, res) => {
+    const { table, rows, opt } = validateRequest.body(req, saveBatchInputSchema)
     await db.saveBatch(table, rows, opt)
     res.end()
   })
@@ -117,8 +117,8 @@ export function httpDBRequestHandler(db: CommonDB): BackendRouter {
   // })
 
   // deleteByQuery
-  router.put('/deleteByQuery', reqValidation('body', runQueryInputSchema), async (req, res) => {
-    const { query, opt } = req.body as RunQueryInput
+  router.put('/deleteByQuery', async (req, res) => {
+    const { query, opt } = validateRequest.body(req, runQueryInputSchema)
     const q = DBQuery.fromPlainObject(query)
     res.json(await db.deleteByQuery(q, opt))
   })

package/src/index.ts

@@ -20,11 +20,11 @@ export * from './server/notFoundMiddleware'
 export * from './server/okMiddleware'
 export * from './server/basicAuthMiddleware'
 export * from './server/requestTimeoutMiddleware'
-export * from './server/reqValidationMiddleware'
+export * from './server/validation/validateRequest'
 export * from './server/simpleRequestLoggerMiddleware'
 export * from './server/serverStatusMiddleware'
-export * from './server/validateMiddleware'
-export * from './server/zodValidateMiddleware'
+export * from './server/validation/validateMiddleware'
+export * from './server/validation/zodValidateMiddleware'
 export * from './server/request.log.util'
 export * from './server/startServer'
 export * from './server/startServer.model'

package/src/server/genericErrorMiddleware.ts

@@ -90,7 +90,6 @@ export function respondWithError(req: BackendRequest, res: BackendResponse, err:
   // Otherwise, it breaks the _isHttpErrorResponse function check, and error get formatted/detected wrongly
   httpError.data['httpStatusCode'] = httpError.data.backendResponseStatusCode
   httpError.data.headersSent = headersSent || undefined
-  httpError.data.report ||= undefined // set to undefined if false
   _filterUndefinedValues(httpError.data, true)
 
   formatError?.(httpError) // Mutates

package/src/server/{validateMiddleware.ts → validation/validateMiddleware.ts}

@@ -1,7 +1,7 @@
 import { JsonSchema, JsonSchemaBuilder, _get, AppError } from '@naturalcycles/js-lib'
 import { AjvSchema, AjvValidationError } from '@naturalcycles/nodejs-lib'
-import { ReqValidationOptions } from './reqValidationMiddleware'
-import { BackendRequestHandler } from './server.model'
+import { BackendRequestHandler } from '../server.model'
+import { ReqValidationOptions } from './validateRequest'
 
 const REDACTED = 'REDACTED'
 
@@ -41,7 +41,8 @@ function validateObject(
     objectName: `request ${prop}`,
   })
 
-  const reportPredicate = typeof opt.report === 'function' ? opt.report : () => !!opt.report
+  const reportPredicate =
+    typeof opt.report === 'function' ? opt.report : () => opt.report as boolean | undefined
 
   return (req, res, next) => {
     const error = ajvSchema.getValidationError(req[prop])

package/src/server/{reqValidationMiddleware.ts → validation/validateRequest.ts}

@@ -1,6 +1,6 @@
 import { _get, AppError } from '@naturalcycles/js-lib'
 import { AnySchema, getValidationResult, JoiValidationError } from '@naturalcycles/nodejs-lib'
-import { BackendRequestHandler } from './server.model'
+import { BackendRequest } from '../server.model'
 
 const REDACTED = 'REDACTED'
 
@@ -18,17 +18,57 @@ export interface ReqValidationOptions<ERR extends Error> {
   report?: boolean | ((err: ERR) => boolean)
 }
 
-export function reqValidation(
-  reqProperty: 'body' | 'params' | 'query',
-  schema: AnySchema,
-  opt: ReqValidationOptions<JoiValidationError> = {},
-): BackendRequestHandler {
-  const reportPredicate = typeof opt.report === 'function' ? opt.report : () => !!opt.report
+/**
+ * Mutates error
+ */
+function redact(redactPaths: string[], obj: any, error: Error): void {
+  redactPaths
+    .map(path => _get(obj, path) as string)
+    .filter(Boolean)
+    .forEach(secret => {
+      error.message = error.message.replace(secret, REDACTED)
+    })
+}
+
+class ValidateRequest {
+  body<T>(
+    req: BackendRequest,
+    schema: AnySchema<T>,
+    opt: ReqValidationOptions<JoiValidationError> = {},
+  ): T {
+    return this.validate(req, 'body', schema, opt)
+  }
+
+  query<T>(
+    req: BackendRequest,
+    schema: AnySchema<T>,
+    opt: ReqValidationOptions<JoiValidationError> = {},
+  ): T {
+    return this.validate(req, 'query', schema, opt)
+  }
 
-  return (req, res, next) => {
+  params<T>(
+    req: BackendRequest,
+    schema: AnySchema<T>,
+    opt: ReqValidationOptions<JoiValidationError> = {},
+  ): T {
+    return this.validate(req, 'params', schema, opt)
+  }
+
+  private validate<T>(
+    req: BackendRequest,
+    reqProperty: 'body' | 'params' | 'query',
+    schema: AnySchema<T>,
+    opt: ReqValidationOptions<JoiValidationError> = {},
+  ): T {
     const { value, error } = getValidationResult(req[reqProperty], schema, `request ${reqProperty}`)
     if (error) {
-      const report = reportPredicate(error)
+      let report: boolean | undefined
+      if (typeof opt.report === 'boolean') {
+        report = opt.report
+      } else if (typeof opt.report === 'function') {
+        report = opt.report(error)
+      }
 
       if (opt.redactPaths) {
         redact(opt.redactPaths, req[reqProperty], error)
@@ -36,29 +76,17 @@ export function reqValidation(
         delete error.data.annotation
       }
 
-      return next(
-        new AppError(error.message, {
-          backendResponseStatusCode: 400,
-          report,
-          ...error.data,
-        }),
-      )
+      throw new AppError(error.message, {
+        backendResponseStatusCode: 400,
+        report,
+        ...error.data,
+      })
     }
 
     // mutate req to replace the property with the value, converted by Joi
     req[reqProperty] = value
-    next()
+    return value
   }
 }
 
-/**
- * Mutates error
- */
-function redact(redactPaths: string[], obj: any, error: Error): void {
-  redactPaths
-    .map(path => _get(obj, path) as string)
-    .filter(Boolean)
-    .forEach(secret => {
-      error.message = error.message.replace(secret, REDACTED)
-    })
-}
+export const validateRequest = new ValidateRequest()

package/src/server/{zodValidateMiddleware.ts → validation/zodValidateMiddleware.ts}

@@ -1,6 +1,6 @@
 import { _get, AppError, ZodSchema, ZodValidationError, zSafeValidate } from '@naturalcycles/js-lib'
-import { ReqValidationOptions } from './reqValidationMiddleware'
-import { BackendRequestHandler } from './server.model'
+import { BackendRequestHandler } from '../server.model'
+import { ReqValidationOptions } from './validateRequest'
 
 const REDACTED = 'REDACTED'
 
@@ -15,7 +15,8 @@ export function zodReqValidate(
   schema: ZodSchema,
   opt: ReqValidationOptions<ZodValidationError<any>> = {},
 ): BackendRequestHandler {
-  const reportPredicate = typeof opt.report === 'function' ? opt.report : () => !!opt.report
+  const reportPredicate =
+    typeof opt.report === 'function' ? opt.report : () => opt.report as boolean | undefined
 
   return (req, res, next) => {
     const { error } = zSafeValidate(req[prop], schema)