ismx-nexo-node-app 0.4.74 → 0.4.76

package/dist/js/business/utils/ArrayUtils.js

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class ArrayUtils {
+    /**
+     * Compares two arrays for equality, checking if all elements are identical and in the same order.
+     *
+     * @param {any[]} [first] - The first array to be compared.
+     * @param {any[]} [second] - The second array to be compared.
+     * @return {boolean} Returns true if both arrays are equal, false otherwise.
+     */
     static equals(first, second) {
         if (first === undefined && second === undefined)
             return true;
@@ -10,5 +17,65 @@ class ArrayUtils {
             return false;
         return first.every((value, index) => value === second[index]);
     }
+    /**
+     * Searches for an exact match of a value in the provided array. Returns a boolean
+     * indicating whether the value exists in the array.
+     *
+     * @param {any[]} arr - The array to search within. If not provided or null, the method will return false.
+     * @param {any} value - The value to search for in the array.
+     * @return {boolean} Returns true if the value exists in the array, otherwise false.
+     */
+    static findEq(arr, value) {
+        if (!arr || !value)
+            return false;
+        return !!arr.find(v => v === value);
+    }
+    /**
+     * Computes the symmetric difference between two arrays.
+     *
+     * @param {T[]} arr1 - The first array to compare.
+     * @param {T[]} arr2 - The second array to compare.
+     * @return {T[]} An array containing elements that are unique to each input array.
+     * @template T
+     */
+    static diff(arr1, arr2) {
+        const onlyInArr1 = ArrayUtils.subtract(arr1, arr2);
+        const onlyInArr2 = ArrayUtils.subtract(arr2, arr1);
+        return Array.from(new Set([...onlyInArr1, ...onlyInArr2]).values());
+    }
+    /**
+     * Toggles the presence of an item in an array. If the item exists in the array, it is removed;
+     * if it does not exist, it is added.
+     *
+     * @param {T[]} array - The array to modify by toggling the item.
+     * @param {T} item - The item to toggle in the array.
+     * @return {T[]} A new array with the item either added or removed.
+     */
+    static toggle(array, item) {
+        return array.includes(item)
+            ? array.filter(i => i !== item)
+            : [...array, item];
+    }
+    /**
+     * Converts a value into an array, wrapping it if necessary.
+     * If the input is already an array, it returns the input as-is.
+     *
+     * @param {T | T[]} value - The value or array to be unified into an array.
+     * @return {T[]} An array containing the input value(s).
+     */
+    static unify(value) {
+        return Array.isArray(value) ? value : [value];
+    }
+    /**
+     * Returns elements from the first array that are not present in the second array.
+     *
+     * @param {T[]} arr1 - The source array.
+     * @param {T[]} arr2 - The array containing elements to be excluded.
+     * @return {T[]} An array containing elements from arr1 that are not in arr2.
+     * @template T
+     */
+    static subtract(arr1, arr2) {
+        return arr1.filter(item => !arr2.includes(item));
+    }
 }
 exports.default = ArrayUtils;

package/dist/js/repository/RepositoryDatabasePostgres.js

@@ -156,8 +156,6 @@ class RepositoryDatabasePostgres extends RepositoryDatabase_1.default {
                 const camelKey = PostgresUtils_1.default.snakeToCamel(column);
                 return Object.prototype.hasOwnProperty.call(object, camelKey);
             });
-            if (columns.length === 0)
-                throw new Error(`No valid columns provided to update for table ${tableName}`);
             const params = columns.map((_, index) => `\$${index + 2}`).join(",");
             const values = [id, ...columns.map((column) => object[PostgresUtils_1.default.snakeToCamel(column)])];
             const query = `UPDATE ${schema}.${tableName} SET (${columns.join(",")}) = ROW(${params}) WHERE id = $1 RETURNING *`;

package/dist/types/business/utils/ArrayUtils.d.ts

