@decaf-ts/decorator-validation/lib/esm/model/decorators.js

simple decorator based validation engine

import { bindModelPrototype, construct } from "./construction.js";
import { ModelKeys } from "./../utils/constants.js";
import { Model } from "./Model.js";
import { Decoration, metadata } from "@decaf-ts/decoration";
/**
 * @description Base decorator for model classes.
 * @summary This decorator wraps the original constructor to bind the Model prototype, run a builder function, and register the model.
 * @param {any} original The original constructor of the class.
 * @return {any} The new constructor with added model functionality.
 * @function modelBaseDecorator
 * @memberOf module:decorator-validation
 */
export function modelBaseDecorator(original) {
    // the new constructor behaviour
    const newConstructor = function (...args) {
        const instance = construct(original, ...args);
        bindModelPrototype(instance);
        // run a builder function if defined with the first argument (The ModelArg)
        const builder = Model.getBuilder();
        if (builder)
            builder(instance, args.length ? args[0] : undefined);
        return instance;
    };
    // copy prototype so instanceof operator still works
    newConstructor.prototype = original.prototype;
    // Sets the proper constructor name for type verification
    Object.defineProperty(newConstructor, "name", {
        writable: false,
        enumerable: true,
        configurable: false,
        value: original.prototype.constructor.name,
    });
    metadata(ModelKeys.CONSTRUCTOR, original)(newConstructor);
    Model.register(newConstructor, original.name);
    // return new constructor (will override original)
    return newConstructor;
}
/**
 * @summary Defines a class as a Model class
 * @description
 *
 * - Registers the class under the model registry so it can be easily rebuilt;
 * - Overrides the class constructor;
 * - Runs the global {@link ModelBuilderFunction} if defined;
 *
 * @function model
 *
 * @category Class Decorators
 */
export function model() {
    const key = ModelKeys.MODEL;
    return Decoration.for(key).define(modelBaseDecorator).apply();
}
/**
 * @summary Defines the hashing algorithm to use on the model
 * @description
 *
 * - Registers the class under the model registry so it can be easily rebuilt;
 * - Overrides the class constructor;
 * - Runs the global {@link ModelBuilderFunction} if defined;
 *
 * @param {string} algorithm the algorithm to use
 *
 * @function hashedBy
 *
 * @category Class Decorators
 */
export function hashedBy(algorithm, ...args) {
    return metadata(ModelKeys.HASHING, {
        algorithm: algorithm,
        args: args,
    });
}
/**
 * @summary Defines the serialization algorithm to use on the model
 *
 * @param {string} serializer the algorithm to use
 *
 * @function serializedBy
 *
 * @category Class Decorators
 */
export function serializedBy(serializer, ...args) {
    return metadata(ModelKeys.SERIALIZATION, {
        serializer: serializer,
        args: args,
    });
}
//# sourceMappingURL=decorators.js.map