@itzworking/decorated-class 0.0.162 → 0.0.197

package/{dist → dist-cjs}/decorators/attribute/attribute.js

@@ -31,19 +31,3 @@ const Attribute = (attributeType, options = {}) => {
     return (0, utils_1.updateAttributes)(attributeType, isValidType, options);
 };
 exports.Attribute = Attribute;
-// export const OldAttribute = {
-//   List: (type: PrimitiveType | any) =>
-//     updateAttributes(
-//       "List",
-//       (value: any) =>
-//         value === undefined || value === null || Array.isArray(value),
-//       type
-//     ),
-//   Object: (type: any) =>
-//     updateAttributes(
-//       "Object",
-//       (value: any) =>
-//         value === undefined || value === null || typeof value === type,
-//       type
-//     ),
-// };

package/{dist → dist-cjs}/decorators/attribute/types/attribute-type.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AttributeType = void 0;
-const primitive_type_1 = require("./primitive-type");
 var AttributeType;
 (function (AttributeType) {
     AttributeType["String"] = "String";

package/{dist → dist-cjs}/decorators/attribute/utils/update-attributes.js

@@ -4,6 +4,9 @@ exports.updateAttributes = void 0;
 require("reflect-metadata");
 const symbol_1 = require("../symbol");
 const updateAttributes = (attributeType, isValidType, options = {}) => (target, context) => {
+    if (!target) {
+        return;
+    }
     const attributes = Reflect.getOwnMetadata(symbol_1.symbol, target) || [];
     const attributeName = typeof context === "string" ? context : context.name;
     let currentAttribute = attributes.find((attribute) => attribute.attributeName === attributeName);
@@ -15,7 +18,6 @@ const updateAttributes = (attributeType, isValidType, options = {}) => (target,
             attributeName,
             attributeType,
             constraints: [],
-            // isMethod: typeof target[attributeName] === "function",
             nestedType: options?.nestedType,
             isValidTypeInTarget,
         };
@@ -23,7 +25,6 @@ const updateAttributes = (attributeType, isValidType, options = {}) => (target,
     }
     else {
         currentAttribute.attributeType = attributeType;
-        // currentAttribute.isMethod = typeof target[attributeName] === "function";
         currentAttribute.nestedType = options?.nestedType;
         currentAttribute.isValidTypeInTarget = isValidTypeInTarget;
     }

package/{dist → dist-cjs}/decorators/validation/utils/register-constraint.js

@@ -3,34 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerConstraint = exports.registerConstraintWithoutProps = exports.registerConstraintWithProps = void 0;
 const symbol_1 = require("../../attribute/symbol");
 const errors_1 = require("../../../errors");
-/**
- * Registers a constraint validator with properties.
- *
- * This utility function allows the creation and registration of a constraint validator
- * that takes a parameter, such as @Max(5), which can be applied as a decorator on a class attribute.
- *
- * @param constraintId - A unique identifier for the constraint. This ID will be used to reference
- *                       the constraint validator when validating properties.
- * @param constraintValidator - The constraint validator function that validates the property based
- *                              on the given parameter. It returns a function that accepts the property
- *                              value and performs the validation.
- *
- * @example
- * ```typescript
- * // Register the constraint validator with a unique ID
- * const Max = registerConstraintWithProps(
- *   "Max",
- *   (max: number) => (value: any) => typeof value === "number" && value <= max
- * );
- *
- * // Use the constraint as a decorator on a class attribute
- * class ExampleClass {
- *   @Attribute(AttributeType.Integer)
- *   @Max(5)
- *   numberValue: number;
- * }
- * ```
- */
 const registerConstraintWithProps = (constraintId, constraintValidator) => {
     return (props) => (target, context) => {
         const attributes = Reflect.getOwnMetadata(symbol_1.symbol, target) || [];
@@ -69,34 +41,6 @@ const registerConstraintWithProps = (constraintId, constraintValidator) => {
     };
 };
 exports.registerConstraintWithProps = registerConstraintWithProps;
-/**
- * Registers a constraint validator without properties.
- *
- * This utility function allows the creation and registration of a constraint validator
- * that does not take any parameters, such as @NotBlank, which can be applied as a decorator
- * on a class attribute.
- *
- * @param constraintId - A unique identifier for the constraint. This ID will be used to reference
- *                       the constraint validator when validating properties.
- * @param constraintValidator - The constraint validator function that validates the property without
- *                              any parameters. It accepts only the property value.
- *
- * @example
- * ```typescript
- * // Register the constraint validator with a unique ID
- * const NotBlank = registerConstraintWithoutProps(
- *   'NotBlank',
- *   (value: any) => typeof value === 'string' && value.trim().length > 0
- * );
- *
- * // Use the constraint as a decorator on a class attribute
- * class ExampleClass {
- *   @Attribute(AttributeType.String)
- *   @NotBlank
- *   textValue: string;
- * }
- * ```
- */
 const registerConstraintWithoutProps = (constraintId, constraintValidator) => {
     return (0, exports.registerConstraintWithProps)(constraintId, () => constraintValidator)();
 };

package/dist-cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/{dist → dist-cjs}/validator/list-validation-errors.js

@@ -15,7 +15,6 @@ const listValidationErrors = (target) => {
             validations.push({
                 attributeName: attribute.attributeName,
                 constraintId: "AttributeTypeIsDefined",
-                // constraintProps: "",
                 message: `${attribute.attributeName} has no @Attribute(AttributeType) defined`,
             });
             continue;

package/dist-es/decorated-class.js

@@ -0,0 +1,77 @@
+import { AttributeType, listAttributes, PrimitiveType } from "./decorators";
+const parseBoolean = (value) => {
+    switch (value) {
+        case true:
+        case "true":
+        case 1:
+        case "1":
+        case "on":
+        case "yes":
+            return true;
+        case false:
+        case "false":
+        case 0:
+        case "0":
+        case "off":
+        case "no":
+            return false;
+        default:
+            return undefined;
+    }
+};
+const isPrimitiveType = (type) => {
+    return Object.values(PrimitiveType).includes(type);
+};
+const parseType = (value, type, nestedType) => {
+    if (type === AttributeType.Float) {
+        return parseFloat(value);
+    }
+    if (type === AttributeType.Integer) {
+        return parseInt(value);
+    }
+    if (type === AttributeType.Boolean) {
+        return parseBoolean(value);
+    }
+    if (type === AttributeType.Date) {
+        return new Date(value);
+    }
+    if (type === AttributeType.Object &&
+        nestedType &&
+        nestedType.prototype instanceof DecoratedClass) {
+        return new nestedType(value);
+    }
+    if (type === AttributeType.List) {
+        if (!value || !Array.isArray(value)) {
+            return undefined;
+        }
+        if (nestedType) {
+            if (isPrimitiveType(nestedType)) {
+                return value.map((item) => parseType(item, nestedType));
+            }
+            else if (nestedType.prototype instanceof DecoratedClass) {
+                return value.map((item) => parseType(item, AttributeType.Object, nestedType));
+            }
+        }
+    }
+    return value;
+};
+export class DecoratedClass {
+    constructor(props = {}) {
+        if (!props) {
+            return;
+        }
+        const attributes = listAttributes(this);
+        const self = this;
+        for (const attribute of attributes) {
+            const { attributeName: key, attributeType, nestedType } = attribute;
+            if (self[key] !== undefined || props[key] === undefined) {
+                continue;
+            }
+            const value = parseType(props[key], attributeType, nestedType);
+            if (value === undefined) {
+                continue;
+            }
+            self[key] = value;
+        }
+    }
+}

package/dist-es/decorators/attribute/attribute.js

@@ -0,0 +1,29 @@
+import { updateAttributes } from "./utils";
+import { AttributeType } from "./types";
+export const Attribute = (attributeType, options = {}) => {
+    let isValidType = () => true;
+    if (attributeType === AttributeType.String) {
+        isValidType = (value) => value === undefined || value === null || typeof value === "string";
+    }
+    else if (attributeType === AttributeType.Integer) {
+        isValidType = (value) => value === undefined ||
+            value === null ||
+            (Number(value) === value && value % 1 === 0);
+    }
+    else if (attributeType === AttributeType.Float) {
+        isValidType = (value) => value === undefined || value === null || Number(value) === value;
+    }
+    else if (attributeType === AttributeType.Boolean) {
+        isValidType = (value) => value === undefined || value === null || typeof value === "boolean";
+    }
+    else if (attributeType === AttributeType.Date) {
+        isValidType = (value) => value === undefined || value === null || value instanceof Date;
+    }
+    else if (attributeType === AttributeType.List) {
+        isValidType = (value) => value === undefined || value === null || Array.isArray(value);
+    }
+    else if (attributeType === AttributeType.Object) {
+        isValidType = (value) => value === undefined || value === null || typeof value === "object";
+    }
+    return updateAttributes(attributeType, isValidType, options);
+};

package/dist-es/decorators/attribute/index.js

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./attribute";
+export * from "./is-attribute";
+export * from "./list-attributes";

package/dist-es/decorators/attribute/is-attribute.js

@@ -0,0 +1,4 @@
+import { symbol } from "./symbol";
+export const isAttribute = (target, propertyKey) => {
+    return !!Reflect.getMetadata(symbol, target, propertyKey);
+};

package/dist-es/decorators/attribute/list-attributes.js

@@ -0,0 +1,11 @@
+import { symbol } from "./symbol";
+export const listAttributes = (target) => {
+    let attributes = [];
+    let targetToUse = Object.getPrototypeOf(target);
+    while (targetToUse && targetToUse !== Object.prototype) {
+        const parentAttributes = Reflect.getOwnMetadata(symbol, targetToUse) || [];
+        attributes = [...parentAttributes, ...attributes];
+        targetToUse = Object.getPrototypeOf(targetToUse);
+    }
+    return attributes;
+};

package/dist-es/decorators/attribute/symbol.js

@@ -0,0 +1 @@
+export const symbol = Symbol("itw_attribute");

package/dist-es/decorators/attribute/types/attribute-decorator.js

@@ -0,0 +1 @@
+export {};

package/dist-es/decorators/attribute/types/attribute-definition.js

@@ -0,0 +1 @@
+export {};

package/dist-es/decorators/attribute/types/attribute-type-alias.js

@@ -0,0 +1,2 @@
+import { AttributeType as AT } from "./attribute-type";
+export { AT };

package/dist-es/decorators/attribute/types/attribute-type.js

@@ -0,0 +1,10 @@
+export var AttributeType;
+(function (AttributeType) {
+    AttributeType["String"] = "String";
+    AttributeType["Float"] = "Float";
+    AttributeType["Integer"] = "Integer";
+    AttributeType["Boolean"] = "Boolean";
+    AttributeType["Date"] = "Date";
+    AttributeType["List"] = "List";
+    AttributeType["Object"] = "Object";
+})(AttributeType || (AttributeType = {}));

package/dist-es/decorators/attribute/types/index.js

@@ -0,0 +1,5 @@
+export * from "./attribute-decorator";
+export * from "./attribute-definition";
+export * from "./attribute-type";
+export * from "./attribute-type-alias";
+export * from "./primitive-type";

package/dist-es/decorators/attribute/types/primitive-type.js

@@ -0,0 +1,8 @@
+export var PrimitiveType;
+(function (PrimitiveType) {
+    PrimitiveType["String"] = "String";
+    PrimitiveType["Integer"] = "Integer";
+    PrimitiveType["Float"] = "Float";
+    PrimitiveType["Boolean"] = "Boolean";
+    PrimitiveType["Date"] = "Date";
+})(PrimitiveType || (PrimitiveType = {}));

package/dist-es/decorators/attribute/utils/index.js

@@ -0,0 +1 @@
+export * from "./update-attributes";

package/dist-es/decorators/attribute/utils/update-attributes.js

@@ -0,0 +1,30 @@
+import "reflect-metadata";
+import { symbol } from "../symbol";
+export const updateAttributes = (attributeType, isValidType, options = {}) => (target, context) => {
+    if (!target) {
+        return;
+    }
+    const attributes = Reflect.getOwnMetadata(symbol, target) || [];
+    const attributeName = typeof context === "string" ? context : context.name;
+    let currentAttribute = attributes.find((attribute) => attribute.attributeName === attributeName);
+    const isValidTypeInTarget = (target) => isValidType(typeof target[attributeName] === "function"
+        ? target[attributeName]()
+        : target[attributeName]);
+    if (!currentAttribute) {
+        currentAttribute = {
+            attributeName,
+            attributeType,
+            constraints: [],
+            nestedType: options?.nestedType,
+            isValidTypeInTarget,
+        };
+        attributes.push(currentAttribute);
+    }
+    else {
+        currentAttribute.attributeType = attributeType;
+        currentAttribute.nestedType = options?.nestedType;
+        currentAttribute.isValidTypeInTarget = isValidTypeInTarget;
+    }
+    Reflect.defineMetadata(symbol, attributes, target);
+    Reflect.defineMetadata(symbol, currentAttribute, target, attributeName);
+};

package/dist-es/decorators/index.js

@@ -0,0 +1,4 @@
+import "reflect-metadata";
+export * from "./attribute";
+export * from "./attribute/types/primitive-type";
+export * from "./validation";

package/dist-es/decorators/validation/index.js

@@ -0,0 +1,7 @@
+export * from "./types";
+export * from "./utils";
+export * from "./max";
+export * from "./min";
+export * from "./not-blank";
+export * from "./not-null";
+export * from "./pattern";

package/dist-es/decorators/validation/max.js

@@ -0,0 +1,17 @@
+import { registerConstraintWithProps } from "./utils";
+import { UnsupportedDecoratorError } from "../../errors";
+export const Max = registerConstraintWithProps("Max", (max) => (value) => {
+    if (value === null || value === undefined) {
+        return true;
+    }
+    if (typeof value === "string") {
+        return value.length <= max;
+    }
+    if (typeof value === "number") {
+        return value <= max;
+    }
+    if (Array.isArray(value)) {
+        return value.length <= max;
+    }
+    throw new UnsupportedDecoratorError();
+});

package/dist-es/decorators/validation/min.js

@@ -0,0 +1,17 @@
+import { registerConstraintWithProps } from "./utils";
+import { UnsupportedDecoratorError } from "../../errors";
+export const Min = registerConstraintWithProps("Min", (min) => (value) => {
+    if (value === null || value === undefined) {
+        return true;
+    }
+    if (typeof value === "string") {
+        return value.length >= min;
+    }
+    if (typeof value === "number") {
+        return value >= min;
+    }
+    if (Array.isArray(value)) {
+        return value.length >= min;
+    }
+    throw new UnsupportedDecoratorError();
+});

package/dist-es/decorators/validation/not-blank.js

@@ -0,0 +1,11 @@
+import { registerConstraintWithoutProps } from "./utils";
+import { UnsupportedDecoratorError } from "../../errors";
+export const NotBlank = registerConstraintWithoutProps("NotBlank", (value) => {
+    if (value === null || value === undefined) {
+        return true;
+    }
+    if (typeof value !== "string") {
+        throw new UnsupportedDecoratorError();
+    }
+    return value.trim().length > 0;
+});

package/dist-es/decorators/validation/not-null.js

@@ -0,0 +1,2 @@
+import { registerConstraintWithoutProps } from "./utils";
+export const NotNull = registerConstraintWithoutProps("NotNull", (value) => value !== null && value !== undefined);

package/dist-es/decorators/validation/pattern.js

@@ -0,0 +1,12 @@
+import { registerConstraintWithProps } from "./utils";
+import { UnsupportedDecoratorError } from "../../errors";
+export const Pattern = registerConstraintWithProps("Pattern", (pattern) => (value) => {
+    if (value === null || value === undefined) {
+        return true;
+    }
+    if (typeof value !== "string") {
+        throw new UnsupportedDecoratorError();
+    }
+    const r = value.match(pattern);
+    return !!r && r.length > 0;
+});

package/dist-es/decorators/validation/types/index.js

@@ -0,0 +1,2 @@
+export * from "./validation-definition";
+export * from "./validation-type";

package/dist-es/decorators/validation/types/validation-definition.js

@@ -0,0 +1 @@
+export {};

package/dist-es/decorators/validation/types/validation-type.js

@@ -0,0 +1 @@
+export {};

package/dist-es/decorators/validation/utils/index.js

@@ -0,0 +1 @@
+export * from "./register-constraint";

package/dist-es/decorators/validation/utils/register-constraint.js

@@ -0,0 +1,43 @@
+import { symbol } from "../../attribute/symbol";
+import { UnsupportedDecoratorError } from "../../../errors";
+export const registerConstraintWithProps = (constraintId, constraintValidator) => {
+    return (props) => (target, context) => {
+        const attributes = Reflect.getOwnMetadata(symbol, target) || [];
+        const attributeName = typeof context === "string" ? context : context.name;
+        let currentAttribute = attributes.find((attribute) => attribute.attributeName === attributeName);
+        const constraint = {
+            constraintId,
+            isValid: (target) => {
+                try {
+                    return constraintValidator(props)(typeof target[attributeName] === "function"
+                        ? target[attributeName]()
+                        : target[attributeName], target);
+                }
+                catch (e) {
+                    if (e instanceof UnsupportedDecoratorError) {
+                        e.setErrorProps(constraintId, `${target.constructor.name}.${attributeName}`, typeof target[attributeName]);
+                    }
+                    throw e;
+                }
+            },
+            constraintProps: props,
+        };
+        if (!currentAttribute) {
+            currentAttribute = {
+                attributeName,
+                constraints: [constraint],
+                isValidTypeInTarget: () => false,
+            };
+            attributes.push(currentAttribute);
+        }
+        else {
+            currentAttribute.constraints.push(constraint);
+        }
+        Reflect.defineMetadata(symbol, attributes, target);
+        Reflect.defineMetadata(symbol, currentAttribute, target, attributeName);
+    };
+};
+export const registerConstraintWithoutProps = (constraintId, constraintValidator) => {
+    return registerConstraintWithProps(constraintId, () => constraintValidator)();
+};
+export const registerConstraint = registerConstraintWithoutProps;

package/dist-es/errors/attributes-not-valid-error.js

@@ -0,0 +1,9 @@
+export class AttributesNotValidError extends Error {
+    validations;
+    constructor(validations) {
+        super(validations.map((error) => error.message).join(", "));
+        this.name = "AttributesNotValidError";
+        this.validations = validations;
+        Object.setPrototypeOf(this, AttributesNotValidError.prototype);
+    }
+}

package/dist-es/errors/index.js

@@ -0,0 +1,3 @@
+export * from "./attributes-not-valid-error";
+export * from "./invalid-target-error";
+export * from "./unsupported-decorator-error";

package/dist-es/errors/invalid-target-error.js

@@ -0,0 +1,6 @@
+export class InvalidTargetError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidTargetError";
+    }
+}

package/dist-es/errors/unsupported-decorator-error.js

@@ -0,0 +1,15 @@
+export class UnsupportedDecoratorError extends Error {
+    decorator;
+    attributePath;
+    attributeType;
+    constructor() {
+        super("UnsupportedDecoratorError");
+        this.name = "UnsupportedDecoratorError";
+    }
+    setErrorProps(decorator, attributePath, attributeType) {
+        this.decorator = decorator;
+        this.attributePath = attributePath;
+        this.attributeType = attributeType;
+        this.message = `@${decorator} is not supported for ${attributePath}`;
+    }
+}

package/dist-es/index.js

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./decorators";
+export * from "./errors";
+export * from "./validator";
+export * from "./decorated-class";

package/dist-es/types.js

@@ -0,0 +1 @@
+export {};

package/dist-es/validator/index.js

@@ -0,0 +1 @@
+export * from "./validator";

package/dist-es/validator/list-validation-errors.js

@@ -0,0 +1,49 @@
+import { listAttributes } from "../decorators/attribute";
+import { InvalidTargetError } from "../errors";
+import { DecoratedClass } from "../decorated-class";
+export const listValidationErrors = (target) => {
+    if (!target) {
+        throw new InvalidTargetError("Target is not defined");
+    }
+    const attributes = listAttributes(target);
+    const validations = [];
+    for (const attribute of attributes) {
+        if (!attribute.attributeType) {
+            validations.push({
+                attributeName: attribute.attributeName,
+                constraintId: "AttributeTypeIsDefined",
+                message: `${attribute.attributeName} has no @Attribute(AttributeType) defined`,
+            });
+            continue;
+        }
+        if (!attribute.isValidTypeInTarget(target)) {
+            const attributeToUse = attribute.attributeType === "Object" && attribute.nestedType
+                ? attribute.nestedType
+                : attribute.attributeType;
+            validations.push({
+                attributeName: attribute.attributeName,
+                constraintId: "CorrectAttributeType",
+                constraintProps: attributeToUse,
+                message: `${attribute.attributeName} is not of type ${attributeToUse}`,
+            });
+            continue;
+        }
+        if (attribute.attributeType === "Object" &&
+            attribute.nestedType &&
+            attribute.nestedType.prototype instanceof DecoratedClass &&
+            target[attribute.attributeName]) {
+            validations.push(...listValidationErrors(target[attribute.attributeName]));
+        }
+        for (const validation of attribute.constraints) {
+            if (!validation.isValid(target)) {
+                validations.push({
+                    attributeName: attribute.attributeName,
+                    constraintId: validation.constraintId,
+                    constraintProps: validation.constraintProps,
+                    message: `Attribute ${attribute.attributeName} is not valid`,
+                });
+            }
+        }
+    }
+    return validations;
+};

package/dist-es/validator/validate.js

@@ -0,0 +1,8 @@
+import { AttributesNotValidError } from "../errors";
+import { listValidationErrors } from "./list-validation-errors";
+export const validate = (target) => {
+    const validations = listValidationErrors(target);
+    if (validations.length) {
+        throw new AttributesNotValidError(validations);
+    }
+};

package/dist-es/validator/validator.js

@@ -0,0 +1,6 @@
+import { validate } from "./validate";
+import { listValidationErrors } from "./list-validation-errors";
+export const validator = {
+    validate: (target) => validate(target),
+    listValidationErrors: (target) => listValidationErrors(target),
+};

package/{dist → dist-types}/decorated-class.d.ts

@@ -2,4 +2,3 @@ export type DecoratedClassConstructorProps = any;
 export declare abstract class DecoratedClass {
     protected constructor(props?: DecoratedClassConstructorProps);
 }
-//# sourceMappingURL=decorated-class.d.ts.map

package/{dist → dist-types}/decorators/attribute/attribute.d.ts

@@ -3,4 +3,3 @@ import { DecoratedClass } from "../../decorated-class";
 export declare const Attribute: (attributeType: AttributeType, options?: {
     nestedType?: PrimitiveType | DecoratedClass | any;
 }) => import("./types").AttributeDecorator;
-//# sourceMappingURL=attribute.d.ts.map

package/{dist → dist-types}/decorators/attribute/index.d.ts

@@ -2,4 +2,3 @@ export * from "./types";
 export * from "./attribute";
 export * from "./is-attribute";
 export * from "./list-attributes";
-//# sourceMappingURL=index.d.ts.map

package/{dist → dist-types}/decorators/attribute/is-attribute.d.ts

@@ -1,2 +1 @@
 export declare const isAttribute: (target: any, propertyKey: string) => boolean;
-//# sourceMappingURL=is-attribute.d.ts.map

package/{dist → dist-types}/decorators/attribute/list-attributes.d.ts

@@ -1,3 +1,2 @@
 import { AttributeDefinition } from "./types";
 export declare const listAttributes: (target: any) => AttributeDefinition[];
-//# sourceMappingURL=list-attributes.d.ts.map

package/{dist → dist-types}/decorators/attribute/symbol.d.ts

@@ -1,2 +1 @@
 export declare const symbol: unique symbol;
-//# sourceMappingURL=symbol.d.ts.map