@decaf-ts/decorator-validation 1.7.6 → 1.7.8

package/lib/esm/model/decorators.js

@@ -98,4 +98,4 @@ export function serializedBy(serializer, ...args) {
 export function description(description) {
     return metadata(Model.key(ModelKeys.DESCRIPTION), description);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/model/types.d.ts

@@ -1,3 +1,4 @@
+import type { ConditionalAsync } from "../types";
 import { ModelErrorDefinition } from "./ModelErrorDefinition";
 import { Model } from "./Model";
 /**
@@ -46,21 +47,48 @@ export type ModelConstructor<T extends Model> = {
     new (model?: ModelArg<T>, ...args: any[]): T;
 };
 /**
- * @description Interface for objects that can be validated
- * @summary Defines the Validation API for validatable models
+ * @description Interface for objects that can be validated.
+ * @summary Defines the Validation API for validation behavior on models, supporting both synchronous and asynchronous validations.
+ * Implementers must provide a `hasErrors` method that performs the validation and returns either validation errors or undefined if validation passes.
+ *
+ * @template Async - A boolean flag indicating whether the validation is asynchronous (`true`) or synchronous (`false`).
+ *
+ * @param {any[]} [args] - Optional arguments to control validation behavior passed to the validation method.
+ *
  * @interface Validatable
- * @memberOf module:decorator-validation
  * @category Model
+ * @memberOf module:decorator-validation
+ *
+ * @example
+ * ```typescript
+ * // Synchronous validation example
+ * class SyncModel implements Validatable<false> {
+ *   hasErrors(...args: any[]): ModelErrorDefinition | undefined {
+ *     // perform synchronous validation logic
+ *     return undefined; // or return errors if invalid
+ *   }
+ * }
+ *
+ * // Asynchronous validation example
+ * class AsyncModel implements Validatable<true> {
+ *   async hasErrors(...args: any[]): Promise<ModelErrorDefinition | undefined> {
+ *     // perform asynchronous validation logic
+ *     return undefined; // or return errors if invalid
+ *   }
+ * }
+ * ```
  */
-export interface Validatable {
+export interface Validatable<Async extends boolean = false> {
     /**
-     * @description Validates the object against its validation rules
-     * @summary Validates the model and returns the {@link ModelErrorDefinition} if any errors exist
-     * @param {any[]} [args] - Optional arguments to control validation behavior
-     * @return {ModelErrorDefinition | undefined} - Validation errors if any, otherwise undefined
+     * @description Validates the object against its validation rules.
+     * @summary Validates the model and returns the {@link ModelErrorDefinition} if any errors exist, or `undefined` if no errors.
+     *
+     * @param {any[]} [args] - Optional arguments that may influence validation logic.
+     * @return {ConditionalAsync<Async, ModelErrorDefinition | undefined>} Validation errors or undefined, conditionally wrapped in a Promise if asynchronous.
+     *
      * @method
      */
-    hasErrors(...args: any[]): ModelErrorDefinition | undefined;
+    hasErrors(...args: any[]): ConditionalAsync<Async, ModelErrorDefinition | undefined>;
 }
 /**
  * @description Interface for objects that can be serialized to string

package/lib/esm/model/types.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/model/utils.d.ts

@@ -1,3 +1,16 @@
-import type { Model } from "./Model";
+import { ConditionalAsync } from "../types";
+import { Model } from "./Model";
 export declare function getModelKey(str: string): string;
 export declare function getMetadata<M extends Model>(model: M): any;
+/**
+ * Wraps a value in a Promise if the `async` flag is true.
+ *
+ * @template T - The type of the value being wrapped.
+ * @template Async - A boolean type that determines if the result should be wrapped in a Promise.
+ *
+ * @param value - The value to return directly or wrap in a Promise.
+ * @param async - If true, the value is wrapped in a resolved Promise. If false or undefined, the value is returned as-is.
+ *
+ * @returns The original value or a Promise resolving to it, depending on the `async` flag.
+ */
+export declare function toConditionalPromise<T, Async extends boolean>(value: T, async?: Async): ConditionalAsync<Async, T>;

package/lib/esm/model/utils.js

@@ -8,4 +8,18 @@ export function getMetadata(model) {
         throw new Error("could not find metadata for provided " + model.constructor.name);
     return metadata;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbW9kZWwvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxnQ0FBMkI7QUFHL0MsTUFBTSxVQUFVLFdBQVcsQ0FBQyxHQUFXO0lBQ3JDLE9BQU8sU0FBUyxDQUFDLE9BQU8sR0FBRyxHQUFHLENBQUM7QUFDakMsQ0FBQztBQUVELE1BQU0sVUFBVSxXQUFXLENBQWtCLEtBQVE7SUFDbkQsTUFBTSxRQUFRLEdBQUcsT0FBTyxDQUFDLFdBQVcsQ0FDbEMsV0FBVyxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsRUFDNUIsS0FBSyxDQUFDLFdBQVcsQ0FDbEIsQ0FBQztJQUNGLElBQUksQ0FBQyxRQUFRO1FBQ1gsTUFBTSxJQUFJLEtBQUssQ0FDYix1Q0FBdUMsR0FBRyxLQUFLLENBQUMsV0FBVyxDQUFDLElBQUksQ0FDakUsQ0FBQztJQUNKLE9BQU8sUUFBUSxDQUFDO0FBQ2xCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNb2RlbEtleXMgfSBmcm9tIFwiLi4vdXRpbHMvY29uc3RhbnRzXCI7XG5pbXBvcnQgdHlwZSB7IE1vZGVsIH0gZnJvbSBcIi4vTW9kZWxcIjtcblxuZXhwb3J0IGZ1bmN0aW9uIGdldE1vZGVsS2V5KHN0cjogc3RyaW5nKSB7XG4gIHJldHVybiBNb2RlbEtleXMuUkVGTEVDVCArIHN0cjtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGdldE1ldGFkYXRhPE0gZXh0ZW5kcyBNb2RlbD4obW9kZWw6IE0pIHtcbiAgY29uc3QgbWV0YWRhdGEgPSBSZWZsZWN0LmdldE1ldGFkYXRhKFxuICAgIGdldE1vZGVsS2V5KE1vZGVsS2V5cy5NT0RFTCksXG4gICAgbW9kZWwuY29uc3RydWN0b3JcbiAgKTtcbiAgaWYgKCFtZXRhZGF0YSlcbiAgICB0aHJvdyBuZXcgRXJyb3IoXG4gICAgICBcImNvdWxkIG5vdCBmaW5kIG1ldGFkYXRhIGZvciBwcm92aWRlZCBcIiArIG1vZGVsLmNvbnN0cnVjdG9yLm5hbWVcbiAgICApO1xuICByZXR1cm4gbWV0YWRhdGE7XG59XG4iXX0=
+/**
+ * Wraps a value in a Promise if the `async` flag is true.
+ *
+ * @template T - The type of the value being wrapped.
+ * @template Async - A boolean type that determines if the result should be wrapped in a Promise.
+ *
+ * @param value - The value to return directly or wrap in a Promise.
+ * @param async - If true, the value is wrapped in a resolved Promise. If false or undefined, the value is returned as-is.
+ *
+ * @returns The original value or a Promise resolving to it, depending on the `async` flag.
+ */
+export function toConditionalPromise(value, async) {
+    return (async ? Promise.resolve(value) : value);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/model/validation.d.ts

@@ -1,14 +1,116 @@
 import { ModelErrorDefinition } from "./ModelErrorDefinition";
 import { Model } from "./Model";
+import { ValidationPropertyDecoratorDefinition } from "../validation";
+import { ConditionalAsync, DecoratorMetadataAsync } from "../types";
 /**
- * @summary Analyses the decorations of the properties and validates the obj according to them
+ * Retrieves the validation metadata decorators associated with a specific property of a model,
+ * using the reflective metadata key.
  *
- * @typedef M extends Model
- * @prop {M} obj Model object to validate
- * @prop {string[]} [propsToIgnore] object properties to ignore in the validation
+ * @param model - The model instance or class containing the decorated property.
+ * @param {string} prop - The name of the property whose decorators should be retrieved.
+ * @param {string} reflectKey - The metadata key used to retrieve the decorators.
+ *                     Defaults to `ValidationKeys.REFLECT`.
  *
+ * @returns The validation decorators applied to the property
+ */
+export declare function getValidationDecorators(model: Record<string, any>, prop: string, reflectKey?: string): ValidationPropertyDecoratorDefinition;
+/**
+ * @description
+ * Retrieves all validatable property decorators from a given model, excluding specified properties.
+ *
+ * @summary
+ * Iterates through the own enumerable properties of a model instance, filtering out any properties
+ * listed in the `propsToIgnore` array. For each remaining property, it checks whether validation
+ * decorators are present using `getValidationDecorators`, and if so, collects them in the result array.
+ *
+ * @template M - A generic parameter extending the `Model` class, representing the model type being inspected.
+ *
+ * @param {M} model - An instance of a class extending `Model` from which validatable properties will be extracted.
+ * @param {string[]} propsToIgnore - An array of property names that should be excluded from validation inspection.
+ *
+ * @return {ValidationPropertyDecoratorDefinition[]} An array of validation decorator definitions
+ * associated with the model's properties, excluding those listed in `propsToIgnore`.
+ *
+ * @function getValidatableProperties
+ */
+export declare function getValidatableProperties<M extends Model>(model: M, propsToIgnore: string[]): ValidationPropertyDecoratorDefinition[];
+export declare function validateDecorator<M extends Model, Async extends boolean = false>(model: M, value: any, decorator: DecoratorMetadataAsync, async?: Async): ConditionalAsync<Async, string | undefined>;
+/**
+ * @description
+ * Executes validation logic for a set of decorators applied to a model's property, handling both
+ * synchronous and asynchronous validations, including support for nested validations and lists.
+ *
+ * @summary
+ * Iterates over an array of decorator metadata objects and applies each validation rule to the
+ * provided value. For list decorators (`ValidationKeys.LIST`), it performs element-wise validation,
+ * supporting nested model validation and type checks. If the `async` flag is set, asynchronous
+ * validation is supported using `Promise.all`. The result is a record mapping validation keys to
+ * error messages, or `undefined` if no errors are found.
+ *
+ * @template M - A type parameter extending `Model`, representing the model type being validated.
+ * @template Async - A boolean indicating whether validation should be performed asynchronously.
+ *
+ * @param {M} model - The model instance that the validation is associated with.
+ * @param {any} value - The value to be validated against the provided decorators.
+ * @param {DecoratorMetadataAsync[]} decorators - An array of metadata objects representing validation decorators.
+ * @param {Async} [async] - Optional flag indicating whether validation should be performed asynchronously.
+ *
+ * @return {ConditionalAsync<Async, Record<string, string>> | undefined}
+ * Returns either a record of validation errors (keyed by the decorator key) or `undefined` if no errors are found.
+ * If `async` is true, the return value is a Promise resolving to the same structure.
+ *
+ * @function validateDecorators
+ */
+export declare function validateDecorators<M extends Model, Async extends boolean = false>(model: M, value: any, decorators: DecoratorMetadataAsync[], async?: Async): ConditionalAsync<Async, Record<string, string> | undefined>;
+/**
  * @function validate
+ * @template M
+ * @template Async
  * @memberOf module:decorator-validation
  * @category Model
+ *
+ * @description
+ * Validates the properties of a {@link Model} instance using registered decorators.
+ * Supports both synchronous and asynchronous validation flows, depending on the `async` flag.
+ *
+ * @summary
+ * This function inspects a given model object, identifies decorated properties that require validation,
+ * and applies the corresponding validation rules. It also supports nested model validation and gracefully
+ * merges any validation errors. For collections (Array/Set), it enforces the presence of the `@list` decorator
+ * and checks the type of elements. If a property is a nested model, it will call `hasErrors` on it and flatten
+ * the nested error keys using dot notation.
+ *
+ * @param {M} model - The model instance to be validated. Must extend from {@link Model}.
+ * @param {Async} [async] - A flag indicating whether validation should be asynchronous.
+ * @param {...string} propsToIgnore - A variadic list of property names that should be skipped during validation.
+ *
+ * @returns {ConditionalAsync<Async, ModelErrorDefinition | undefined>}
+ * Returns either a {@link ModelErrorDefinition} containing validation errors,
+ * or `undefined` if no errors are found. When `async` is `true`, returns a Promise.
+ *
+ * @see {@link Model}
+ * @see {@link ModelErrorDefinition}
+ * @see {@link validateDecorators}
+ * @see {@link getValidatableProperties}
+ *
+ * @mermaid
+ * sequenceDiagram
+ *     participant Caller
+ *     participant validate
+ *     participant getValidatableProperties
+ *     participant validateDecorators
+ *     participant ModelInstance
+ *     Caller->>validate: call with obj, async, propsToIgnore
+ *     validate->>getValidatableProperties: retrieve decorated props
+ *     loop for each property
+ *         validate->>validateDecorators: validate using decorators
+ *         alt is nested model
+ *             validate->>ModelInstance: call hasErrors()
+ *         end
+ *     end
+ *     alt async
+ *         validate->>validate: Promise.allSettled for errors
+ *     end
+ *     validate-->>Caller: return ModelErrorDefinition | undefined
  */
-export declare function validate<M extends Model>(obj: M, ...propsToIgnore: string[]): ModelErrorDefinition | undefined;
+export declare function validate<M extends Model<boolean>, Async extends boolean = false>(model: M, async: Async, ...propsToIgnore: string[]): ConditionalAsync<Async, ModelErrorDefinition | undefined>;