@tsed/ajv 8.26.2 → 8.28.0

package/lib/esm/fn/validate.js

@@ -1,4 +1,5 @@
 import { inject } from "@tsed/di";
+import { JsonSchema } from "@tsed/schema";
 import { AjvService } from "../services/AjvService.js";
 /**
  * Validate a value against a JSON schema or a type using the configured `AjvService`.
@@ -9,10 +10,18 @@ import { AjvService } from "../services/AjvService.js";
  * @typeParam TReturn Explicit return type override. When omitted, `TValue` is returned.
  * @typeParam TValue Input value type.
  * @param value Value to validate.
- * @param options Validation options, a JSON schema, or a target type descriptor.
+ * @param options Validation options, a `JsonSchema`, or a target type descriptor.
  * @returns The validated value. If `returnsCoercedValues` is enabled, it may contain coerced values.
  * @throws {AjvValidationError} When validation fails.
  */
 export function validate(value, options) {
-    return inject(AjvService).validate(value, options);
+    return inject(AjvService).validate(value, mapOptions(options));
+}
+function mapOptions(options) {
+    if (options instanceof JsonSchema) {
+        return {
+            schema: options
+        };
+    }
+    return options;
 }

package/lib/esm/index.js

@@ -15,3 +15,5 @@ export * from "./services/Ajv.js";
 export * from "./services/AjvService.js";
 export * from "./utils/defaultErrorFormatter.js";
 export * from "./utils/getPath.js";
+export * from "./utils/mapClassError.js";
+export * from "./utils/mapErrors.js";

package/lib/esm/services/AjvService.js

@@ -1,17 +1,18 @@
 import "./Ajv.js";
-import { deepClone, getValue, nameOf, prototypeOf, setValue } from "@tsed/core";
+import { deepClone } from "@tsed/core";
 import { constant, inject, injectable } from "@tsed/di";
-import { getJsonSchema, JsonEntityStore, JsonSchema } from "@tsed/schema";
+import { compile, JsonSchema } from "@tsed/schema";
 import { Ajv } from "ajv";
-import { AjvValidationError } from "../errors/AjvValidationError.js";
 import { defaultErrorFormatter } from "../utils/defaultErrorFormatter.js";
