querier-ts 0.0.0 → 1.0.0

package/lib/core/validation/decorators/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./number-validaton"), exports);

package/lib/core/validation/decorators/number-validaton.d.ts

@@ -0,0 +1,36 @@
+import 'reflect-metadata';
+/**
+ * Sets a minimal value to be used as argument to the given parameter.
+ *
+ * @param value Minimal value to set.
+ *
+ * @returns Decorator function.
+ */
+export declare function min(value: number): (target: object, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * Sets a maximum value to be used as argument to the given parameter.
+ *
+ * @param value Maximal value to set.
+ *
+ * @returns Decorator function.
+ */
+export declare function max(value: number): (target: object, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * Marks the given parameter as an integer.
+ *
+ * @param target Class to which the parameter belongs.
+ * @param propertyKey Method name.
+ * @param parameterIndex Parameter index.
+ */
+export declare function integer(target: object, propertyKey: string | symbol, parameterIndex: number): void;
+/**
+ * Validates the property decorators `integer`, `min`, and `max`, throwing and error
+ * when the arguments passed to the parameters decorated by them are invalid.
+ *
+ * @param target Class to which the method belongs.
+ * @param propertyName Method name.
+ * @param descriptor Descriptor object.
+ *
+ * @throws {InvalidArgumentError} If an argument is invalid.
+ */
+export declare function validateNumbers(target: any, propertyName: string, descriptor: TypedPropertyDescriptor<any>): void;

package/lib/core/validation/decorators/number-validaton.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.min = min;
+exports.max = max;
+exports.integer = integer;
+exports.validateNumbers = validateNumbers;
+require("reflect-metadata");
+const type_guards_1 = require("../../../utils/functions/type-guards");
+const errors_1 = require("../../errors");
+const minMetadataKey = Symbol('min');
+const maxMetadataKey = Symbol('max');
+const integerMetadataKey = Symbol('integer');
+/**
+ * Sets a minimal value to be used as argument to the given parameter.
+ *
+ * @param value Minimal value to set.
+ *
+ * @returns Decorator function.
+ */
+function min(value) {
+    return (target, propertyKey, parameterIndex) => {
+        const minParameters = Reflect.getOwnMetadata(minMetadataKey, target, propertyKey) || [];
+        minParameters.push({
+            value,
+            index: parameterIndex,
+        });
+        Reflect.defineMetadata(minMetadataKey, minParameters, target, propertyKey);
+    };
+}
+/**
+ * Sets a maximum value to be used as argument to the given parameter.
+ *
+ * @param value Maximal value to set.
+ *
+ * @returns Decorator function.
+ */
+function max(value) {
+    return (target, propertyKey, parameterIndex) => {
+        const maxParameters = Reflect.getOwnMetadata(maxMetadataKey, target, propertyKey) || [];
+        maxParameters.push({
+            value,
+            index: parameterIndex,
+        });
+        Reflect.defineMetadata(maxMetadataKey, maxParameters, target, propertyKey);
+    };
+}
+/**
+ * Marks the given parameter as an integer.
+ *
+ * @param target Class to which the parameter belongs.
+ * @param propertyKey Method name.
+ * @param parameterIndex Parameter index.
+ */
+function integer(target, propertyKey, parameterIndex) {
+    const integerParameters = Reflect.getOwnMetadata(integerMetadataKey, target, propertyKey) || [];
+    integerParameters.push({
+        index: parameterIndex,
+    });
+    Reflect.defineMetadata(integerMetadataKey, integerParameters, target, propertyKey);
+}
+/**
+ * Validates the property decorators `integer`, `min`, and `max`, throwing and error
+ * when the arguments passed to the parameters decorated by them are invalid.
+ *
+ * @param target Class to which the method belongs.
+ * @param propertyName Method name.
+ * @param descriptor Descriptor object.
+ *
+ * @throws {InvalidArgumentError} If an argument is invalid.
+ */
+function validateNumbers(target, propertyName, descriptor) {
+    const method = descriptor.value;
+    descriptor.value = function () {
+        const minParams = Reflect.getOwnMetadata(minMetadataKey, target, propertyName) || [];
+        const maxParams = Reflect.getOwnMetadata(maxMetadataKey, target, propertyName) || [];
+        const integerParams = Reflect.getOwnMetadata(integerMetadataKey, target, propertyName) || [];
+        checkMinParams(propertyName, minParams, arguments);
+        checkMaxParams(propertyName, maxParams, arguments);
+        checkIntegerParams(propertyName, integerParams, arguments);
+        return method.apply(this, arguments);
+    };
+}
+function checkMinParams(methodName, params, actualArguments) {
+    for (const parameter of params) {
+        const actualValue = actualArguments[parameter.index];
+        const minValue = parameter.value;
+        if (!(0, type_guards_1.isNumber)(actualValue) || actualValue < minValue) {
+            throw new errors_1.InvalidArgumentError({
+                method: methodName,
+                param: parameter.index,
+                argument: actualValue,
+                expected: `equal or greater than ${minValue}`,
+            });
+        }
+    }
+}
+function checkMaxParams(methodName, params, actualArguments) {
+    for (const parameter of params) {
+        const actualValue = actualArguments[parameter.index];
+        const maxValue = parameter.value;
+        if (!(0, type_guards_1.isNumber)(actualValue) || actualValue > maxValue) {
+            throw new errors_1.InvalidArgumentError({
+                method: methodName,
+                param: parameter.index,
+                argument: actualValue,
+                expected: `equal or less than ${maxValue}`,
+            });
+        }
+    }
+}
+function checkIntegerParams(methodName, params, actualArguments) {
+    for (const { index } of params) {
+        const actualValue = actualArguments[index];
+        if (!Number.isSafeInteger(actualValue)) {
+            throw new errors_1.InvalidArgumentError({
+                method: methodName,
+                param: index,
+                argument: actualValue,
+                expected: 'an integer',
+            });
+        }
+    }
+}

package/lib/core/validation/index.d.ts

@@ -0,0 +1 @@
+export * from './query-row-validator';

package/lib/core/validation/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./query-row-validator"), exports);

package/lib/core/validation/query-row-validator.d.ts

@@ -0,0 +1,57 @@
+import { QueryRowValidatorInitializer } from '../types';
+/**
+ * Validates a row in the query.
+ */
+export declare class QueryRowValidator<T extends object> {
+    /**
+     * Row to be validated.
+     */
+    private row;
+    /**
+     * Conditions to be applied to the row.
+     */
+    private conditionsObject;
+    /**
+     * Indicates whether conditions with `null` and `undefined` values should be
+     * skipped.
+     */
+    private ignoreNullValues;
+    /**
+     * Initializes the validator.
+     *
+     * @param row Row to validated.
+     * @param config Validator configuration.
+     */
+    private constructor();
+    /**
+     * Validates a row.
+     *
+     * @param row Row to validated.
+     * @param config Validator configuration.
+     */
+    static validate<T extends object>(row: T, config: QueryRowValidatorInitializer<T>): boolean;
+    /**
+     * Validates all conditions of the row.
+     *
+     * @returns Validation result.
+     */
+    private validate;
+    /**
+     * Validate a condition to a specific column.
+     *
+     * @param columnName Column name.
+     * @param condition Condition to be validated.
+     *
+     * @returns Validation result.
+     */
+    private validateColumnCondition;
+    /**
+     * Validates an object inside the row.
+     *
+     * @param obj Object to validated.
+     * @param conditionsObject Conditions to be applied to the object.
+     *
+     * @returns Validation result.
+     */
+    private validateInnerObject;
+}

package/lib/core/validation/query-row-validator.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryRowValidator = void 0;
+const generic_1 = require("../../utils/functions/generic");
+const type_guards_1 = require("../../utils/functions/type-guards");
+/**
+ * Validates a row in the query.
+ */
+class QueryRowValidator {
+    /**
+     * Initializes the validator.
+     *
+     * @param row Row to validated.
+     * @param config Validator configuration.
+     */
+    constructor(row, config) {
+        this.row = row;
+        this.conditionsObject = config.conditionsObject;
+        this.ignoreNullValues = config.ignoreNullValues;
+    }
+    /**
+     * Validates a row.
+     *
+     * @param row Row to validated.
+     * @param config Validator configuration.
+     */
+    static validate(row, config) {
+        const validator = new QueryRowValidator(row, config);
+        return validator.validate();
+    }
+    /**
+     * Validates all conditions of the row.
+     *
+     * @returns Validation result.
+     */
+    validate() {
+        const conditionsEntries = (0, generic_1.getEntries)(this.conditionsObject);
+        return conditionsEntries.every(([columnName, condition]) => this.validateColumnCondition(columnName, condition));
+    }
+    /**
+     * Validate a condition to a specific column.
+     *
+     * @param columnName Column name.
+     * @param condition Condition to be validated.
+     *
+     * @returns Validation result.
+     */
+    validateColumnCondition(columnName, condition) {
+        if (this.ignoreNullValues &&
+            (condition === null || condition === undefined)) {
+            return true;
+        }
+        const cellValue = this.row[columnName];
+        if ((0, type_guards_1.isFunction)(condition)) {
+            return condition(cellValue);
+        }
+        if (Array.isArray(condition)) {
+            return Array.isArray(cellValue)
+                ? (0, generic_1.compareArrays)(cellValue, condition)
+                : false;
+        }
+        if ((0, type_guards_1.isObject)(condition)) {
+            return (0, type_guards_1.isObject)(cellValue)
+                ? this.validateInnerObject(cellValue, condition)
+                : false;
+        }
+        return cellValue === condition;
+    }
+    /**
+     * Validates an object inside the row.
+     *
+     * @param obj Object to validated.
+     * @param conditionsObject Conditions to be applied to the object.
+     *
+     * @returns Validation result.
+     */
+    validateInnerObject(obj, conditionsObject) {
+        return QueryRowValidator.validate(obj, {
+            conditionsObject,
+            ignoreNullValues: this.ignoreNullValues,
+        });
+    }
+}
+exports.QueryRowValidator = QueryRowValidator;

package/lib/index.d.ts

@@ -1,2 +1 @@
-import { Query } from './query';
-export { Query };
+export * from './query';

package/lib/index.js

@@ -1,5 +1,17 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Query = void 0;
-const query_1 = require("./query");
-Object.defineProperty(exports, "Query", { enumerable: true, get: function () { return query_1.Query; } });
+__exportStar(require("./query"), exports);

package/lib/query.d.ts

@@ -1,6 +1,5 @@
+import { QueryConditionsGroup, QueryConditionsGroupNullable } from './core/types';
 import { addPrefixToObject, PropertyOnly, PropOf } from './utils/types';
-import { QueryConditionsGroup } from './query-conditions-group';
-import { QueryConditionsGroupNullable } from './query-conditions-group-nullable';
 /**
  * Allows filtering data from an array of objects.
  *
@@ -57,30 +56,29 @@ export declare class Query<T extends object> {
     /**
      * Initializes the query.
      *
-     * @param {T[]} rows Rows to be queried.
+     * @param rows Rows to be queried.
      */
     private constructor();
     /**
      * Creates a new query based on the given data.
      *
-     * @param {T[]} rows Rows to be queried.
+     * @param rows Rows to be queried.
      *
-     * @returns {Query<T>} Query to the given rows.
+     * @returns Query to the given rows.
      */
     static from<T extends object>(rows: T[]): Query<T>;
     /**
      * Defines specific columns to be returned on the final results.
      *
-     * @param {PropOf<T> | PropOf<T>[]} columns Selected columns.
+     * @param columns Selected columns.
      *
-     * @returns {this} Current query.
+     * @returns Current query.
      */
     select(columns: PropOf<T> | PropOf<T>[]): this;
     /**
      * Applies conditions to the query.
      *
-     * @param {QueryConditionsGroup<T> | ((obj: T) => boolean)} condition Filter to
-     * be applied to the query.
+     * @param condition Filter to be applied to the query.
      *
      * If a callback function is provided, it must return a boolean value.
      *
@@ -88,87 +86,86 @@ export declare class Query<T extends object> {
      * corresponding values must be the expected values for the attributes or a
      * callback functions that return boolean values.
      *
-     * @returns {this} Current query.
+     * @returns Current query.
      */
     where(condition: QueryConditionsGroup<T> | ((obj: T) => boolean)): this;
     /**
      * Applies a set of conditions to the query ignoring `null` and `undefined`
      * values as conditions.
      *
-     * @param {QueryConditionsGroupNullable<T>} condition An object where each
-     * property represents an attribute to be validated. The values can be
-     * literal or callback functions that return a boolean. If `null` or `undefined`
-     * is passed, that condition will be skipped.
+     * @param condition An object where each property represents an attribute
+     * to be validated. The values can be literal or callback functions that
+     * return a boolean. If `null` or `undefined` is passed, that condition
+     * will be skipped.
      *
-     * @returns {this} Current query.
+     * @returns Current query.
      */
     filterWhere(condition: QueryConditionsGroupNullable<T>): this;
     /**
      * Adds ordering to the results.
      *
-     * @param {(PropOf<T> | keyof addPrefixToObject<PropertyOnly<T>, '-'>)[]} columns
-     * Ascending or descending columns. To mark a field as descending, use `-` before
-     * its name.
+     * @param columns Ascending or descending columns. To mark a field as
+     * descending, use `-` before its name.
      *
-     * @returns {this} Current query.
+     * @returns Current query.
      */
     orderBy(...columns: (PropOf<T> | keyof addPrefixToObject<PropertyOnly<T>, '-'>)[]): this;
     /**
      * Returns the current number of rows.
      *
-     * @return {number}
+     * @return Filtered rows count.
      */
     count(): number;
     /**
      * Checks if there is at least one row compatible with the query.
      *
-     * @returns {boolean} Boolean indicating whether any row exists.
+     * @returns Whether any row exists after filtering.
      */
     exists(): boolean;
     /**
      * Returns the first result.
      *
-     * @returns {T}
+     * @returns The first result.
      */
     first(): T | null;
     /**
      * Returns the last result.
      *
-     * @returns {T}
+     * @returns The last result.
      */
     last(): T | null;
     /**
      * Returns all results.
      *
-     * @returns {T[]}
+     * @returns All filtered rows.
      */
     all(): T[];
     /**
      * Returns the value of the first (selected) column of the first row.
      *
-     * @returns {T[Promise<T>]|false} First value or `false`, if none row exists.
+     * @returns First value or `false`, if none row exists.
      */
     scalar(): T[PropOf<T>] | false;
     /**
      * Returns the values of the first (selected) column of all rows.
      *
-     * @returns {T[Promise<T>][]} Values from the first (selected) column.
+     * @returns Values from the first (selected) column.
      */
     column(): T[PropOf<T>][];
     /**
      * Returns the values of the rows. If there are selected columns, only their
      * values will be returned.
      *
-     * @returns {T[PropOf<T>][][]} Array with the values of all rows.
+     * @returns Array with the values of all rows.
      */
     values(): T[PropOf<T>][][];
     /**
      * Defines the number of rows to skip.
      *
-     * @param {number} numberOfRows Numbers of rows to skip. Only non negative integer numbers
+     * @param numberOfRows Numbers of rows to skip. Only non negative integer numbers
      * are allowed.
      *
-     * @returns {this} Current query.
+     * @returns Current query.
      *
      * @throws {InvalidArgumentError} If the given number is less than 0.
      */
@@ -176,9 +173,9 @@ export declare class Query<T extends object> {
     /**
      * Defines a limit for the number of results.
      *
-     * @param {number} limit Limit of results. Only non negative integer numbers are allowed.
+     * @param limit Limit of results. Only non negative integer numbers are allowed.
      *
-     * @returns {this} Current query.
+     * @returns Current query.
      *
      * @throws {InvalidArgumentError} If the given limit is less than 0.
      */
@@ -186,28 +183,26 @@ export declare class Query<T extends object> {
     /**
      * Returns the rows that should be used in the final results.
      *
-     * @returns {T[]} Rows within the specified limit.
+     * @returns Rows within the specified limit.
      */
     private getLimitedRows;
     /**
      * Returns the first selected column or the first key of some row.
      *
-     * @returns {Promise<T>|null} The first column or `null`, if none is selected
-     * or there is no row.
+     * @returns The first column or `null`, if none is selected  or there is no row.
      */
     private getFirstColumn;
     /**
      * Filters the rows according to the given conditions.
      *
-     * @param {QueryConditionsGroupNullable<T> | ((obj: T) => boolean)} condition
-     * Object or callback function.
+     * @param condition Object or callback function.
      */
     private filterRows;
     /**
      * Validates a row based on the given conditions object.
      *
-     * @param {T} row Row to validate.
-     * @param {QueryConditionsGroupNullable<T>} condition Conditions object.
+     * @param row Row to validate.
+     * @param condition Conditions object.
      *
      * @returns {boolean} Validation result.
      */