@decaf-ts/core 0.5.0 → 0.5.2

package/lib/esm/query/Condition.d.ts

@@ -2,74 +2,118 @@ import { AttributeOption, ConditionBuilderOption } from "./options";
 import { Model, ModelErrorDefinition } from "@decaf-ts/decorator-validation";
 import { GroupOperator, Operator } from "./constants";
 /**
- * @summary Condition Class
- * @description Represents a logical condition
- *
- * @param {string | Condition} attr1
- * @param {Operator | GroupOperator} operator
- * @param {string | Condition} comparison
- *
+ * @description Represents a logical condition for database queries
+ * @summary A class that encapsulates query conditions with support for complex logical operations.
+ * This class allows for building and combining query conditions using logical operators (AND, OR, NOT)
+ * and comparison operators (equals, not equals, greater than, etc.).
+ * @template M - The model type this condition operates on
+ * @param {string | Condition<M>} attr1 - The attribute name or a nested condition
+ * @param {Operator | GroupOperator} operator - The operator to use for the condition
+ * @param {any} comparison - The value to compare against or another condition
  * @class Condition
- * @implements Executor
+ * @example
+ * // Create a simple condition
+ * const nameCondition = Condition.attribute("name").eq("John");
+ *
+ * // Create a complex condition
+ * const complexCondition = Condition.attribute("age").gt(18)
+ *   .and(Condition.attribute("status").eq("active"));
  *
- * @category Query
- * @subcategory Conditions
+ * // Use the builder pattern
+ * const userQuery = Condition.builder()
+ *   .attribute("email").regexp(".*@example.com")
+ *   .and(Condition.attribute("lastLogin").gt(new Date("2023-01-01")));
  */
