@decaf-ts/decorator-validation
Version:
simple decorator based validation engine
55 lines • 5.49 kB
JavaScript
import { apply, metadata } from "@decaf-ts/reflection";
import { ModelKeys } from "./constants.js";
/**
* @description Property decorator factory for model attributes
* @summary Creates a decorator that marks class properties as model attributes
*
* @param {string} [key=ModelKeys.ATTRIBUTE] - The metadata key under which to store the property name
* @return {function(object, any?): void} - Decorator function that registers the property
* @function prop
* @category Property Decorators
*
* @mermaid
* sequenceDiagram
* participant D as Decorator
* participant M as Model
*
* D->>M: Check if key exists
* alt key exists
* M-->>D: Return existing props array
* else key doesn't exist
* D->>M: Create new props array
* end
* D->>M: Check if property exists
* alt property not in array
* D->>M: Add property to array
* end
*/
export function prop(key = ModelKeys.ATTRIBUTE) {
return (model, propertyKey) => {
let props;
if (Object.prototype.hasOwnProperty.call(model, key)) {
props = model[key];
}
else {
props = model[key] = [];
}
if (!props.includes(propertyKey))
props.push(propertyKey);
};
}
/**
* @description Combined property decorator factory for metadata and attribute marking
* @summary Creates a decorator that both marks a property as a model attribute and assigns metadata to it
*
* @template V
* @param {string} key - The metadata key
* @param {V} value - The metadata value to associate with the property
* @return {Function} - Combined decorator function
* @function propMetadata
* @category Property Decorators
*/
export function propMetadata(key, value) {
return apply(prop(), metadata(key, value));
}
//# sourceMappingURL=data:application/json;base64,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