@naturalcycles/nodejs-lib 15.8.0 → 15.9.0

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

@@ -1,4 +1,4 @@
 /**
  * CommonLogger that logs to process.stdout directly (bypassing console.log).
  */
-export declare const stdoutLogger: import("@naturalcycles/js-lib/log").CommonLogger;
+export declare const stdoutLogger: any;

package/dist/validation/ajv/ajvSchema.d.ts

@@ -1,10 +1,19 @@
-import { type ValidationFunctionResult } from '@naturalcycles/js-lib';
+import { type ValidationFunction, type ValidationFunctionResult } from '@naturalcycles/js-lib';
 import type { JsonSchema, JsonSchemaBuilder } from '@naturalcycles/js-lib/json-schema';
 import type { Ajv } from 'ajv';
 import { AjvValidationError } from './ajvValidationError.js';
 export interface AjvValidationOptions {
-    objectName?: string;
-    objectId?: string;
+    /**
+     * Defaults to false.
+     *
+     * If set to true - AJV will mutate the input in case it needs to apply transformations
+     * (strip unknown properties, convert types, etc).
+     *
+     * If false - it will deep-clone the input to prevent its mutation. Will return the cloned/mutated object.
+     */
+    mutateInput?: boolean;
+    inputName?: string;
+    inputId?: string;
 }
 export interface AjvSchemaCfg {
     /**
@@ -12,11 +21,7 @@ export interface AjvSchemaCfg {
      * AjvSchema default (not the same as Ajv defaults) parameters
      */
     ajv: Ajv;
-    /**
-     * Dependent schemas to pass to Ajv instance constructor.
-     * Simpler than instantiating and passing ajv instance yourself.
-     */
-    objectName?: string;
+    inputName?: string;
     /**
      * Option of Ajv.
      * If set to true - will mutate your input objects!
@@ -54,7 +59,6 @@ export declare class AjvSchema<T = unknown> {
      */
     static create<T>(schema: JsonSchemaBuilder<T> | JsonSchema<T> | AjvSchema<T>, cfg?: Partial<AjvSchemaCfg>): AjvSchema<T>;
     readonly cfg: AjvSchemaCfg;
-    private getValidateFunction;
     /**
      * It returns the original object just for convenience.
      * Reminder: Ajv will MUTATE your object under 2 circumstances:
@@ -64,6 +68,8 @@ export declare class AjvSchema<T = unknown> {
      * Returned object is always the same object (`===`) that was passed, so it is returned just for convenience.
      */
     validate(input: T, opt?: AjvValidationOptions): T;
-    isValid(input: T): boolean;
+    isValid(input: T, opt?: AjvValidationOptions): boolean;
     getValidationResult(input: T, opt?: AjvValidationOptions): ValidationFunctionResult<T, AjvValidationError>;
+    getValidationFunction(): ValidationFunction<T, AjvValidationError>;
+    private getAJVValidateFunction;
 }

package/dist/validation/ajv/ajvSchema.js

@@ -1,6 +1,6 @@
-import { _isObject, _lazyValue } from '@naturalcycles/js-lib';
+import { _isObject, _lazyValue, } from '@naturalcycles/js-lib';
 import { JsonSchemaAnyBuilder } from '@naturalcycles/js-lib/json-schema';
-import { _filterNullishValues } from '@naturalcycles/js-lib/object';
+import { _deepCopy, _filterNullishValues } from '@naturalcycles/js-lib/object';
 import { _substringBefore } from '@naturalcycles/js-lib/string';
 import { _inspect } from '../../string/inspect.js';
 import { AjvValidationError } from './ajvValidationError.js';
