@naturalcycles/nodejs-lib 15.81.1 → 15.82.0

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

@@ -49,6 +49,11 @@ export declare class AjvSchema<IN = unknown, OUT = IN> {
     private getAJVValidateFunction;
     private static requireValidJsonSchema;
     private applyImprovementsOnErrorMessages;
+    private getErrorMessageForInstancePath;
+    private traverseSchemaPath;
+    private getChildSchema;
+    private getArrayItemSchema;
+    private getObjectPropertySchema;
 }
 export declare const HIDDEN_AJV_SCHEMA: unique symbol;
 export type WithCachedAjvSchema<Base, IN, OUT> = Base & {

package/dist/validation/ajv/ajvSchema.js

@@ -162,12 +162,56 @@ export class AjvSchema {
             return;
         const { errorMessages } = this.schema;
         for (const error of errors) {
-            if (errorMessages?.[error.keyword]) {
+            const errorMessage = this.getErrorMessageForInstancePath(this.schema, error.instancePath, error.keyword);
+            if (errorMessage) {
+                error.message = errorMessage;
+            }
+            else if (errorMessages?.[error.keyword]) {
                 error.message = errorMessages[error.keyword];
             }
             error.instancePath = error.instancePath.replaceAll(/\/(\d+)/g, `[$1]`).replaceAll('/', '.');
         }
     }
+    getErrorMessageForInstancePath(schema, instancePath, keyword) {
+        if (!schema || !instancePath)
+            return undefined;
+        const segments = instancePath.split('/').filter(Boolean);
+        return this.traverseSchemaPath(schema, segments, keyword);
+    }
+    traverseSchemaPath(schema, segments, keyword) {
+        if (!segments.length)
+            return undefined;
+        const [currentSegment, ...remainingSegments] = segments;
+        const nextSchema = this.getChildSchema(schema, currentSegment);
+        if (!nextSchema)
+            return undefined;
+        if (nextSchema.errorMessages?.[keyword]) {
+            return nextSchema.errorMessages[keyword];
+        }
+        if (remainingSegments.length) {
+            return this.traverseSchemaPath(nextSchema, remainingSegments, keyword);
+        }
+        return undefined;
+    }
+    getChildSchema(schema, segment) {
+        if (!segment)
+            return undefined;
+        if (/^\d+$/.test(segment) && schema.items) {
+            return this.getArrayItemSchema(schema, segment);
+        }
+        return this.getObjectPropertySchema(schema, segment);
+    }
+    getArrayItemSchema(schema, indexSegment) {
+        if (!schema.items)
+            return undefined;
+        if (Array.isArray(schema.items)) {
+            return schema.items[Number(indexSegment)];
+        }
+        return schema.items;
+    }
+    getObjectPropertySchema(schema, segment) {
+        return schema.properties?.[segment];
+    }
 }
 const separator = '\n';
 export const HIDDEN_AJV_SCHEMA = Symbol('HIDDEN_AJV_SCHEMA');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/nodejs-lib",
   "type": "module",
-  "version": "15.81.1",
+  "version": "15.82.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@types/js-yaml": "^4",

package/src/validation/ajv/ajvSchema.ts

@@ -229,13 +229,78 @@ export class AjvSchema<IN = unknown, OUT = IN> {
     const { errorMessages } = this.schema
 
     for (const error of errors) {
-      if (errorMessages?.[error.keyword]) {
+      const errorMessage = this.getErrorMessageForInstancePath(
+        this.schema,
+        error.instancePath,
+        error.keyword,
+      )
+
+      if (errorMessage) {
+        error.message = errorMessage
+      } else if (errorMessages?.[error.keyword]) {
         error.message = errorMessages[error.keyword]
       }
 
       error.instancePath = error.instancePath.replaceAll(/\/(\d+)/g, `[$1]`).replaceAll('/', '.')
     }
   }
+
+  private getErrorMessageForInstancePath(
+    schema: JsonSchema<IN, OUT> | undefined,
+    instancePath: string,
+    keyword: string,
+  ): string | undefined {
+    if (!schema || !instancePath) return undefined
+
+    const segments = instancePath.split('/').filter(Boolean)
+    return this.traverseSchemaPath(schema, segments, keyword)
+  }
+
+  private traverseSchemaPath<IN = unknown, OUT = IN>(
+    schema: JsonSchema<IN, OUT>,
+    segments: string[],
+    keyword: string,
+  ): string | undefined {
+    if (!segments.length) return undefined
+
+    const [currentSegment, ...remainingSegments] = segments
+
+    const nextSchema = this.getChildSchema(schema, currentSegment)
+    if (!nextSchema) return undefined
+
+    if (nextSchema.errorMessages?.[keyword]) {
+      return nextSchema.errorMessages[keyword]
+    }
+
+    if (remainingSegments.length) {
+      return this.traverseSchemaPath(nextSchema, remainingSegments, keyword)
+    }
+
+    return undefined
+  }
+
+  private getChildSchema(schema: JsonSchema, segment: string | undefined): JsonSchema | undefined {
+    if (!segment) return undefined
+    if (/^\d+$/.test(segment) && schema.items) {
+      return this.getArrayItemSchema(schema, segment)
+    }
+
+    return this.getObjectPropertySchema(schema, segment)
+  }
+
+  private getArrayItemSchema(schema: JsonSchema, indexSegment: string): JsonSchema | undefined {
+    if (!schema.items) return undefined
+
+    if (Array.isArray(schema.items)) {
+      return schema.items[Number(indexSegment)]
+    }
+
+    return schema.items
+  }
+
+  private getObjectPropertySchema(schema: JsonSchema, segment: string): JsonSchema | undefined {
+    return schema.properties?.[segment as keyof typeof schema.properties]
+  }
 }
 
 const separator = '\n'