inibase 1.0.0-rc.9 → 1.0.0-rc.91

package/dist/utils.js

@@ -0,0 +1,509 @@
+/**
+ * Type guard function to check if the input is an array of objects.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is an array of objects, false otherwise.
+ *
+ * Note: Considers empty arrays and arrays where every element is an object.
+ */
+export const isArrayOfObjects = (input) => Array.isArray(input) && (input.length === 0 || input.every(isObject));
+/**
+ * Type guard function to check if the input is an array of arrays.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is an array of arrays, false otherwise.
+ *
+ * Note: Considers empty arrays and arrays where every element is also an array.
+ */
+export const isArrayOfArrays = (input) => Array.isArray(input) && (input.length === 0 || input.every(Array.isArray));
+/**
+ * Type guard function to check if the input is an array of nulls or an array of arrays of nulls.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is an array consisting entirely of nulls or arrays of nulls, false otherwise.
+ *
+ * Note: Recursively checks each element, allowing for nested arrays of nulls.
+ */
+export const isArrayOfNulls = (input) => input.every((_input) => Array.isArray(_input) ? isArrayOfNulls(_input) : _input === null);
+/**
+ * Type guard function to check if the input is an object.
+ *
+ * @param obj - The value to be checked.
+ * @returns boolean - True if the input is an object (excluding arrays), false otherwise.
+ *
+ * Note: Checks if the input is non-null and either has 'Object' as its constructor name or is of type 'object' without being an array.
+ */
+export const isObject = (obj) => obj != null &&
+    (obj.constructor.name === "Object" ||
+        (typeof obj === "object" && !Array.isArray(obj)));
+/**
+ * Recursively merges properties from a source object into a target object. If a property exists in both, the source's value overwrites the target's.
+ *
+ * @param target - The target object to merge properties into.
+ * @param source - The source object from which properties are merged.
+ * @returns any - The modified target object with merged properties.
+ *
+ * Note: Performs a deep merge for nested objects. Non-object properties are directly overwritten.
+ */
+export const deepMerge = (target, source) => {
+    for (const key in source) {
+        if (Object.hasOwn(source, key)) {
+            if (isObject(source[key]) && isObject(target[key]))
+                target[key] = deepMerge(target[key], source[key]);
+            else if (source[key] !== null)
+                target[key] = source[key];
+        }
+    }
+    return target;
+};
+/**
+ * Type guard function to check if the input is a number.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a number, false otherwise.
+ *
+ * Note: Validates that the input can be parsed as a float and that subtracting zero results in a number, ensuring it's a numeric value.
+ */
+export const isNumber = (input) => !Number.isNaN(Number.parseFloat(input)) && !Number.isNaN(input - 0);
+/**
+ * Checks if the input is a valid email format.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input matches the email format, false otherwise.
+ *
+ * Note: Uses a regular expression to validate the email format, ensuring it has parts separated by '@' and contains a domain with a period.
+ */
+export const isEmail = (input) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(input));
+/**
+ * Checks if the input is a valid URL format.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input matches the URL format, false otherwise.
+ *
+ * Note: Validates URLs including protocols (http/https), domain names, IP addresses, ports, paths, query strings, and fragments.
+ *       Also recognizes 'tel:' and 'mailto:' as valid URL formats, as well as strings starting with '#' without spaces.
+ */
+export const isURL = (input) => {
+    if (typeof input !== "string")
+        return false;
+    if ((input[0] === "#" && !input.includes(" ")) ||
+        input.startsWith("tel:") ||
+        input.startsWith("mailto:"))
+        return true;
+    const pattern = new RegExp("^(https?:\\/\\/)?" + // protocol
+        "((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|" + // domain name
+        "localhost|" + // OR localhost
+        "((\\d{1,3}\\.){3}\\d{1,3}))" + // OR ip (v4) address
+        "(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*" + // port and path
+        "(\\?[;&a-z\\d%_.~+=-]*)?" + // query string
+        "(\\#[-a-z\\d_]*)?$", "i"); // fragment locator
+    return !!pattern.test(input);
+};
+/**
+ * Checks if the input contains HTML tags or entities.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input contains HTML tags or entities, false otherwise.
+ *
+ * Note: Uses a regular expression to detect HTML tags (like <tag>) and entities (like &entity;).
+ *       Recognizes both opening and closing tags, as well as self-closing tags.
+ */
+export const isHTML = (input) => /<\/?\s*[a-z-][^>]*\s*>|(\&(?:[\w\d]+|#\d+|#x[a-f\d]+);)/g.test(input);
+/**
+ * Type guard function to check if the input is a string, excluding strings that match specific formats (number, boolean, email, URL, IP).
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a string that doesn't match the specific formats, false otherwise.
+ *
+ * Note: Validates the input against being a number, boolean, email, URL, or IP address to ensure it's a general string.
+ */
+export const isString = (input) => Object.prototype.toString.call(input) === "[object String]" &&
+    (!isNumber(input) || String(input).at(0) === "0");
+/**
+ * Checks if the input is a valid IP address format.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input matches the IP address format, false otherwise.
+ *
+ * Note: Uses a regular expression to validate IP addresses, ensuring they consist of four octets, each ranging from 0 to 255.
+ */
+export const isIP = (input) => /^(?:(?:^|\.)(?:2(?:5[0-5]|[0-4]\d)|1?\d?\d)){4}$/.test(input);
+/**
+ * Type guard function to check if the input is a boolean or a string representation of a boolean.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a boolean value or 'true'/'false' strings, false otherwise.
+ *
+ * Note: Recognizes both boolean literals (true, false) and their string representations ("true", "false").
+ */
+export const isBoolean = (input) => typeof input === "boolean" || input === "true" || input === "false";
+/**
+ * Type guard function to check if the input is a password based on a specific length criterion.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a string with a length of 161 characters, false otherwise.
+ *
+ * Note: Specifically checks for string length to determine if it matches the defined password length criterion.
+ */
+export const isPassword = (input) => typeof input === "string" && input.length === 97;
+/**
+ * Checks if the input can be converted to a valid date.
+ *
+ * @param input - The input to be checked, can be of any type.
+ * @returns A boolean indicating whether the input is a valid date.
+ */
+export const isDate = (input) => !Number.isNaN(new Date(input).getTime()) ||
+    !Number.isNaN(Date.parse(input)) ||
+    !!input.match(/\b\d{2}[/.-]\d{2}[/.-]\d{4}\b/);
+/**
+ * Checks if the input is a valid ID.
+ *
+ * @param input - The input to be checked, can be of any type.
+ * @returns A boolean indicating whether the input is a string representing a valid ID of length 32.
+ */
+export const isValidID = (input) => {
+    return typeof input === "string" && input.length === 32;
+};
+/**
+ * Checks if a given string is a valid JSON.
+ *
+ * @param {string} str - The string to be checked.
+ * @returns {boolean} Returns true if the string is valid JSON, otherwise false.
+ */
+export const isJSON = (str) => str === "null" || str === "undefined" || str[0] === "{" || str[0] === "[";
+/**
+ * Identifies and returns properties that have changed between two objects.
+ *
+ * @param obj1 - The first object for comparison, with string keys and values.
+ * @param obj2 - The second object for comparison, with string keys and values.
+ * @returns A record of changed properties with original values from obj1 and new values from obj2, or null if no changes are found.
+ */
+export const findChangedProperties = (obj1, obj2) => {
+    const result = {};
+    for (const key1 in obj1)
+        if (Object.hasOwn(obj2, key1) && obj1[key1] !== obj2[key1])
+            result[obj1[key1]] = obj2[key1];
+    return Object.keys(result).length ? result : null;
+};
+/**
+ * Detects the field type of an input based on available types.
+ *
+ * @param input - The input whose field type is to be detected.
+ * @param availableTypes - An array of potential field types to consider.
+ * @returns The detected field type as a string, or undefined if no matching type is found.
+ */
+export const detectFieldType = (input, availableTypes) => {
+    if (input !== null && input !== undefined)
+        if (!Array.isArray(input)) {
+            if ((input === "0" ||
+                input === "1" ||
+                input === "true" ||
+                input === "false") &&
+                availableTypes.includes("boolean"))
+                return "boolean";
+            if (isNumber(input)) {
+                if (availableTypes.includes("table"))
+                    return "table";
+                if (availableTypes.includes("date"))
+                    return "date";
+                if (availableTypes.includes("number"))
+                    return "number";
+                if (availableTypes.includes("string") && String(input).at(0) === "0")
+                    return "string";
+            }
+            else if (typeof input === "string") {
+                if (availableTypes.includes("table") && isValidID(input))
+                    return "table";
+                if (input.startsWith("[") && availableTypes.includes("array"))
+                    return "array";
+                if (availableTypes.includes("email") && isEmail(input))
+                    return "email";
+                if (availableTypes.includes("url") && isURL(input))
+                    return "url";
+                if (availableTypes.includes("password") && isPassword(input))
+                    return "password";
+                if (availableTypes.includes("json") && isJSON(input))
+                    return "json";
+                if (availableTypes.includes("json") && isDate(input))
+                    return "json";
+                if (availableTypes.includes("string") && isString(input))
+                    return "string";
+                if (availableTypes.includes("ip") && isIP(input))
+                    return "ip";
+            }
+        }
+        else
+            return "array";
+    return undefined;
+};
+export const isFieldType = (compareAtType, fieldType, fieldChildrenType) => {
+    if (fieldType) {
+        if (Array.isArray(fieldType)) {
+            if (fieldType.some((type) => Array.isArray(compareAtType)
+                ? compareAtType.includes(type)
+                : compareAtType === type))
+                return true;
+        }
+        else if ((Array.isArray(compareAtType) && compareAtType.includes(fieldType)) ||
+            compareAtType === fieldType)
+            return true;
+    }
+    if (fieldChildrenType) {
+        if (Array.isArray(fieldChildrenType)) {
+            if (!isArrayOfObjects(fieldChildrenType)) {
+                if (fieldChildrenType.some((type) => Array.isArray(compareAtType)
+                    ? compareAtType.includes(type)
+                    : compareAtType === type))
+                    return true;
+            }
+        }
+        else if ((Array.isArray(compareAtType) &&
+            compareAtType.includes(fieldChildrenType)) ||
+            compareAtType === fieldChildrenType)
+            return true;
+    }
+    return false;
+};
+// Function to recursively flatten an array of objects and their nested children
+export const flattenSchema = (schema, keepParents = false) => {
+    const result = [];
+    function _flattenHelper(item, parentKey) {
+        if (item.children && isArrayOfObjects(item.children)) {
+            if (keepParents)
+                result.push((({ children, ...rest }) => rest)(item));
+            for (const child of item.children)
+                _flattenHelper(child, item.key);
+        }
+        else
+            result.push({
+                ...item,
+                key: parentKey ? `${parentKey}.${item.key}` : item.key,
+            });
+    }
+    for (const item of schema)
+        _flattenHelper(item, "");
+    return result;
+};
+export const filterSchema = (schema, callback) => schema.filter((field) => {
+    if (field.children && isArrayOfObjects(field.children))
+        field.children = filterSchema(field.children, callback);
+    return callback(field);
+});
+/**
+ * Validates if the given value matches the specified field type(s).
+ *
+ * @param value - The value to be validated.
+ * @param fieldType - The expected field type or an array of possible field types.
+ * @param fieldChildrenType - Optional; the expected type(s) of children elements, used if the field type is an array.
+ * @returns A boolean indicating whether the value matches the specified field type(s).
+ */
+export const validateFieldType = (value, fieldType, fieldChildrenType) => {
+    if (value === null)
+        return true;
+    if (Array.isArray(fieldType)) {
+        const detectedFieldType = detectFieldType(value, fieldType);
+        if (!detectedFieldType)
+            return false;
+        fieldType = detectedFieldType;
+    }
+    if (fieldType === "array" && fieldChildrenType)
+        return value.every((v) => {
+            let _fieldChildrenType = fieldChildrenType;
+            if (Array.isArray(_fieldChildrenType)) {
+                const detectedFieldType = detectFieldType(v, _fieldChildrenType);
+                if (!detectedFieldType)
+                    return false;
+                _fieldChildrenType = detectedFieldType;
+            }
+            return validateFieldType(v, _fieldChildrenType);
+        });
+    switch (fieldType) {
+        case "string":
+            return isString(value);
+        case "password":
+            return !Array.isArray(value) && !isObject(value); // accept
+        case "number":
+            return isNumber(value);
+        case "html":
+            return isHTML(value);
+        case "ip":
+            return isIP(value);
+        case "boolean":
+            return isBoolean(value);
+        case "date":
+            return isDate(value);
+        case "object":
+            return isObject(value);
+        case "array":
+            return Array.isArray(value);
+        case "email":
+            return isEmail(value);
+        case "url":
+            return isURL(value);
+        case "table":
+            // feat: check if id exists
+            if (Array.isArray(value))
+                return ((isArrayOfObjects(value) &&
+                    value.every((element) => Object.hasOwn(element, "id") &&
+                        (isValidID(element.id) || isNumber(element.id)))) ||
+                    value.every(isNumber) ||
+                    isValidID(value));
+            if (isObject(value))
+                return (Object.hasOwn(value, "id") &&
+                    (isValidID(value.id) || isNumber(value.id)));
+            return isNumber(value) || isValidID(value);
+        case "id":
+            return isNumber(value) || isValidID(value);
+        case "json":
+            return isJSON(value) || Array.isArray(value) || isObject(value);
+        default:
+            return false;
+    }
+};
+export function FormatObjectCriteriaValue(value) {
+    switch (value[0]) {
+        case ">":
+        case "<":
+            return value[1] === "="
+                ? [
+                    value.slice(0, 2),
+                    value.slice(2),
+                ]
+                : [
+                    value.slice(0, 1),
+                    value.slice(1),
+                ];
+        case "[":
+            return value[1] === "]"
+                ? [
+                    value.slice(0, 2),
+                    value.slice(2).toString().split(","),
+                ]
+                : ["[]", value.slice(1)];
+        case "!":
+            return ["=", "*"].includes(value[1])
+                ? [
+                    value.slice(0, 2),
+                    value.slice(2),
+                ]
+                : value[1] === "["
+                    ? [
+                        value.slice(0, 3),
+                        value.slice(3),
+                    ]
+                    : [
+                        `${value.slice(0, 1)}=`,
+                        value.slice(1),
+                    ];
+        case "=":
+            return [
+                value.slice(0, 1),
+                value.slice(1),
+            ];
+        case "*":
+            return [
+                value.slice(0, 1),
+                value.slice(1),
+            ];
+        default:
+            return ["=", value];
+    }
+}
+/**
+ * Get field from schema
+ *
+ * @export
+ * @param {string} keyPath Support dot notation path
+ * @param {Schema} schema
+ */
+export function getField(keyPath, schema) {
+    let RETURN = schema;
+    const keyPathSplited = keyPath.split(".");
+    for (const [index, key] of keyPathSplited.entries()) {
+        if (!isArrayOfObjects(RETURN))
+            return null;
+        const foundItem = RETURN.find((item) => item.key === key);
+        if (!foundItem)
+            return null;
+        if (index === keyPathSplited.length - 1)
+            RETURN = foundItem;
+        if ((foundItem.type === "array" || foundItem.type === "object") &&
+            foundItem.children &&
+            isArrayOfObjects(foundItem.children))
+            RETURN = foundItem.children;
+    }
+    if (!RETURN)
+        return null;
+    return isArrayOfObjects(RETURN) ? RETURN[0] : RETURN;
+}
+/**
+ * Override a schema field, key, type or other properties
+ *
+ * @export
+ * @param {string} keyPath Support dot notation path
+ * @param {Schema} schema
+ * @param {(Omit<Field, "key" | "type"> & {
+ * 		key?: string;
+ * 		type?: FieldType | FieldType[];
+ * 	})} field
+ */
+export function setField(keyPath, schema, field) {
+    const keyPathSplited = keyPath.split(".");
+    for (const [index, key] of keyPathSplited.entries()) {
+        const foundItem = schema.find((item) => item.key === key);
+        if (!foundItem)
+            return null;
+        if (index === keyPathSplited.length - 1) {
+            Object.assign(foundItem, field);
+            return foundItem;
+        }
+        if ((foundItem.type === "array" || foundItem.type === "object") &&
+            foundItem.children &&
+            isArrayOfObjects(foundItem.children))
+            schema = foundItem.children;
+    }
+}
+/**
+ * Remove field from schema
+ *
+ * @export
+ * @param {string} keyPath Support dot notation path
+ * @param {Schema} schema
+ */
+export function unsetField(keyPath, schema) {
+    const keyPathSplited = keyPath.split(".");
+    let parent = null;
+    let targetIndex;
+    for (const [index, key] of keyPathSplited.entries()) {
+        const foundItem = schema.find((item) => item.key === key);
+        if (!foundItem)
+            return null;
+        if (index === keyPathSplited.length - 1) {
+            if (parent) {
+                if (Array.isArray(parent)) {
+                    if (targetIndex !== undefined)
+                        parent.splice(targetIndex, 1);
+                }
+                else
+                    delete parent[key];
+            }
+            else {
+                const indexToRemove = schema.indexOf(foundItem);
+                if (indexToRemove !== -1)
+                    schema.splice(indexToRemove, 1);
+            }
+            return foundItem;
+        }
+        if ((foundItem.type === "array" || foundItem.type === "object") &&
+            foundItem.children &&
+            isArrayOfObjects(foundItem.children)) {
+            parent = foundItem.children;
+            targetIndex = schema.indexOf(foundItem);
+            schema = foundItem.children;
+        }
+        else {
+            parent = foundItem;
+            targetIndex = undefined;
+        }
+    }
+}

package/dist/utils.server.d.ts

@@ -0,0 +1,83 @@
+import { exec as execSync, execFile as execFileSync } from "node:child_process";
+import { gunzip as gunzipSync, gzip as gzipSync } from "node:zlib";
+import type { ComparisonOperator, Field, FieldType, Schema } from "./index.js";
+export declare const exec: typeof execSync.__promisify__;
+export declare const execFile: typeof execFileSync.__promisify__;
+export declare const gzip: typeof gzipSync.__promisify__;
+export declare const gunzip: typeof gunzipSync.__promisify__;
+/**
+ * Generates a hashed password using SHA-256.
+ *
+ * @param password - The plain text password to hash.
+ * @returns A string containing the salt and the hashed password, separated by a colon.
+ */
+export declare const hashPassword: (password: string) => string;
+/**
+ * Compares a hashed password with an input password to verify a match.
+ *
+ * @param hashedPassword - The hashed password, containing both the salt and the hash, separated by a colon.
+ * @param inputPassword - The plain text input password to compare against the hashed password.
+ * @returns A boolean indicating whether the input password matches the hashed password.
+ */
+export declare const comparePassword: (hash: string, password: string) => boolean;
+export declare const encodeID: (id: number | string, secretKeyOrSalt: string | number | Buffer) => string;
+export declare const decodeID: (input: string, secretKeyOrSalt: string | number | Buffer) => number;
+export declare const extractIdsFromSchema: (schema: Schema, secretKeyOrSalt: string | number | Buffer) => number[];
+/**
+ * Finds the last ID number in a schema, potentially decoding it if encrypted.
+ *
+ * @param schema - The schema to search, defined as an array of schema objects.
+ * @param secretKeyOrSalt - The secret key or salt for decoding an encrypted ID, can be a string, number, or Buffer.
+ * @returns The last ID number in the schema, decoded if necessary.
+ */
+export declare const findLastIdNumber: (schema: Schema, secretKeyOrSalt: string | number | Buffer) => number;
+/**
+ * Adds or updates IDs in a schema, encoding them using a provided secret key or salt.
+ *
+ * @param schema - The schema to update, defined as an array of schema objects.
+ * @param oldIndex - The starting index for generating new IDs, defaults to 0.
+ * @param secretKeyOrSalt - The secret key or salt for encoding IDs, can be a string, number, or Buffer.
+ * @param encodeIDs - If true, IDs will be encoded, else they will remain as numbers.
+ * @returns The updated schema with encoded IDs.
+ */
+export declare const addIdToSchema: (schema: Schema, startWithID: number, secretKeyOrSalt: string | number | Buffer, encodeIDs?: boolean) => Field[];
+export declare const encodeSchemaID: (schema: Schema, secretKeyOrSalt: string | number | Buffer) => Schema;
+export declare const hashString: (str: string) => string;
+/**
+ * Evaluates a comparison between two values based on a specified operator and field types.
+ *
+ * @param operator - The comparison operator (e.g., '=', '!=', '>', '<', '>=', '<=', '[]', '![]', '*', '!*').
+ * @param originalValue - The value to compare, can be a single value or an array of values.
+ * @param comparedValue - The value or values to compare against.
+ * @param fieldType - Optional type of the field to guide comparison (e.g., 'password', 'boolean').
+ * @param fieldChildrenType - Optional type for child elements in array inputs.
+ * @returns boolean - Result of the comparison operation.
+ *
+ * Note: Handles various data types and comparison logic, including special handling for passwords and regex patterns.
+ */
+export declare const compare: (operator: ComparisonOperator, originalValue: string | number | boolean | null | (string | number | boolean | null)[], comparedValue: string | number | boolean | null | (string | number | boolean | null)[], fieldType?: FieldType | FieldType[]) => boolean;
+/**
+ * Helper function to check equality based on the field type.
+ *
+ * @param originalValue - The original value.
+ * @param comparedValue - The value to compare against.
+ * @param fieldType - Type of the field.
+ * @returns boolean - Result of the equality check.
+ */
+export declare const isEqual: (originalValue: string | number | boolean | null | (string | number | boolean | null)[], comparedValue: string | number | boolean | null | (string | number | boolean | null)[], fieldType?: FieldType) => boolean;
+/**
+ * Helper function to check array equality.
+ *
+ * @param originalValue - The original value.
+ * @param comparedValue - The value to compare against.
+ * @returns boolean - Result of the array equality check.
+ */
+export declare const isArrayEqual: (originalValue: string | number | boolean | null | (string | number | boolean | null)[], comparedValue: string | number | boolean | null | (string | number | boolean | null)[]) => boolean;
+/**
+ * Helper function to check wildcard pattern matching using regex.
+ *
+ * @param originalValue - The original value.
+ * @param comparedValue - The value with wildcard pattern.
+ * @returns boolean - Result of the wildcard pattern matching.
+ */
+export declare const isWildcardMatch: (originalValue: string | number | boolean | null | (string | number | boolean | null)[], comparedValue: string | number | boolean | null | (string | number | boolean | null)[]) => boolean;