@@ -19,22 +19,11 @@ export class AjvSchema {
             lazy: false,
             ...cfg,
             ajv: cfg.ajv || getAjv(),
-            // ajv:
-            //   cfg.ajv ||
-            //   getAjv({
-            //     schemas: cfg.schemas?.map(s => {
-            //       if (s instanceof AjvSchema) return s.schema
-            //       if (s instanceof JsonSchemaAnyBuilder) return s.build()
-            //       return s as JsonSchema
-            //     }),
-            //     coerceTypes: cfg.coerceTypes || false,
-            //     // verbose: true,
-            //   }),
-            // Auto-detecting "ObjectName" from $id of the schema (e.g "Address.schema.json")
-            objectName: cfg.objectName || (schema.$id ? _substringBefore(schema.$id, '.') : undefined),
+            // Auto-detecting "InputName" from $id of the schema (e.g "Address.schema.json")
+            inputName: cfg.inputName || (schema.$id ? _substringBefore(schema.$id, '.') : undefined),
         };
         if (!cfg.lazy) {
-            this.getValidateFunction(); // compile eagerly
+            this.getAJVValidateFunction(); // compile eagerly
         }
     }
     /**
@@ -64,7 +53,6 @@ export class AjvSchema {
         return new AjvSchema(schema, cfg);
     }
     cfg;
-    getValidateFunction = _lazyValue(() => this.cfg.ajv.compile(this.schema));
     /**
      * It returns the original object just for convenience.
      * Reminder: Ajv will MUTATE your object under 2 circumstances:
@@ -74,32 +62,46 @@ export class AjvSchema {
      * Returned object is always the same object (`===`) that was passed, so it is returned just for convenience.
      */
     validate(input, opt = {}) {
-        const [error, output] = this.getValidationResult(input, opt);
-        if (error)
-            throw error;
+        const [err, output] = this.getValidationResult(input, opt);
+        if (err)
+            throw err;
         return output;
     }
-    isValid(input) {
-        return this.getValidateFunction()(input);
+    isValid(input, opt) {
+        const [err] = this.getValidationResult(input, opt);
+        return !err;
     }
     getValidationResult(input, opt = {}) {
-        if (this.isValid(input))
-            return [null, input];
-        const errors = this.getValidateFunction().errors;
-        const { objectId = _isObject(input) ? input['id'] : undefined, objectName = this.cfg.objectName, } = opt;
-        const name = [objectName || 'Object', objectId].filter(Boolean).join('.');
+        const fn = this.getAJVValidateFunction();
+        const item = opt.mutateInput || typeof input !== 'object' ? input : _deepCopy(input);
+        const valid = fn(item); // mutates item
+        if (valid)
+            return [null, item];
+        const errors = fn.errors;
+        const { inputId = _isObject(input) ? input['id'] : undefined, inputName = this.cfg.inputName || 'Object', } = opt;
+        const dataVar = [inputName, inputId].filter(Boolean).join('.');
         let message = this.cfg.ajv.errorsText(errors, {
-            dataVar: name,
+            dataVar,
             separator,
         });
         const inputStringified = _inspect(input, { maxLen: 4000 });
         message = [message, 'Input: ' + inputStringified].join(separator);
         const err = new AjvValidationError(message, _filterNullishValues({
             errors,
-            objectName,
-            objectId,
+            inputName,
+            inputId,
         }));
-        return [err, input];
+        return [err, item];
     }
+    getValidationFunction() {
+        return (input, opt) => {
+            return this.getValidationResult(input, {
+                mutateInput: opt?.mutateInput,
+                inputName: opt?.inputName,
+                inputId: opt?.inputId,
+            });
+        };
+    }
+    getAJVValidateFunction = _lazyValue(() => this.cfg.ajv.compile(this.schema));
 }
 const separator = '\n';

package/dist/validation/ajv/ajvValidationError.d.ts