-import { getPath } from "../utils/getPath.js";
+import { mapErrors } from "../utils/mapErrors.js";
 export class AjvService {
     constructor() {
         this.name = "ajv";
         this.errorFormatter = constant("ajv.errorFormatter", defaultErrorFormatter);
         this.returnsCoercedValues = constant("ajv.returnsCoercedValues");
+        this.hasLoadSchema = !!constant("ajv.loadSchema");
         this.ajv = inject(Ajv);
+        this.validatorsBySchema = new WeakMap();
     }
     /**
      * Validate a value against a JSON schema, a model type, or explicit AJV options.
@@ -29,19 +30,18 @@ export class AjvService {
      * @throws {AjvValidationError} When validation fails.
      */
     async validate(value, options) {
-        let { schema: defaultSchema, type, collectionType, returnsCoercedValues = this.returnsCoercedValues, ...additionalOptions } = this.mapOptions(options);
-        const schema = defaultSchema || getJsonSchema(type, { ...additionalOptions, customKeys: true });
-        if (schema) {
-            const localValue = this.returnsCoercedValues ? value : deepClone(value);
-            const validate = this.ajv.compile(schema);
+        if (options.type || options.schema) {
+            let { schema: defaultSchema, type, collectionType, returnsCoercedValues = this.returnsCoercedValues, ...additionalOptions } = options;
+            const validate = await this.getValidator(defaultSchema || type, additionalOptions);
+            const localValue = returnsCoercedValues ? value : deepClone(value);
             const valid = await validate(localValue);
             const { errors } = validate;
             if (!valid && errors) {
-                throw this.mapErrors(errors, {
+                throw mapErrors(errors, {
                     type,
                     collectionType,
-                    async: true,
-                    value: localValue
+                    value: localValue,
+                    errorFormatter: this.errorFormatter
                 });
             }
             if (returnsCoercedValues) {
@@ -50,52 +50,32 @@ export class AjvService {
         }
         return value;
     }
-    mapOptions(options) {
-        if (options instanceof JsonSchema) {
-            return {
-                schema: options.toJSON({ customKeys: true })
-            };
-        }
-        return options;
-    }
-    mapErrors(errors, options) {
-        const { type, collectionType, value } = options;
-        const message = errors
-            .map((error) => {
-            if (collectionType) {
-                error.collectionName = nameOf(collectionType);
-            }
-            const dataPath = getPath(error);
-            if (!error.data) {
-                if (dataPath) {
-                    error.data = getValue(value, dataPath.replace(/^\./, ""));
-                }
-                else if (error.schemaPath !== "#/required") {
-                    error.data = value;
-                }
-            }
-            if (dataPath && dataPath.match(/pwd|password|mdp|secret/)) {
-                error.data = "[REDACTED]";
-            }
-            if (type) {
-                error.modelName = nameOf(type);
-                error.message = this.mapClassError(error, type);
-            }
-            return this.errorFormatter(error);
-        })
-            .join("\n");
-        return new AjvValidationError(message, errors);
-    }
-    mapClassError(error, targetType) {
-        const propertyKey = getValue(error, "params.missingProperty");
-        if (propertyKey) {
-            const store = JsonEntityStore.from(prototypeOf(targetType), propertyKey);
-            if (store) {
-                setValue(error, "params.missingProperty", store.name || propertyKey);
-                return error.message?.replace(`'${propertyKey}'`, `'${store.name || propertyKey}'`);
-            }
+    /**
+     * Resolve and compile a validator for the provided schema input.
+     *
+     * The compiled validator is cached by schema object identity to avoid
+     * recompiling validators for repeated calls using the same schema instance.
+     *
+     * When `loadSchema` is configured, this method uses `compileAsync` to support
+     * asynchronous external reference resolution.
+     *
+     * @param schema Schema source as `JsonSchema` instance or plain JSON schema object.
+     * @returns Compiled AJV validate function.
+     */
+    async getValidator(input, additionalOptions) {
+        const schema = input instanceof JsonSchema || typeof input === "function"
+            ? compile(input, {
+                ...additionalOptions,
+                customKeys: true
+            })
+            : input;
+        const cached = this.validatorsBySchema.get(schema);
+        if (cached) {
+            return cached;
         }
-        return error.message;
+        const validate = this.hasLoadSchema ? await this.ajv.compileAsync(schema) : this.ajv.compile(schema);
+        this.validatorsBySchema.set(schema, validate);
+        return validate;
     }
 }
 injectable(AjvService).type("validator:service");

package/lib/esm/utils/mapClassError.js

@@ -0,0 +1,23 @@
+import { getValue, prototypeOf, setValue } from "@tsed/core";
+import { JsonEntityStore } from "@tsed/schema";
+/**
+ * Rewrite class-related AJV messages using Ts.ED metadata.
+ *
+ * For missing required properties, this method replaces the property key by
+ * the store-resolved property name when aliasing/naming is configured.
+ *
+ * @param error AJV error object to transform.
+ * @param targetType Class used to resolve property metadata.
+ * @returns Updated message when metadata exists, otherwise original message.
+ */
+export function mapClassError(error, targetType) {
+    const propertyKey = getValue(error, "params.missingProperty");
+    if (propertyKey) {
+        const store = JsonEntityStore.from(prototypeOf(targetType), propertyKey);
+        if (store) {
+            setValue(error, "params.missingProperty", store.name || propertyKey);
+            return error.message?.replace(`'${propertyKey}'`, `'${store.name || propertyKey}'`);
+        }
+    }
+    return error.message;
+}

package/lib/esm/utils/mapErrors.js

@@ -0,0 +1,42 @@
+import { getValue, nameOf } from "@tsed/core";
+import { AjvValidationError } from "../errors/AjvValidationError.js";
+import { getPath } from "./getPath.js";
+import { mapClassError } from "./mapClassError.js";
+/**
+ * Map raw AJV errors to framework-level validation error output.
+ *
+ * Enriches errors with collection/model information and contextual data values,
+ * then formats each message via the configured `errorFormatter`.
+ *
+ * @param errors Raw AJV error objects.
+ * @param options Validation context used to enrich error payloads.
+ * @returns Normalized Ts.ED validation error.
+ */
+export function mapErrors(errors, options) {
+    const { type, collectionType, value, errorFormatter } = options;
+    const message = errors
+        .map((error) => {
+        if (collectionType) {
+            error.collectionName = nameOf(collectionType);
+        }
+        const dataPath = getPath(error);
+        if (error.data === undefined) {
+            if (dataPath) {
+                error.data = getValue(value, dataPath.replace(/^\./, ""));
+            }
+            else if (error.schemaPath !== "#/required") {
+                error.data = value;
+            }
+        }
+        if (dataPath && dataPath.match(/pwd|password|mdp|secret/i)) {
+            error.data = "[REDACTED]";
+        }
+        if (type) {
+            error.modelName = nameOf(type);
+            error.message = mapClassError(error, type);
+        }
+        return errorFormatter(error);
+    })
+        .join("\n");
+    return new AjvValidationError(message, errors);
+}

package/lib/types/fn/validate.d.ts

@@ -9,7 +9,7 @@ import { type AjvValidateOptions } from "../services/AjvService.js";
  * @typeParam TReturn Explicit return type override. When omitted, `TValue` is returned.
  * @typeParam TValue Input value type.
  * @param value Value to validate.
- * @param options Validation options, a JSON schema, or a target type descriptor.
+ * @param options Validation options, a `JsonSchema`, or a target type descriptor.
  * @returns The validated value. If `returnsCoercedValues` is enabled, it may contain coerced values.
  * @throws {AjvValidationError} When validation fails.
  */

package/lib/types/index.d.ts

@@ -15,3 +15,5 @@ export * from "./services/Ajv.js";
 export * from "./services/AjvService.js";
 export * from "./utils/defaultErrorFormatter.js";
 export * from "./utils/getPath.js";
+export * from "./utils/mapClassError.js";
+export * from "./utils/mapErrors.js";

package/lib/types/services/AjvService.d.ts

@@ -1,9 +1,8 @@
 import "./Ajv.js";
 import { Type } from "@tsed/core";
 import { JsonSchema, JsonSchemaObject } from "@tsed/schema";
-import { Ajv, ErrorObject } from "ajv";
-import { AjvValidationError } from "../errors/AjvValidationError.js";
-import { AjvErrorObject, ErrorFormatter } from "../interfaces/AjvSettings.js";
+import { Ajv, ValidateFunction } from "ajv";
+import { ErrorFormatter } from "../interfaces/AjvSettings.js";
 export interface AjvValidateOptions extends Record<string, any> {
     schema?: JsonSchema | Partial<JsonSchemaObject>;
     type?: Type<any> | any;
@@ -14,7 +13,9 @@ export declare class AjvService {
     readonly name = "ajv";
     protected errorFormatter: ErrorFormatter;
     protected returnsCoercedValues: boolean | undefined;
+    protected hasLoadSchema: boolean;
     protected ajv: Ajv;
+    protected validatorsBySchema: WeakMap<object, ValidateFunction<unknown>>;
     /**
      * Validate a value against a JSON schema, a model type, or explicit AJV options.
      *
@@ -30,8 +31,18 @@ export declare class AjvService {
      * @returns The validated value (possibly coerced when configured).
      * @throws {AjvValidationError} When validation fails.
      */
-    validate<TReturn = never, TValue = unknown>(value: TValue, options: AjvValidateOptions | JsonSchema): Promise<[TReturn] extends [never] ? TValue : TReturn>;
-    protected mapOptions(options: AjvValidateOptions | JsonSchema): AjvValidateOptions;
-    protected mapErrors(errors: ErrorObject[], options: any): AjvValidationError;
-    protected mapClassError(error: AjvErrorObject, targetType: Type<any>): string | undefined;
+    validate<TReturn = never, TValue = unknown>(value: TValue, options: AjvValidateOptions): Promise<[TReturn] extends [never] ? TValue : TReturn>;
+    /**
+     * Resolve and compile a validator for the provided schema input.
+     *
+     * The compiled validator is cached by schema object identity to avoid
+     * recompiling validators for repeated calls using the same schema instance.
+     *
+     * When `loadSchema` is configured, this method uses `compileAsync` to support
+     * asynchronous external reference resolution.
+     *
+     * @param schema Schema source as `JsonSchema` instance or plain JSON schema object.
+     * @returns Compiled AJV validate function.
+     */
+    protected getValidator(input: Type | JsonSchema | JsonSchemaObject, additionalOptions: Record<string, any>): Promise<ValidateFunction<unknown>>;
 }

package/lib/types/utils/mapClassError.d.ts

@@ -0,0 +1,13 @@
+import { Type } from "@tsed/core";
+import { AjvErrorObject } from "../interfaces/AjvSettings.js";
+/**
+ * Rewrite class-related AJV messages using Ts.ED metadata.
+ *
+ * For missing required properties, this method replaces the property key by
+ * the store-resolved property name when aliasing/naming is configured.
+ *
+ * @param error AJV error object to transform.
+ * @param targetType Class used to resolve property metadata.
+ * @returns Updated message when metadata exists, otherwise original message.
+ */
+export declare function mapClassError(error: AjvErrorObject, targetType: Type<any>): string | undefined;

package/lib/types/utils/mapErrors.d.ts

@@ -0,0 +1,21 @@
+import { Type } from "@tsed/core";
+import { ErrorObject } from "ajv";
+import { AjvValidationError } from "../errors/AjvValidationError.js";
+import { ErrorFormatter } from "../interfaces/AjvSettings.js";
+export interface MapErrorsOptions {
+    collectionType?: Type<any> | any;
+    errorFormatter: ErrorFormatter;
+    type?: Type<any> | any;
+    value: unknown;
+}
+/**
+ * Map raw AJV errors to framework-level validation error output.
+ *
+ * Enriches errors with collection/model information and contextual data values,
+ * then formats each message via the configured `errorFormatter`.
+ *
+ * @param errors Raw AJV error objects.
+ * @param options Validation context used to enrich error payloads.
+ * @returns Normalized Ts.ED validation error.
+ */
+export declare function mapErrors(errors: ErrorObject[], options: MapErrorsOptions): AjvValidationError;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/ajv",
   "description": "AJV package for Ts.ED framework",
   "type": "module",
-  "version": "8.26.2",
+  "version": "8.28.0",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
@@ -29,17 +29,17 @@
     "tslib": ">=2.7.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.26.2",
-    "@tsed/core": "8.26.2",
-    "@tsed/di": "8.26.2",
-    "@tsed/exceptions": "8.26.2",
-    "@tsed/schema": "8.26.2",
-    "@tsed/typescript": "8.26.2",
+    "@tsed/barrels": "8.28.0",
+    "@tsed/core": "8.28.0",
+    "@tsed/di": "8.28.0",
+    "@tsed/exceptions": "8.28.0",
+    "@tsed/schema": "8.28.0",
+    "@tsed/typescript": "8.28.0",
     "ajv": "^8.17.1",
     "eslint": "9.12.0",
     "typescript": "6.0.2",
     "vite": "7.3.2",
-    "vitest": "3.2.4"
+    "vitest": "4.1.4"
   },
   "peerDependencies": {
     "@tsed/core": ">=8.0.0",