-export declare class Condition extends Model {
-    protected attr1?: string | Condition;
+export declare class Condition<M extends Model> extends Model {
+    protected attr1?: string | Condition<M>;
     protected operator?: Operator | GroupOperator;
     protected comparison?: any;
     private constructor();
     /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation
-     * @param {Condition} condition
+     * @description Combines this condition with another using logical AND
+     * @summary Joins two conditions with an AND operator, requiring both to be true
+     * @param {Condition<M>} condition - The condition to combine with this one
+     * @return {Condition<M>} A new condition representing the AND operation
      */
-    and(condition: Condition): Condition;
+    and(condition: Condition<M>): Condition<M>;
     /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation
-     * @param {Condition} condition
+     * @description Combines this condition with another using logical OR
+     * @summary Joins two conditions with an OR operator, requiring at least one to be true
+     * @param {Condition<M>} condition - The condition to combine with this one
+     * @return {Condition<M>} A new condition representing the OR operation
      */
-    or(condition: Condition): Condition;
+    or(condition: Condition<M>): Condition<M>;
     /**
-     * @summary excludes a valut from the result
-     * @param val
+     * @description Creates a negation condition
+     * @summary Excludes a value from the result by applying a NOT operator
+     * @param {any} val - The value to negate
+     * @return {Condition<M>} A new condition representing the NOT operation
      */
-    not(val: any): Condition;
+    not(val: any): Condition<M>;
     /**
-     * @inheritDoc
+     * @description Validates the condition and checks for errors
+     * @summary Extends the base validation to ensure the condition is properly formed
+     * @param {...string[]} exceptions - Fields to exclude from validation
+     * @return {ModelErrorDefinition | undefined} Error definition if validation fails, undefined otherwise
      */
     hasErrors(...exceptions: string[]): ModelErrorDefinition | undefined;
     /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation
-     * @param {Condition} condition1
-     * @param {Condition} condition2
+     * @description Creates a new condition that combines two conditions with logical AND
+     * @summary Static method that joins two conditions with an AND operator, requiring both to be true
+     * @template M - The model type this condition operates on
+     * @param {Condition<M>} condition1 - The first condition
+     * @param {Condition<M>} condition2 - The second condition
+     * @return {Condition<M>} A new condition representing the AND operation
      */
-    static and(condition1: Condition, condition2: Condition): Condition;
+    static and<M extends Model>(condition1: Condition<M>, condition2: Condition<M>): Condition<M>;
     /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation
-     * @param {Condition} condition1
-     * @param {Condition} condition2
+     * @description Creates a new condition that combines two conditions with logical OR
+     * @summary Static method that joins two conditions with an OR operator, requiring at least one to be true
+     * @template M - The model type this condition operates on
+     * @param {Condition<M>} condition1 - The first condition
+     * @param {Condition<M>} condition2 - The second condition
+     * @return {Condition<M>} A new condition representing the OR operation
      */
-    static or(condition1: Condition, condition2: Condition): Condition;
+    static or<M extends Model>(condition1: Condition<M>, condition2: Condition<M>): Condition<M>;
     /**
-     * @summary Groups 2 {@link Condition}s by the specified {@link GroupOperator}
-     * @param {Condition} condition1
-     * @param {GroupOperator} operator
-     * @param {Condition} condition2
+     * @description Creates a new condition that groups two conditions with a specified operator
+     * @summary Private static method that combines two conditions using the specified group operator
+     * @template M - The model type this condition operates on
+     * @param {Condition<M>} condition1 - The first condition
+     * @param {GroupOperator} operator - The group operator to use (AND, OR)
+     * @param {Condition<M>} condition2 - The second condition
+     * @return {Condition<M>} A new condition representing the grouped operation
      */
     private static group;
-    static attribute(attr: string): AttributeOption;
     /**
-     * @summary Condition Builder Class
-     * @description provides a simple API to build {@link Condition}s
-     *
+     * @description Creates a condition builder for a specific model attribute
+     * @summary Static method that initializes a condition builder with the specified attribute
+     * @template M - The model type this condition operates on
+     * @param attr - The model attribute to build a condition for
+     * @return {AttributeOption<M>} A condition builder initialized with the attribute
+     */
+    static attribute<M extends Model>(attr: keyof M): AttributeOption<M>;
+    /**
+     * @description Alias for the attribute method
+     * @summary Shorthand method that initializes a condition builder with the specified attribute
+     * @template M - The model type this condition operates on
+     * @param attr - The model attribute to build a condition for
+     * @return {AttributeOption<M>} A condition builder initialized with the attribute
+     */
+    static attr<M extends Model>(attr: keyof M): AttributeOption<M>;
+    /**
+     * @description Provides a fluent API to build query conditions
+     * @summary A builder class that simplifies the creation of database query conditions
+     * with a chainable interface for setting attributes and operators
+     * @template M - The model type this condition builder operates on
      * @class ConditionBuilder
-     * @implements Builder
-     * @implements AttributeOption
-     *
-     * @category Query
-     * @subcategory Conditions
      */
     private static Builder;
-    static get builder(): ConditionBuilderOption;
+    /**
+     * @description Creates a new condition builder
+     * @summary Factory method that returns a new instance of the condition builder
+     * @template M - The model type this condition builder will operate on
+     * @return {ConditionBuilderOption<M>} A new condition builder instance
+     */
+    static builder<M extends Model>(): ConditionBuilderOption<M>;
 }

package/lib/esm/query/Condition.js

@@ -7,22 +7,31 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Model, required, sf, } from "@decaf-ts/decorator-validation";
+import { Model, required, } from "@decaf-ts/decorator-validation";
 import { GroupOperator, Operator } from "./constants";
 import { QueryError } from "./errors";
 /**
- * @summary Condition Class
- * @description Represents a logical condition
- *
- * @param {string | Condition} attr1
- * @param {Operator | GroupOperator} operator
- * @param {string | Condition} comparison
- *
+ * @description Represents a logical condition for database queries
+ * @summary A class that encapsulates query conditions with support for complex logical operations.
+ * This class allows for building and combining query conditions using logical operators (AND, OR, NOT)
+ * and comparison operators (equals, not equals, greater than, etc.).
+ * @template M - The model type this condition operates on
+ * @param {string | Condition<M>} attr1 - The attribute name or a nested condition
+ * @param {Operator | GroupOperator} operator - The operator to use for the condition
+ * @param {any} comparison - The value to compare against or another condition
  * @class Condition
- * @implements Executor
+ * @example
+ * // Create a simple condition
+ * const nameCondition = Condition.attribute("name").eq("John");
  *
- * @category Query
- * @subcategory Conditions
+ * // Create a complex condition
+ * const complexCondition = Condition.attribute("age").gt(18)
+ *   .and(Condition.attribute("status").eq("active"));
+ *
+ * // Use the builder pattern
+ * const userQuery = Condition.builder()
+ *   .attribute("email").regexp(".*@example.com")
+ *   .and(Condition.attribute("lastLogin").gt(new Date("2023-01-01")));
  */
 export class Condition extends Model {
     constructor(attr1, operator, comparison) {
@@ -35,33 +44,43 @@ export class Condition extends Model {
         this.comparison = comparison;
     }
     /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation
-     * @param {Condition} condition
+     * @description Combines this condition with another using logical AND
+     * @summary Joins two conditions with an AND operator, requiring both to be true
+     * @param {Condition<M>} condition - The condition to combine with this one
+     * @return {Condition<M>} A new condition representing the AND operation
      */
     and(condition) {
         return Condition.and(this, condition);
     }
     /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation
-     * @param {Condition} condition
+     * @description Combines this condition with another using logical OR
+     * @summary Joins two conditions with an OR operator, requiring at least one to be true
+     * @param {Condition<M>} condition - The condition to combine with this one
+     * @return {Condition<M>} A new condition representing the OR operation
      */
     or(condition) {
         return Condition.or(this, condition);
     }
     /**
-     * @summary excludes a valut from the result
-     * @param val
+     * @description Creates a negation condition
+     * @summary Excludes a value from the result by applying a NOT operator
+     * @param {any} val - The value to negate
+     * @return {Condition<M>} A new condition representing the NOT operation
      */
     not(val) {
         return new Condition(this, Operator.NOT, val);
     }
     /**
-     * @inheritDoc
+     * @description Validates the condition and checks for errors
+     * @summary Extends the base validation to ensure the condition is properly formed
+     * @param {...string[]} exceptions - Fields to exclude from validation
+     * @return {ModelErrorDefinition | undefined} Error definition if validation fails, undefined otherwise
      */
     hasErrors(...exceptions) {
         const errors = super.hasErrors(...exceptions);
         if (errors)
             return errors;
+        const invalidOpMessage = `Invalid operator ${this.operator}}`;
         if (typeof this.attr1 === "string") {
             if (this.comparison instanceof Condition)
                 return {
@@ -72,7 +91,7 @@ export class Condition extends Model {
             if (Object.values(Operator).indexOf(this.operator) === -1)
                 return {
                     operator: {
-                        condition: sf("Invalid operator {0}", this.operator),
+                        condition: invalidOpMessage,
                     },
                 };
         }
@@ -81,7 +100,7 @@ export class Condition extends Model {
                 this.operator !== Operator.NOT)
                 return {
                     comparison: {
-                        condition: sf("Invalid operator {0}", this.operator),
+                        condition: invalidOpMessage,
                     },
                 };
             if (Object.values(GroupOperator).indexOf(this.operator) ===
@@ -89,7 +108,7 @@ export class Condition extends Model {
                 this.operator !== Operator.NOT)
                 return {
                     operator: {
-                        condition: sf("Invalid operator {0}", this.operator),
+                        condition: invalidOpMessage,
                     },
                 };
             // if (this.operator !== Operator.NOT && typeof this.attr1.attr1 !== "string")
@@ -101,43 +120,65 @@ export class Condition extends Model {
         }
     }
     /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation
-     * @param {Condition} condition1
-     * @param {Condition} condition2
+     * @description Creates a new condition that combines two conditions with logical AND
+     * @summary Static method that joins two conditions with an AND operator, requiring both to be true
+     * @template M - The model type this condition operates on
+     * @param {Condition<M>} condition1 - The first condition
+     * @param {Condition<M>} condition2 - The second condition
+     * @return {Condition<M>} A new condition representing the AND operation
      */
     static and(condition1, condition2) {
         return Condition.group(condition1, GroupOperator.AND, condition2);
     }
     /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation
-     * @param {Condition} condition1
-     * @param {Condition} condition2
+     * @description Creates a new condition that combines two conditions with logical OR
+     * @summary Static method that joins two conditions with an OR operator, requiring at least one to be true
+     * @template M - The model type this condition operates on
+     * @param {Condition<M>} condition1 - The first condition
+     * @param {Condition<M>} condition2 - The second condition
+     * @return {Condition<M>} A new condition representing the OR operation
      */
     static or(condition1, condition2) {
         return Condition.group(condition1, GroupOperator.OR, condition2);
     }
     /**
-     * @summary Groups 2 {@link Condition}s by the specified {@link GroupOperator}
-     * @param {Condition} condition1
-     * @param {GroupOperator} operator
-     * @param {Condition} condition2
+     * @description Creates a new condition that groups two conditions with a specified operator
+     * @summary Private static method that combines two conditions using the specified group operator
+     * @template M - The model type this condition operates on
+     * @param {Condition<M>} condition1 - The first condition
+     * @param {GroupOperator} operator - The group operator to use (AND, OR)
+     * @param {Condition<M>} condition2 - The second condition
+     * @return {Condition<M>} A new condition representing the grouped operation
      */
     static group(condition1, operator, condition2) {
         return new Condition(condition1, operator, condition2);
     }
+    /**
+     * @description Creates a condition builder for a specific model attribute
+     * @summary Static method that initializes a condition builder with the specified attribute
+     * @template M - The model type this condition operates on
+     * @param attr - The model attribute to build a condition for
+     * @return {AttributeOption<M>} A condition builder initialized with the attribute
+     */
     static attribute(attr) {
         return new Condition.Builder().attribute(attr);
     }
     /**
-     * @summary Condition Builder Class
-     * @description provides a simple API to build {@link Condition}s
-     *
+     * @description Alias for the attribute method
+     * @summary Shorthand method that initializes a condition builder with the specified attribute
+     * @template M - The model type this condition operates on
+     * @param attr - The model attribute to build a condition for
+     * @return {AttributeOption<M>} A condition builder initialized with the attribute
+     */
+    static attr(attr) {
+        return this.attribute(attr);
+    }
+    /**
+     * @description Provides a fluent API to build query conditions
+     * @summary A builder class that simplifies the creation of database query conditions
+     * with a chainable interface for setting attributes and operators
+     * @template M - The model type this condition builder operates on
      * @class ConditionBuilder
-     * @implements Builder
-     * @implements AttributeOption
-     *
-     * @category Query
-     * @subcategory Conditions
      */
     static { this.Builder = class ConditionBuilder {
         constructor() {
@@ -146,68 +187,102 @@ export class Condition extends Model {
             this.comparison = undefined;
         }
         /**
-         * @inheritDoc
+         * @description Sets the attribute for the condition
+         * @summary Specifies which model attribute the condition will operate on
+         * @param attr - The model attribute to use in the condition
+         * @return {AttributeOption<M>} This builder instance for method chaining
          */
         attribute(attr) {
             this.attr1 = attr;
             return this;
         }
         /**
-         * @summary Creates an Equality Comparison
-         * @param {any} val
+         * @description Alias for the attribute method
+         * @summary Shorthand method to specify which model attribute the condition will operate on
+         * @param attr - The model attribute to use in the condition
+         * @return {AttributeOption<M>} This builder instance for method chaining
+         */
+        attr(attr) {
+            return this.attribute(attr);
+        }
+        /**
+         * @description Creates an equality condition
+         * @summary Builds a condition that checks if the attribute equals the specified value
+         * @param {any} val - The value to compare the attribute against
+         * @return {Condition<M>} A new condition representing the equality comparison
          */
         eq(val) {
             return this.setOp(Operator.EQUAL, val);
         }
         /**
-         * @summary Creates a Different Comparison
-         * @param {any} val
+         * @description Creates an inequality condition
+         * @summary Builds a condition that checks if the attribute is different from the specified value
+         * @param {any} val - The value to compare the attribute against
+         * @return {Condition<M>} A new condition representing the inequality comparison
          */
         dif(val) {
             return this.setOp(Operator.DIFFERENT, val);
         }
         /**
-         * @summary Creates a Greater Than Comparison
-         * @param {any} val
+         * @description Creates a greater than condition
+         * @summary Builds a condition that checks if the attribute is greater than the specified value
+         * @param {any} val - The value to compare the attribute against
+         * @return {Condition<M>} A new condition representing the greater than comparison
          */
         gt(val) {
             return this.setOp(Operator.BIGGER, val);
         }
         /**
-         * @summary Creates a Lower Than Comparison
-         * @param {any} val
+         * @description Creates a less than condition
+         * @summary Builds a condition that checks if the attribute is less than the specified value
+         * @param {any} val - The value to compare the attribute against
+         * @return {Condition<M>} A new condition representing the less than comparison
          */
         lt(val) {
             return this.setOp(Operator.SMALLER, val);
         }
         /**
-         * @summary Creates a Greater or Equal to Comparison
-         * @param {any} val
+         * @description Creates a greater than or equal to condition
+         * @summary Builds a condition that checks if the attribute is greater than or equal to the specified value
+         * @param {any} val - The value to compare the attribute against
+         * @return {Condition<M>} A new condition representing the greater than or equal comparison
          */
         gte(val) {
             return this.setOp(Operator.BIGGER_EQ, val);
         }
         /**
-         * @summary Creates a Lower or Equal to Comparison
-         * @param {any} val
+         * @description Creates a less than or equal to condition
+         * @summary Builds a condition that checks if the attribute is less than or equal to the specified value
+         * @param {any} val - The value to compare the attribute against
+         * @return {Condition<M>} A new condition representing the less than or equal comparison
          */
         lte(val) {
             return this.setOp(Operator.SMALLER_EQ, val);
         }
+        /**
+         * @description Creates an inclusion condition
+         * @summary Builds a condition that checks if the attribute value is included in the specified array
+         * @param {any[]} arr - The array of values to check against
+         * @return {Condition<M>} A new condition representing the inclusion comparison
+         */
         in(arr) {
             return this.setOp(Operator.IN, arr);
         }
         /**
-         * @summary Creates a Regexpo Comparison
-         * @param {any} val
+         * @description Creates a regular expression condition
+         * @summary Builds a condition that checks if the attribute matches the specified regular expression pattern
+         * @param {any} val - The regular expression pattern to match against
+         * @return {Condition<M>} A new condition representing the regular expression comparison
          */
         regexp(val) {
             return this.setOp(Operator.REGEXP, new RegExp(val).source);
         }
         /**
-         * @summary Creates an {@link Operator} based Comparison
-         * @param {Operator} op
-         * @param {any} val
+         * @description Sets the operator and comparison value for the condition
+         * @summary Private method that configures the condition with the specified operator and value
+         * @param {Operator} op - The operator to use for the condition
+         * @param {any} val - The value to compare against
+         * @return {Condition<M>} A new condition with the specified operator and value
          */
         setOp(op, val) {
             this.operator = op;
@@ -215,9 +290,10 @@ export class Condition extends Model {
             return this.build();
         }
         /**
-         * @summary Builds the Database Object
-         * @throws {QueryError} if it fails to build the {@link Condition}
-         * @private
+         * @description Constructs a Condition instance from the builder's state
+         * @summary Finalizes the condition building process by creating a new Condition instance
+         * @throws {QueryError} If the condition cannot be built due to invalid parameters
+         * @return {Condition<M>} A new condition instance with the configured attributes
          */
         build() {
             try {
@@ -228,7 +304,13 @@ export class Condition extends Model {
             }
         }
     }; }
-    static get builder() {
+    /**
+     * @description Creates a new condition builder
+     * @summary Factory method that returns a new instance of the condition builder
+     * @template M - The model type this condition builder will operate on
+     * @return {ConditionBuilderOption<M>} A new condition builder instance
+     */
+    static builder() {
         return new Condition.Builder();
     }
 }
@@ -244,4 +326,4 @@ __decorate([
     required(),
     __metadata("design:type", Object)
 ], Condition.prototype, "comparison", void 0);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Condition.js","sourceRoot":"","sources":["../../../src/query/Condition.ts"],"names":[],"mappings":"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","sourcesContent":["import { AttributeOption, ConditionBuilderOption } from \"./options\";\nimport {\n  Model,\n  ModelErrorDefinition,\n  required,\n  sf,\n} from \"@decaf-ts/decorator-validation\";\nimport { GroupOperator, Operator } from \"./constants\";\nimport { QueryError } from \"./errors\";\n\n/**\n * @summary Condition Class\n * @description Represents a logical condition\n *\n * @param {string | Condition} attr1\n * @param {Operator | GroupOperator} operator\n * @param {string | Condition} comparison\n *\n * @class Condition\n * @implements Executor\n *\n * @category Query\n * @subcategory Conditions\n */\n\nexport class Condition extends Model {\n  @required()\n  protected attr1?: string | Condition = undefined;\n  @required()\n  protected operator?: Operator | GroupOperator = undefined;\n  @required()\n  protected comparison?: any = undefined;\n\n  private constructor(\n    attr1: string | Condition,\n    operator: Operator | GroupOperator,\n    comparison: any\n  ) {\n    super();\n    this.attr1 = attr1;\n    this.operator = operator;\n    this.comparison = comparison;\n  }\n\n  /**\n   * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation\n   * @param {Condition} condition\n   */\n  and(condition: Condition): Condition {\n    return Condition.and(this, condition);\n  }\n\n  /**\n   * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation\n   * @param {Condition} condition\n   */\n  or(condition: Condition): Condition {\n    return Condition.or(this, condition);\n  }\n\n  /**\n   * @summary excludes a valut from the result\n   * @param val\n   */\n  not(val: any): Condition {\n    return new Condition(this, Operator.NOT, val);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  hasErrors(...exceptions: string[]): ModelErrorDefinition | undefined {\n    const errors = super.hasErrors(...exceptions);\n    if (errors) return errors;\n\n    if (typeof this.attr1 === \"string\") {\n      if (this.comparison instanceof Condition)\n        return {\n          comparison: {\n            condition: \"Both sides of the comparison must be of the same type\",\n          },\n        } as ModelErrorDefinition;\n      if (Object.values(Operator).indexOf(this.operator as Operator) === -1)\n        return {\n          operator: {\n            condition: sf(\"Invalid operator {0}\", this.operator as string),\n          },\n        } as ModelErrorDefinition;\n    }\n\n    if (this.attr1 instanceof Condition) {\n      if (\n        !(this.comparison instanceof Condition) &&\n        this.operator !== Operator.NOT\n      )\n        return {\n          comparison: {\n            condition: sf(\"Invalid operator {0}\", this.operator as string),\n          },\n        } as ModelErrorDefinition;\n      if (\n        Object.values(GroupOperator).indexOf(this.operator as GroupOperator) ===\n          -1 &&\n        this.operator !== Operator.NOT\n      )\n        return {\n          operator: {\n            condition: sf(\"Invalid operator {0}\", this.operator as string),\n          },\n        } as ModelErrorDefinition;\n      // if (this.operator !== Operator.NOT && typeof this.attr1.attr1 !== \"string\")\n      //     return {\n      //         attr1: {\n      //             condition: stringFormat(\"Parent condition attribute must be a string\")\n      //         }\n      //     } as ModelErrorDefinition\n    }\n  }\n\n  /**\n   * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation\n   * @param {Condition} condition1\n   * @param {Condition} condition2\n   */\n  static and(condition1: Condition, condition2: Condition): Condition {\n    return Condition.group(condition1, GroupOperator.AND, condition2);\n  }\n\n  /**\n   * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation\n   * @param {Condition} condition1\n   * @param {Condition} condition2\n   */\n  static or(condition1: Condition, condition2: Condition): Condition {\n    return Condition.group(condition1, GroupOperator.OR, condition2);\n  }\n\n  /**\n   * @summary Groups 2 {@link Condition}s by the specified {@link GroupOperator}\n   * @param {Condition} condition1\n   * @param {GroupOperator} operator\n   * @param {Condition} condition2\n   */\n  private static group(\n    condition1: Condition,\n    operator: GroupOperator,\n    condition2: Condition\n  ): Condition {\n    return new Condition(condition1, operator, condition2);\n  }\n\n  static attribute(attr: string) {\n    return new Condition.Builder().attribute(attr);\n  }\n\n  /**\n   * @summary Condition Builder Class\n   * @description provides a simple API to build {@link Condition}s\n   *\n   * @class ConditionBuilder\n   * @implements Builder\n   * @implements AttributeOption\n   *\n   * @category Query\n   * @subcategory Conditions\n   */\n  private static Builder = class ConditionBuilder\n    implements ConditionBuilderOption, AttributeOption\n  {\n    attr1?: string | Condition = undefined;\n    operator?: Operator | GroupOperator = undefined;\n    comparison?: any = undefined;\n\n    /**\n     * @inheritDoc\n     */\n    attribute(attr: string): AttributeOption {\n      this.attr1 = attr;\n      return this;\n    }\n\n    /**\n     * @summary Creates an Equality Comparison\n     * @param {any} val\n     */\n    eq(val: any) {\n      return this.setOp(Operator.EQUAL, val);\n    }\n\n    /**\n     * @summary Creates a Different Comparison\n     * @param {any} val\n     */\n    dif(val: any) {\n      return this.setOp(Operator.DIFFERENT, val);\n    }\n\n    /**\n     * @summary Creates a Greater Than Comparison\n     * @param {any} val\n     */\n    gt(val: any) {\n      return this.setOp(Operator.BIGGER, val);\n    }\n\n    /**\n     * @summary Creates a Lower Than Comparison\n     * @param {any} val\n     */\n    lt(val: any) {\n      return this.setOp(Operator.SMALLER, val);\n    }\n\n    /**\n     * @summary Creates a Greater or Equal to Comparison\n     * @param {any} val\n     */\n    gte(val: any) {\n      return this.setOp(Operator.BIGGER_EQ, val);\n    }\n\n    /**\n     * @summary Creates a Lower or Equal to Comparison\n     * @param {any} val\n     */\n    lte(val: any) {\n      return this.setOp(Operator.SMALLER_EQ, val);\n    }\n\n    in(arr: any[]) {\n      return this.setOp(Operator.IN, arr);\n    }\n\n    /**\n     * @summary Creates a Regexpo Comparison\n     * @param {any} val\n     */\n    regexp(val: any) {\n      return this.setOp(Operator.REGEXP, new RegExp(val).source);\n    }\n\n    /**\n     * @summary Creates an {@link Operator} based Comparison\n     * @param {Operator} op\n     * @param {any} val\n     */\n    private setOp(op: Operator, val: any) {\n      this.operator = op;\n      this.comparison = val;\n      return this.build();\n    }\n\n    /**\n     * @summary Builds the Database Object\n     * @throws {QueryError} if it fails to build the {@link Condition}\n     * @private\n     */\n    private build(): Condition {\n      try {\n        return new Condition(\n          this.attr1 as string | Condition,\n          this.operator as Operator,\n          this.comparison as any\n        );\n      } catch (e: any) {\n        throw new QueryError(e);\n      }\n    }\n  };\n\n  static get builder(): ConditionBuilderOption {\n    return new Condition.Builder();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Condition.js","sourceRoot":"","sources":["../../../src/query/Condition.ts"],"names":[],"mappings":"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","sourcesContent":["import { AttributeOption, ConditionBuilderOption } from \"./options\";\nimport {\n  Model,\n  ModelErrorDefinition,\n  required,\n} from \"@decaf-ts/decorator-validation\";\nimport { GroupOperator, Operator } from \"./constants\";\nimport { QueryError } from \"./errors\";\n\n/**\n * @description Represents a logical condition for database queries\n * @summary A class that encapsulates query conditions with support for complex logical operations.\n * This class allows for building and combining query conditions using logical operators (AND, OR, NOT)\n * and comparison operators (equals, not equals, greater than, etc.).\n * @template M - The model type this condition operates on\n * @param {string | Condition<M>} attr1 - The attribute name or a nested condition\n * @param {Operator | GroupOperator} operator - The operator to use for the condition\n * @param {any} comparison - The value to compare against or another condition\n * @class Condition\n * @example\n * // Create a simple condition\n * const nameCondition = Condition.attribute(\"name\").eq(\"John\");\n *\n * // Create a complex condition\n * const complexCondition = Condition.attribute(\"age\").gt(18)\n *   .and(Condition.attribute(\"status\").eq(\"active\"));\n *\n * // Use the builder pattern\n * const userQuery = Condition.builder()\n *   .attribute(\"email\").regexp(\".*@example.com\")\n *   .and(Condition.attribute(\"lastLogin\").gt(new Date(\"2023-01-01\")));\n */\nexport class Condition<M extends Model> extends Model {\n  @required()\n  protected attr1?: string | Condition<M> = undefined;\n  @required()\n  protected operator?: Operator | GroupOperator = undefined;\n  @required()\n  protected comparison?: any = undefined;\n\n  private constructor(\n    attr1: string | Condition<M>,\n    operator: Operator | GroupOperator,\n    comparison: any\n  ) {\n    super();\n    this.attr1 = attr1;\n    this.operator = operator;\n    this.comparison = comparison;\n  }\n\n  /**\n   * @description Combines this condition with another using logical AND\n   * @summary Joins two conditions with an AND operator, requiring both to be true\n   * @param {Condition<M>} condition - The condition to combine with this one\n   * @return {Condition<M>} A new condition representing the AND operation\n   */\n  and(condition: Condition<M>): Condition<M> {\n    return Condition.and(this, condition);\n  }\n\n  /**\n   * @description Combines this condition with another using logical OR\n   * @summary Joins two conditions with an OR operator, requiring at least one to be true\n   * @param {Condition<M>} condition - The condition to combine with this one\n   * @return {Condition<M>} A new condition representing the OR operation\n   */\n  or(condition: Condition<M>): Condition<M> {\n    return Condition.or(this, condition);\n  }\n\n  /**\n   * @description Creates a negation condition\n   * @summary Excludes a value from the result by applying a NOT operator\n   * @param {any} val - The value to negate\n   * @return {Condition<M>} A new condition representing the NOT operation\n   */\n  not(val: any): Condition<M> {\n    return new Condition(this, Operator.NOT, val);\n  }\n\n  /**\n   * @description Validates the condition and checks for errors\n   * @summary Extends the base validation to ensure the condition is properly formed\n   * @param {...string[]} exceptions - Fields to exclude from validation\n   * @return {ModelErrorDefinition | undefined} Error definition if validation fails, undefined otherwise\n   */\n  override hasErrors(\n    ...exceptions: string[]\n  ): ModelErrorDefinition | undefined {\n    const errors = super.hasErrors(...exceptions);\n    if (errors) return errors;\n\n    const invalidOpMessage = `Invalid operator ${this.operator}}`;\n\n    if (typeof this.attr1 === \"string\") {\n      if (this.comparison instanceof Condition)\n        return {\n          comparison: {\n            condition: \"Both sides of the comparison must be of the same type\",\n          },\n        } as ModelErrorDefinition;\n      if (Object.values(Operator).indexOf(this.operator as Operator) === -1)\n        return {\n          operator: {\n            condition: invalidOpMessage,\n          },\n        } as ModelErrorDefinition;\n    }\n\n    if (this.attr1 instanceof Condition) {\n      if (\n        !(this.comparison instanceof Condition) &&\n        this.operator !== Operator.NOT\n      )\n        return {\n          comparison: {\n            condition: invalidOpMessage,\n          },\n        } as ModelErrorDefinition;\n      if (\n        Object.values(GroupOperator).indexOf(this.operator as GroupOperator) ===\n          -1 &&\n        this.operator !== Operator.NOT\n      )\n        return {\n          operator: {\n            condition: invalidOpMessage,\n          },\n        } as ModelErrorDefinition;\n      // if (this.operator !== Operator.NOT && typeof this.attr1.attr1 !== \"string\")\n      //     return {\n      //         attr1: {\n      //             condition: stringFormat(\"Parent condition attribute must be a string\")\n      //         }\n      //     } as ModelErrorDefinition\n    }\n  }\n\n  /**\n   * @description Creates a new condition that combines two conditions with logical AND\n   * @summary Static method that joins two conditions with an AND operator, requiring both to be true\n   * @template M - The model type this condition operates on\n   * @param {Condition<M>} condition1 - The first condition\n   * @param {Condition<M>} condition2 - The second condition\n   * @return {Condition<M>} A new condition representing the AND operation\n   */\n  static and<M extends Model>(\n    condition1: Condition<M>,\n    condition2: Condition<M>\n  ): Condition<M> {\n    return Condition.group(condition1, GroupOperator.AND, condition2);\n  }\n\n  /**\n   * @description Creates a new condition that combines two conditions with logical OR\n   * @summary Static method that joins two conditions with an OR operator, requiring at least one to be true\n   * @template M - The model type this condition operates on\n   * @param {Condition<M>} condition1 - The first condition\n   * @param {Condition<M>} condition2 - The second condition\n   * @return {Condition<M>} A new condition representing the OR operation\n   */\n  static or<M extends Model>(\n    condition1: Condition<M>,\n    condition2: Condition<M>\n  ): Condition<M> {\n    return Condition.group(condition1, GroupOperator.OR, condition2);\n  }\n\n  /**\n   * @description Creates a new condition that groups two conditions with a specified operator\n   * @summary Private static method that combines two conditions using the specified group operator\n   * @template M - The model type this condition operates on\n   * @param {Condition<M>} condition1 - The first condition\n   * @param {GroupOperator} operator - The group operator to use (AND, OR)\n   * @param {Condition<M>} condition2 - The second condition\n   * @return {Condition<M>} A new condition representing the grouped operation\n   */\n  private static group<M extends Model>(\n    condition1: Condition<M>,\n    operator: GroupOperator,\n    condition2: Condition<M>\n  ): Condition<M> {\n    return new Condition(condition1, operator, condition2);\n  }\n\n  /**\n   * @description Creates a condition builder for a specific model attribute\n   * @summary Static method that initializes a condition builder with the specified attribute\n   * @template M - The model type this condition operates on\n   * @param attr - The model attribute to build a condition for\n   * @return {AttributeOption<M>} A condition builder initialized with the attribute\n   */\n  static attribute<M extends Model>(attr: keyof M) {\n    return new Condition.Builder<M>().attribute(attr);\n  }\n\n  /**\n   * @description Alias for the attribute method\n   * @summary Shorthand method that initializes a condition builder with the specified attribute\n   * @template M - The model type this condition operates on\n   * @param attr - The model attribute to build a condition for\n   * @return {AttributeOption<M>} A condition builder initialized with the attribute\n   */\n  static attr<M extends Model>(attr: keyof M) {\n    return this.attribute(attr);\n  }\n\n  /**\n   * @description Provides a fluent API to build query conditions\n   * @summary A builder class that simplifies the creation of database query conditions\n   * with a chainable interface for setting attributes and operators\n   * @template M - The model type this condition builder operates on\n   * @class ConditionBuilder\n   */\n  private static Builder = class ConditionBuilder<M extends Model>\n    implements ConditionBuilderOption<M>, AttributeOption<M>\n  {\n    attr1?: keyof M | Condition<M> = undefined;\n    operator?: Operator | GroupOperator = undefined;\n    comparison?: any = undefined;\n\n    /**\n     * @description Sets the attribute for the condition\n     * @summary Specifies which model attribute the condition will operate on\n     * @param attr - The model attribute to use in the condition\n     * @return {AttributeOption<M>} This builder instance for method chaining\n     */\n    attribute(attr: keyof M): AttributeOption<M> {\n      this.attr1 = attr;\n      return this;\n    }\n\n    /**\n     * @description Alias for the attribute method\n     * @summary Shorthand method to specify which model attribute the condition will operate on\n     * @param attr - The model attribute to use in the condition\n     * @return {AttributeOption<M>} This builder instance for method chaining\n     */\n    attr(attr: keyof M) {\n      return this.attribute(attr);\n    }\n\n    /**\n     * @description Creates an equality condition\n     * @summary Builds a condition that checks if the attribute equals the specified value\n     * @param {any} val - The value to compare the attribute against\n     * @return {Condition<M>} A new condition representing the equality comparison\n     */\n    eq(val: any) {\n      return this.setOp(Operator.EQUAL, val);\n    }\n\n    /**\n     * @description Creates an inequality condition\n     * @summary Builds a condition that checks if the attribute is different from the specified value\n     * @param {any} val - The value to compare the attribute against\n     * @return {Condition<M>} A new condition representing the inequality comparison\n     */\n    dif(val: any) {\n      return this.setOp(Operator.DIFFERENT, val);\n    }\n\n    /**\n     * @description Creates a greater than condition\n     * @summary Builds a condition that checks if the attribute is greater than the specified value\n     * @param {any} val - The value to compare the attribute against\n     * @return {Condition<M>} A new condition representing the greater than comparison\n     */\n    gt(val: any) {\n      return this.setOp(Operator.BIGGER, val);\n    }\n\n    /**\n     * @description Creates a less than condition\n     * @summary Builds a condition that checks if the attribute is less than the specified value\n     * @param {any} val - The value to compare the attribute against\n     * @return {Condition<M>} A new condition representing the less than comparison\n     */\n    lt(val: any) {\n      return this.setOp(Operator.SMALLER, val);\n    }\n\n    /**\n     * @description Creates a greater than or equal to condition\n     * @summary Builds a condition that checks if the attribute is greater than or equal to the specified value\n     * @param {any} val - The value to compare the attribute against\n     * @return {Condition<M>} A new condition representing the greater than or equal comparison\n     */\n    gte(val: any) {\n      return this.setOp(Operator.BIGGER_EQ, val);\n    }\n\n    /**\n     * @description Creates a less than or equal to condition\n     * @summary Builds a condition that checks if the attribute is less than or equal to the specified value\n     * @param {any} val - The value to compare the attribute against\n     * @return {Condition<M>} A new condition representing the less than or equal comparison\n     */\n    lte(val: any) {\n      return this.setOp(Operator.SMALLER_EQ, val);\n    }\n\n    /**\n     * @description Creates an inclusion condition\n     * @summary Builds a condition that checks if the attribute value is included in the specified array\n     * @param {any[]} arr - The array of values to check against\n     * @return {Condition<M>} A new condition representing the inclusion comparison\n     */\n    in(arr: any[]) {\n      return this.setOp(Operator.IN, arr);\n    }\n\n    /**\n     * @description Creates a regular expression condition\n     * @summary Builds a condition that checks if the attribute matches the specified regular expression pattern\n     * @param {any} val - The regular expression pattern to match against\n     * @return {Condition<M>} A new condition representing the regular expression comparison\n     */\n    regexp(val: any) {\n      return this.setOp(Operator.REGEXP, new RegExp(val).source);\n    }\n\n    /**\n     * @description Sets the operator and comparison value for the condition\n     * @summary Private method that configures the condition with the specified operator and value\n     * @param {Operator} op - The operator to use for the condition\n     * @param {any} val - The value to compare against\n     * @return {Condition<M>} A new condition with the specified operator and value\n     */\n    private setOp(op: Operator, val: any) {\n      this.operator = op;\n      this.comparison = val;\n      return this.build();\n    }\n\n    /**\n     * @description Constructs a Condition instance from the builder's state\n     * @summary Finalizes the condition building process by creating a new Condition instance\n     * @throws {QueryError} If the condition cannot be built due to invalid parameters\n     * @return {Condition<M>} A new condition instance with the configured attributes\n     */\n    private build(): Condition<M> {\n      try {\n        return new Condition(\n          this.attr1 as string | Condition<M>,\n          this.operator as Operator,\n          this.comparison as any\n        );\n      } catch (e: any) {\n        throw new QueryError(e);\n      }\n    }\n  };\n\n  /**\n   * @description Creates a new condition builder\n   * @summary Factory method that returns a new instance of the condition builder\n   * @template M - The model type this condition builder will operate on\n   * @return {ConditionBuilderOption<M>} A new condition builder instance\n   */\n  static builder<M extends Model>(): ConditionBuilderOption<M> {\n    return new Condition.Builder<M>();\n  }\n}\n"]}