@@ -3,8 +3,8 @@ import { AppError } from '@naturalcycles/js-lib/error/error.util.js';
 import type { ErrorObject } from 'ajv';
 export interface AjvValidationErrorData extends ErrorData {
     errors: ErrorObject[];
-    objectName?: string;
-    objectId?: string;
+    inputName?: string;
+    inputId?: string;
 }
 export declare class AjvValidationError extends AppError<AjvValidationErrorData> {
     constructor(message: string, data: AjvValidationErrorData);

package/dist/validation/ajv/getAjv.d.ts

@@ -6,7 +6,7 @@ import { Ajv } from 'ajv';
  * This function should be used as much as possible,
  * to benefit from cached Ajv instance.
  */
-export declare const getAjv: import("@naturalcycles/js-lib/types").Lazy<Ajv>;
+export declare const getAjv: any;
 /**
  * Create Ajv with modified defaults.
  *

package/dist/validation/joi/joi.shared.schemas.d.ts

@@ -10,7 +10,7 @@ export declare const numberSchema: NumberSchema<number>;
 export declare const numberSchemaTyped: <T>() => NumberSchema<T>;
 export declare const integerSchema: NumberSchema<number>;
 export declare const percentageSchema: NumberSchema<number>;
-export declare const dateStringSchema: StringSchema<import("@naturalcycles/js-lib/types").IsoDate>;
+export declare const dateStringSchema: StringSchema<IsoDate>;
 export declare const binarySchema: import("joi").BinarySchema<Buffer<ArrayBufferLike>>;
 export declare const dateObjectSchema: ObjectSchema<any>;
 export declare const dateIntervalStringSchema: StringSchema<string>;

package/dist/validation/joi/joi.validation.error.d.ts

@@ -13,8 +13,8 @@ import type { ValidationErrorItem } from 'joi';
  */
 export interface JoiValidationErrorData extends ErrorData {
     joiValidationErrorItems: ValidationErrorItem[];
-    joiValidationObjectName?: string;
-    joiValidationObjectId?: string;
+    joiValidationInputName?: string;
+    joiValidationInputId?: string;
     /**
      * Error "annotation" is stripped in Error.message.
      * This field contains the "full" annotation.

package/dist/validation/joi/joi.validation.util.d.ts

@@ -1,6 +1,7 @@
-import { type ValidationFunctionResult } from '@naturalcycles/js-lib';
+import { type ValidationFunction, type ValidationFunctionResult } from '@naturalcycles/js-lib';
 import type { AnySchema, ValidationOptions } from 'joi';
 import { JoiValidationError } from './joi.validation.error.js';
+export declare function getJoiValidationFunction<T>(schema: AnySchema<T>): ValidationFunction<T, JoiValidationError>;
 /**
  * Validates with Joi.
  * Throws JoiValidationError if invalid.
@@ -8,7 +9,7 @@ import { JoiValidationError } from './joi.validation.error.js';
  *
  * If `schema` is undefined - returns value as is.
  */
-export declare function validate<T>(input: any, schema?: AnySchema<T>, objectName?: string, opt?: ValidationOptions): T;
+export declare function validate<T>(input: any, schema?: AnySchema<T>, inputName?: string, opt?: ValidationOptions): T;
 /**
  * Validates with Joi.
  * Returns JoiValidationResult with converted value and error (if any).
@@ -18,7 +19,7 @@ export declare function validate<T>(input: any, schema?: AnySchema<T>, objectNam
  *
  * If `schema` is undefined - returns value as is.
  */
-export declare function getValidationResult<T>(input: T, schema?: AnySchema<T>, objectName?: string, options?: ValidationOptions): ValidationFunctionResult<T, JoiValidationError>;
+export declare function getValidationResult<T>(input: T, schema?: AnySchema<T>, inputName?: string, options?: ValidationOptions): ValidationFunctionResult<T, JoiValidationError>;
 /**
  * Convenience function that returns true if !error.
  */

package/dist/validation/joi/joi.validation.util.js

@@ -5,7 +5,8 @@
  *
  * "Converts" mean e.g trims all strings from leading/trailing spaces.
  */
-import { _hb, _isObject } from '@naturalcycles/js-lib';
+import { _hb, _isObject, } from '@naturalcycles/js-lib';
+import { _assert } from '@naturalcycles/js-lib/error/assert.js';
 import { _truncateMiddle } from '@naturalcycles/js-lib/string/string.util.js';
 import { JoiValidationError } from './joi.validation.error.js';
 // Strip colors in production (for e.g Sentry reporting)
@@ -31,6 +32,12 @@ const defaultOptions = {
     //   stack: true,
     // }
 };
+export function getJoiValidationFunction(schema) {
+    return (input, opt) => {
+        _assert(!opt?.mutateInput, 'mutateInput=true is not yet supported with Joi');
+        return getValidationResult(input, schema, opt?.inputName);
+    };
+}
 /**
  * Validates with Joi.
  * Throws JoiValidationError if invalid.
@@ -38,8 +45,8 @@ const defaultOptions = {
  *
  * If `schema` is undefined - returns value as is.
  */
-export function validate(input, schema, objectName, opt = {}) {
-    const [error, returnValue] = getValidationResult(input, schema, objectName, opt);
+export function validate(input, schema, inputName, opt = {}) {
+    const [error, returnValue] = getValidationResult(input, schema, inputName, opt);
     if (error)
         throw error;
     return returnValue;
@@ -53,14 +60,14 @@ export function validate(input, schema, objectName, opt = {}) {
  *
  * If `schema` is undefined - returns value as is.
  */
-export function getValidationResult(input, schema, objectName, options = {}) {
+export function getValidationResult(input, schema, inputName, options = {}) {
     if (!schema)
         return [null, input];
     const { value, error } = schema.validate(input, {
         ...defaultOptions,
         ...options,
     });
-    const err = error ? createError(input, error, objectName) : null;
+    const err = error ? createError(input, error, inputName) : null;
     return [err, value];
 }
 /**
@@ -89,12 +96,12 @@ export function convert(input, schema) {
     const { value } = schema.validate(input, defaultOptions);
     return value;
 }
-function createError(value, err, objectName) {
+function createError(value, err, inputName) {
     const tokens = [];
-    const objectId = _isObject(value) ? value['id'] : undefined;
-    if (objectId || objectName) {
-        objectName ||= value?.constructor?.name;
-        tokens.push('Invalid ' + [objectName, objectId].filter(Boolean).join('.'));
+    const inputId = _isObject(value) ? value['id'] : undefined;
+    if (inputId || inputName) {
+        inputName ||= value?.constructor?.name;
+        tokens.push('Invalid ' + [inputName, inputId].filter(Boolean).join('.'));
     }
     const annotation = err.annotate(stripColors);
     if (annotation.length > 100) {
@@ -117,8 +124,8 @@ function createError(value, err, objectName) {
     const msg = tokens.join('\n');
     const data = {
         joiValidationErrorItems: err.details,
-        ...(objectName && { joiValidationObjectName: objectName }),
-        ...(objectId && { joiValidationObjectId: objectId }),
+        ...(inputName && { joiValidationInputName: inputName }),
+        ...(inputId && { joiValidationInputId: inputId }),
     };
     // Make annotation non-enumerable, to not get it automatically printed,
     // but still accessible

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/nodejs-lib",
   "type": "module",
-  "version": "15.8.0",
+  "version": "15.9.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@types/js-yaml": "^4",
@@ -23,7 +23,7 @@
   },
   "devDependencies": {
     "@types/through2-concurrent": "^2",
-    "@naturalcycles/dev-lib": "19.14.0"
+    "@naturalcycles/dev-lib": "19.22.0"
   },
   "exports": {
     ".": "./dist/index.js",

package/src/validation/ajv/ajvSchema.ts

@@ -1,7 +1,12 @@
-import { _isObject, _lazyValue, type ValidationFunctionResult } from '@naturalcycles/js-lib'
+import {
+  _isObject,
+  _lazyValue,
+  type ValidationFunction,
+  type ValidationFunctionResult,
+} from '@naturalcycles/js-lib'
 import type { JsonSchema, JsonSchemaBuilder } from '@naturalcycles/js-lib/json-schema'
 import { JsonSchemaAnyBuilder } from '@naturalcycles/js-lib/json-schema'
-import { _filterNullishValues } from '@naturalcycles/js-lib/object'
+import { _deepCopy, _filterNullishValues } from '@naturalcycles/js-lib/object'
 import { _substringBefore } from '@naturalcycles/js-lib/string'
 import type { Ajv } from 'ajv'
 import { _inspect } from '../../string/inspect.js'
@@ -9,8 +14,17 @@ import { AjvValidationError } from './ajvValidationError.js'
 import { getAjv } from './getAjv.js'
 
 export interface AjvValidationOptions {
-  objectName?: string
-  objectId?: string
+  /**
+   * Defaults to false.
+   *
+   * If set to true - AJV will mutate the input in case it needs to apply transformations
+   * (strip unknown properties, convert types, etc).
+   *
+   * If false - it will deep-clone the input to prevent its mutation. Will return the cloned/mutated object.
+   */
+  mutateInput?: boolean
+  inputName?: string
+  inputId?: string
 }
 
 export interface AjvSchemaCfg {
@@ -20,13 +34,7 @@ export interface AjvSchemaCfg {
    */
   ajv: Ajv
 
-  /**
-   * Dependent schemas to pass to Ajv instance constructor.
-   * Simpler than instantiating and passing ajv instance yourself.
-   */
-  // schemas?: (JsonSchema | JsonSchemaBuilder | AjvSchema)[]
-
-  objectName?: string
+  inputName?: string
 
   /**
    * Option of Ajv.
@@ -59,23 +67,12 @@ export class AjvSchema<T = unknown> {
       lazy: false,
       ...cfg,
       ajv: cfg.ajv || getAjv(),
-      // ajv:
-      //   cfg.ajv ||
-      //   getAjv({
-      //     schemas: cfg.schemas?.map(s => {
-      //       if (s instanceof AjvSchema) return s.schema
-      //       if (s instanceof JsonSchemaAnyBuilder) return s.build()
-      //       return s as JsonSchema
-      //     }),
-      //     coerceTypes: cfg.coerceTypes || false,
-      //     // verbose: true,
-      //   }),
-      // Auto-detecting "ObjectName" from $id of the schema (e.g "Address.schema.json")
-      objectName: cfg.objectName || (schema.$id ? _substringBefore(schema.$id, '.') : undefined),
+      // Auto-detecting "InputName" from $id of the schema (e.g "Address.schema.json")
+      inputName: cfg.inputName || (schema.$id ? _substringBefore(schema.$id, '.') : undefined),
     }
 
     if (!cfg.lazy) {
-      this.getValidateFunction() // compile eagerly
+      this.getAJVValidateFunction() // compile eagerly
     }
   }
 
@@ -114,8 +111,6 @@ export class AjvSchema<T = unknown> {
 
   readonly cfg: AjvSchemaCfg
 
-  private getValidateFunction = _lazyValue(() => this.cfg.ajv.compile<T>(this.schema))
-
   /**
    * It returns the original object just for convenience.
    * Reminder: Ajv will MUTATE your object under 2 circumstances:
@@ -125,31 +120,37 @@ export class AjvSchema<T = unknown> {
    * Returned object is always the same object (`===`) that was passed, so it is returned just for convenience.
    */
   validate(input: T, opt: AjvValidationOptions = {}): T {
-    const [error, output] = this.getValidationResult(input, opt)
-    if (error) throw error
+    const [err, output] = this.getValidationResult(input, opt)
+    if (err) throw err
     return output
   }
 
-  isValid(input: T): boolean {
-    return this.getValidateFunction()(input)
+  isValid(input: T, opt?: AjvValidationOptions): boolean {
+    const [err] = this.getValidationResult(input, opt)
+    return !err
   }
 
   getValidationResult(
     input: T,
     opt: AjvValidationOptions = {},
   ): ValidationFunctionResult<T, AjvValidationError> {
-    if (this.isValid(input)) return [null, input]
+    const fn = this.getAJVValidateFunction()
+
+    const item = opt.mutateInput || typeof input !== 'object' ? input : _deepCopy(input)
 
-    const errors = this.getValidateFunction().errors!
+    const valid = fn(item) // mutates item
+    if (valid) return [null, item]
+
+    const errors = fn.errors!
 
     const {
-      objectId = _isObject(input) ? (input['id' as keyof T] as any) : undefined,
-      objectName = this.cfg.objectName,
+      inputId = _isObject(input) ? (input['id' as keyof T] as any) : undefined,
+      inputName = this.cfg.inputName || 'Object',
     } = opt
-    const name = [objectName || 'Object', objectId].filter(Boolean).join('.')
+    const dataVar = [inputName, inputId].filter(Boolean).join('.')
 
     let message = this.cfg.ajv.errorsText(errors, {
-      dataVar: name,
+      dataVar,
       separator,
     })
 
@@ -160,12 +161,24 @@ export class AjvSchema<T = unknown> {
       message,
       _filterNullishValues({
         errors,
-        objectName,
-        objectId,
+        inputName,
+        inputId,
       }),
     )
-    return [err, input]
+    return [err, item]
   }
+
+  getValidationFunction(): ValidationFunction<T, AjvValidationError> {
+    return (input, opt) => {
+      return this.getValidationResult(input, {
+        mutateInput: opt?.mutateInput,
+        inputName: opt?.inputName,
+        inputId: opt?.inputId,
+      })
+    }
+  }
+
+  private getAJVValidateFunction = _lazyValue(() => this.cfg.ajv.compile<T>(this.schema))
 }
 
 const separator = '\n'

package/src/validation/ajv/ajvValidationError.ts

@@ -4,8 +4,8 @@ import type { ErrorObject } from 'ajv'
 
 export interface AjvValidationErrorData extends ErrorData {
   errors: ErrorObject[]
-  objectName?: string
-  objectId?: string
+  inputName?: string
+  inputId?: string
 }
 
 export class AjvValidationError extends AppError<AjvValidationErrorData> {

package/src/validation/joi/joi.validation.error.ts

@@ -14,8 +14,8 @@ import type { ValidationErrorItem } from 'joi'
  */
 export interface JoiValidationErrorData extends ErrorData {
   joiValidationErrorItems: ValidationErrorItem[]
-  joiValidationObjectName?: string
-  joiValidationObjectId?: string
+  joiValidationInputName?: string
+  joiValidationInputId?: string
   /**
    * Error "annotation" is stripped in Error.message.
    * This field contains the "full" annotation.

package/src/validation/joi/joi.validation.util.ts

@@ -6,7 +6,13 @@
  * "Converts" mean e.g trims all strings from leading/trailing spaces.
  */
 
-import { _hb, _isObject, type ValidationFunctionResult } from '@naturalcycles/js-lib'
+import {
+  _hb,
+  _isObject,
+  type ValidationFunction,
+  type ValidationFunctionResult,
+} from '@naturalcycles/js-lib'
+import { _assert } from '@naturalcycles/js-lib/error/assert.js'
 import { _truncateMiddle } from '@naturalcycles/js-lib/string/string.util.js'
 import type { AnySchema, ValidationError, ValidationOptions } from 'joi'
 import type { JoiValidationErrorData } from './joi.validation.error.js'
@@ -37,6 +43,15 @@ const defaultOptions: ValidationOptions = {
   // }
 }
 
+export function getJoiValidationFunction<T>(
+  schema: AnySchema<T>,
+): ValidationFunction<T, JoiValidationError> {
+  return (input, opt) => {
+    _assert(!opt?.mutateInput, 'mutateInput=true is not yet supported with Joi')
+    return getValidationResult(input, schema, opt?.inputName)
+  }
+}
+
 /**
  * Validates with Joi.
  * Throws JoiValidationError if invalid.
@@ -47,10 +62,10 @@ const defaultOptions: ValidationOptions = {
 export function validate<T>(
   input: any,
   schema?: AnySchema<T>,
-  objectName?: string,
+  inputName?: string,
   opt: ValidationOptions = {},
 ): T {
-  const [error, returnValue] = getValidationResult(input, schema, objectName, opt)
+  const [error, returnValue] = getValidationResult(input, schema, inputName, opt)
   if (error) throw error
   return returnValue
 }
@@ -67,7 +82,7 @@ export function validate<T>(
 export function getValidationResult<T>(
   input: T,
   schema?: AnySchema<T>,
-  objectName?: string,
+  inputName?: string,
   options: ValidationOptions = {},
 ): ValidationFunctionResult<T, JoiValidationError> {
   if (!schema) return [null, input]
@@ -77,7 +92,7 @@ export function getValidationResult<T>(
     ...options,
   })
 
-  const err = error ? createError(input, error, objectName) : null
+  const err = error ? createError(input, error, inputName) : null
   return [err, value]
 }
 
@@ -110,15 +125,15 @@ export function convert<T>(input: any, schema?: AnySchema<T>): T {
   return value
 }
 
-function createError(value: any, err: ValidationError, objectName?: string): JoiValidationError {
+function createError(value: any, err: ValidationError, inputName?: string): JoiValidationError {
   const tokens: string[] = []
 
-  const objectId = _isObject(value) ? (value['id'] as string) : undefined
+  const inputId = _isObject(value) ? (value['id'] as string) : undefined
 
-  if (objectId || objectName) {
-    objectName ||= value?.constructor?.name
+  if (inputId || inputName) {
+    inputName ||= value?.constructor?.name
 
-    tokens.push('Invalid ' + [objectName, objectId].filter(Boolean).join('.'))
+    tokens.push('Invalid ' + [inputName, inputId].filter(Boolean).join('.'))
   }
 
   const annotation = err.annotate(stripColors)
@@ -151,8 +166,8 @@ function createError(value: any, err: ValidationError, objectName?: string): Joi
 
   const data: JoiValidationErrorData = {
     joiValidationErrorItems: err.details,
-    ...(objectName && { joiValidationObjectName: objectName }),
-    ...(objectId && { joiValidationObjectId: objectId }),
+    ...(inputName && { joiValidationInputName: inputName }),
+    ...(inputId && { joiValidationInputId: inputId }),
   }
 
   // Make annotation non-enumerable, to not get it automatically printed,