@@ -1,3 +1,54 @@
 export default abstract class ArrayUtils {
+    /**
+     * Compares two arrays for equality, checking if all elements are identical and in the same order.
+     *
+     * @param {any[]} [first] - The first array to be compared.
+     * @param {any[]} [second] - The second array to be compared.
+     * @return {boolean} Returns true if both arrays are equal, false otherwise.
+     */
     static equals(first?: any[], second?: any[]): boolean;
+    /**
+     * Searches for an exact match of a value in the provided array. Returns a boolean
+     * indicating whether the value exists in the array.
+     *
+     * @param {any[]} arr - The array to search within. If not provided or null, the method will return false.
+     * @param {any} value - The value to search for in the array.
+     * @return {boolean} Returns true if the value exists in the array, otherwise false.
+     */
+    static findEq<T>(arr?: T[], value?: T): boolean;
+    /**
+     * Computes the symmetric difference between two arrays.
+     *
+     * @param {T[]} arr1 - The first array to compare.
+     * @param {T[]} arr2 - The second array to compare.
+     * @return {T[]} An array containing elements that are unique to each input array.
+     * @template T
+     */
+    static diff<T>(arr1: T[], arr2: T[]): T[];
+    /**
+     * Toggles the presence of an item in an array. If the item exists in the array, it is removed;
+     * if it does not exist, it is added.
+     *
+     * @param {T[]} array - The array to modify by toggling the item.
+     * @param {T} item - The item to toggle in the array.
+     * @return {T[]} A new array with the item either added or removed.
+     */
+    static toggle<T>(array: T[], item: T): T[];
+    /**
+     * Converts a value into an array, wrapping it if necessary.
+     * If the input is already an array, it returns the input as-is.
+     *
+     * @param {T | T[]} value - The value or array to be unified into an array.
+     * @return {T[]} An array containing the input value(s).
+     */
+    static unify<T>(value: T | T[]): T[];
+    /**
+     * Returns elements from the first array that are not present in the second array.
+     *
+     * @param {T[]} arr1 - The source array.
+     * @param {T[]} arr2 - The array containing elements to be excluded.
+     * @return {T[]} An array containing elements from arr1 that are not in arr2.
+     * @template T
+     */
+    static subtract<T>(arr1: T[], arr2: T[]): T[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ismx-nexo-node-app",
-  "version": "0.4.74",
+  "version": "0.4.76",
   "description": "",
   "scripts": {
     "build": "rm -rf ./dist && npx tsc",

package/src/main/node/business/BusinessState.ts

@@ -29,7 +29,7 @@ export default class BusinessState<Model>
 		for (let l in this.listeners)
 			try { this.listeners[l]?.(this.data); } catch (error) {}
 	}
-	
+
 	protected clone(data: Model): Model {
 		if (!data) return data;
 		return JSON.parse(JSON.stringify(data), this.reviver) as Model;

package/src/main/node/business/utils/ArrayUtils.ts

@@ -1,9 +1,80 @@
 export default abstract class ArrayUtils {
 
+	/**
+	 * Compares two arrays for equality, checking if all elements are identical and in the same order.
+	 *
+	 * @param {any[]} [first] - The first array to be compared.
+	 * @param {any[]} [second] - The second array to be compared.
+	 * @return {boolean} Returns true if both arrays are equal, false otherwise.
+	 */
 	static equals(first?: any[], second?: any[]): boolean {
 		if (first === undefined && second === undefined) return true;
 		if (first === undefined || second === undefined) return false;
 		if (first.length !== second.length) return false;
 		return first.every((value, index) => value === second[index]);
 	}
+
+	/**
+	 * Searches for an exact match of a value in the provided array. Returns a boolean
+	 * indicating whether the value exists in the array.
+	 *
+	 * @param {any[]} arr - The array to search within. If not provided or null, the method will return false.
+	 * @param {any} value - The value to search for in the array.
+	 * @return {boolean} Returns true if the value exists in the array, otherwise false.
+	 */
+	static findEq<T>(arr?: T[], value?: T): boolean {
+		if (!arr || !value) return false;
+		return !!arr.find(v => v === value);
+	}
+
+	/**
+	 * Computes the symmetric difference between two arrays.
+	 *
+	 * @param {T[]} arr1 - The first array to compare.
+	 * @param {T[]} arr2 - The second array to compare.
+	 * @return {T[]} An array containing elements that are unique to each input array.
+	 * @template T
+	 */
+	static diff<T>(arr1: T[], arr2: T[]): T[] {
+		const onlyInArr1 = ArrayUtils.subtract(arr1, arr2);
+		const onlyInArr2 = ArrayUtils.subtract(arr2, arr1);
+		return Array.from(new Set([...onlyInArr1, ...onlyInArr2]).values());
+	}
+
+	/**
+	 * Toggles the presence of an item in an array. If the item exists in the array, it is removed;
+	 * if it does not exist, it is added.
+	 *
+	 * @param {T[]} array - The array to modify by toggling the item.
+	 * @param {T} item - The item to toggle in the array.
+	 * @return {T[]} A new array with the item either added or removed.
+	 */
+	static toggle<T>(array: T[], item: T): T[] {
+		return array.includes(item)
+			? array.filter(i => i !== item)
+			: [...array, item];
+	}
+
+	/**
+	 * Converts a value into an array, wrapping it if necessary.
+	 * If the input is already an array, it returns the input as-is.
+	 *
+	 * @param {T | T[]} value - The value or array to be unified into an array.
+	 * @return {T[]} An array containing the input value(s).
+	 */
+	static unify<T>(value: T | T[]): T[] {
+		return Array.isArray(value) ? value : [value];
+	}
+
+	/**
+	 * Returns elements from the first array that are not present in the second array.
+	 *
+	 * @param {T[]} arr1 - The source array.
+	 * @param {T[]} arr2 - The array containing elements to be excluded.
+	 * @return {T[]} An array containing elements from arr1 that are not in arr2.
+	 * @template T
+	 */
+	static subtract<T>(arr1: T[], arr2: T[]): T[] {
+		return arr1.filter(item => !arr2.includes(item));
+	}
 }

package/src/main/node/repository/RepositoryDatabasePostgres.ts

@@ -131,8 +131,6 @@ export default class RepositoryDatabasePostgres extends RepositoryDatabase
             return Object.prototype.hasOwnProperty.call(object, camelKey);
         });
 
-        if (columns.length === 0) throw new Error(`No valid columns provided to update for table ${tableName}`);
-
         const params = columns.map((_, index) => `\$${index + 2}`).join(",");
         const values = [ id, ...columns.map((column) => object[PostgresUtils.snakeToCamel(column) as keyof T]) ];
         const query = `UPDATE ${schema}.${tableName} SET (${columns.join(",")}) = ROW(${params}) WHERE id = $1 RETURNING *`;