@wxn0brp/db-core 0.2.5 → 0.2.7

package/README.md

@@ -14,7 +14,11 @@ npm install @wxn0brp/db-core
 
 ## Documentation
 
-See the [documentation](docs/README.md) for more information about the API and usage.
+See [typedoc](https://wxn0brp.github.io/ValtheraDB-core/).
+
+## Contributing
+
+Contributions are welcome! Please submit pull requests or open issues on GitHub.
 
 ## License
 

package/dist/types/searchOpts.d.ts

@@ -33,6 +33,10 @@ export type ComparisonOperators<T = any> = {
     $between?: PartialOfType<T, [number, number], number>;
     $in?: Partial<Record<keyof T, T[keyof T][]>>;
     $nin?: Partial<Record<keyof T, T[keyof T][]>>;
+    $idGt?: PartialOfType<T, string | number>;
+    $idLt?: PartialOfType<T, string | number>;
+    $idGte?: PartialOfType<T, string | number>;
+    $idLte?: PartialOfType<T, string | number>;
 };
 /** Type and Existence Operators */
 export type TypeAndExistenceOperators<T = any> = {

package/dist/types/updater.d.ts

@@ -13,7 +13,8 @@ export type ArrayUpdater<T = any> = {
 };
 /** Objects */
 export type ObjectUpdater<T = any> = {
-    $merge?: PartialOfType<T, any[]>;
+    $merge?: PartialOfType<T, any>;
+    $deepMerge?: PartialOfType<T, any>;
 };
 /** Values */
 export type ValueUpdater<T = any> = {
@@ -21,5 +22,7 @@ export type ValueUpdater<T = any> = {
     $dec?: PartialOfType<T, number>;
     $unset?: PartialOfType<T, any>;
     $rename?: PartialOfType<T, any>;
+    /** same as { name: value } */
+    $set?: PartialOfType<T, any>;
 };
 export type UpdaterArg<T = any> = ArrayUpdater<T> & ObjectUpdater<T> & ValueUpdater<T> & Arg<T>;

package/dist/utils/action.js

@@ -1,4 +1,4 @@
-import { compareSafe } from "./sort.js";
+import { compareSafe } from "./compare.js";
 export async function findUtil(query, fileCpu, files) {
     const { search, context = {}, dbFindOpts = {}, findOpts = {} } = query;
     const { reverse = false, max = -1, offset = 0, sortBy, sortAsc = true } = dbFindOpts;

package/dist/utils/hasFieldsAdvanced.js

@@ -1,4 +1,5 @@
 import hasFields from "./hasFields.js";
+import { compareIds } from "./id.js";
 /**
  * Checks if an object meets the criteria specified in the fields with operators.
  */
@@ -6,161 +7,66 @@ export default function hasFieldsAdvanced(obj, fields) {
     if (typeof fields !== "object" || fields === null) {
         throw new Error("Fields must be an object");
     }
+    if (Object.keys(fields).length === 0)
+        return true;
     if ("$and" in fields) {
-        return fields["$and"].every(subFields => hasFieldsAdvanced(obj, subFields));
+        return fields["$and"].every((subFields) => hasFieldsAdvanced(obj, subFields));
     }
     if ("$or" in fields) {
-        return fields["$or"].some(subFields => hasFieldsAdvanced(obj, subFields));
+        return fields["$or"].some((subFields) => hasFieldsAdvanced(obj, subFields));
     }
     // Check various conditions
     if (!checkConditions(obj, fields))
         return false;
-    const fieldsSubset = removeAdvancedOperators({ ...fields });
+    const fieldsSubset = { ...fields };
+    Object.keys(fieldsSubset).filter(key => key.startsWith("$")).forEach(key => delete fieldsSubset[key]);
+    if (!Object.keys(fieldsSubset).length)
+        return true;
     return hasFields(obj, fieldsSubset);
 }
-function removeAdvancedOperators(fields) {
-    const advancedOperators = [
-        "and", "or",
-        "gt", "lt", "gte", "lte", "in", "nin",
-        "exists",
-        "type",
-        "regex",
-        "arrinc", "arrincall", "size",
-        "startsWith", "endsWith",
-        "between",
-        "not",
-        "subset"
-    ].map(operator => "$" + operator);
-    advancedOperators.forEach(operator => delete fields[operator]);
-    return fields;
-}
 function checkConditions(obj, fields) {
-    return (checkComparison(obj, fields) &&
-        checkExistence(obj, fields) &&
-        checkType(obj, fields) &&
-        checkRegex(obj, fields) &&
-        checkArrayConditions(obj, fields) &&
-        checkStringConditions(obj, fields) &&
-        checkBetween(obj, fields) &&
+    return (mainCheck(obj, fields) &&
         checkNot(obj, fields) &&
         checkSubset(obj, fields));
 }
-function checkComparison(obj, fields) {
-    const comparisonOperators = ["$gt", "$lt", "$gte", "$lte", "$in", "$nin"];
-    for (const operator of comparisonOperators) {
-        if (operator in fields) {
-            for (const entries of Object.entries(fields[operator])) {
-                const [key, value] = entries;
-                switch (operator) {
-                    case "$gt":
-                        if (!(obj[key] > value))
-                            return false;
-                        break;
-                    case "$lt":
-                        if (!(obj[key] < value))
-                            return false;
-                        break;
-                    case "$gte":
-                        if (!(obj[key] >= value))
-                            return false;
-                        break;
-                    case "$lte":
-                        if (!(obj[key] <= value))
-                            return false;
-                        break;
-                    case "$in":
-                        if (!value.includes(obj[key]))
-                            return false;
-                        break;
-                    case "$nin":
-                        if (value.includes(obj[key]))
-                            return false;
-                        break;
-                }
-            }
-        }
-    }
-    return true;
-}
-function checkExistence(obj, fields) {
-    if ("$exists" in fields) {
-        for (const [key, shouldExist] of Object.entries(fields["$exists"])) {
+function mainCheck(obj, fields) {
+    return _for(fields, obj, {
+        gt: (data, value) => data > value,
+        lt: (data, value) => data < value,
+        gte: (data, value) => data >= value,
+        lte: (data, value) => data <= value,
+        in: (data, value) => value.includes(data),
+        nin: (data, value) => !value.includes(data),
+        type: (data, value) => typeof data === value,
+        exists: (_, shouldExist, key) => {
             if (shouldExist && !(key in obj))
                 return false;
             if (!shouldExist && (key in obj))
                 return false;
-        }
-    }
-    return true;
-}
-function checkType(obj, fields) {
-    if ("$type" in fields) {
-        for (const [key, type] of Object.entries(fields["$type"])) {
-            if (typeof obj[key] !== type)
-                return false;
-        }
-    }
-    return true;
-}
-function checkRegex(obj, fields) {
-    if ("$regex" in fields) {
-        for (const [key, regexData] of Object.entries(fields["$regex"])) {
+            return true;
+        },
+        regex: (data, regexData) => {
             const regex = typeof regexData === "string" ? new RegExp(regexData) : regexData;
-            if (!regex.test(obj[key]))
-                return false;
-        }
-    }
-    return true;
-}
-function checkArrayConditions(obj, fields) {
-    if ("$arrinc" in fields) {
-        for (const [key, values] of Object.entries(fields["$arrinc"])) {
-            if (!Array.isArray(obj[key]) || !values.some(val => obj[key].includes(val)))
-                return false;
-        }
-    }
-    if ("$arrincall" in fields) {
-        for (const [key, values] of Object.entries(fields["$arrincall"])) {
-            if (!Array.isArray(obj[key]) || !values.every(val => obj[key].includes(val)))
-                return false;
-        }
-    }
-    if ("$size" in fields) {
-        for (const [key, size] of Object.entries(fields["$size"])) {
-            if (Array.isArray(obj[key]) || typeof obj[key] === "string") {
-                if (obj[key].length !== size)
-                    return false;
+            return regex.test(data);
+        },
+        size: (data, size) => {
+            if (Array.isArray(data) || typeof data === "string") {
+                return data.length === size;
             }
             else {
                 return false;
             }
-        }
-    }
-    return true;
-}
-function checkStringConditions(obj, fields) {
-    if ("$startsWith" in fields) {
-        for (const [key, value] of Object.entries(fields["$startsWith"])) {
-            if (typeof obj[key] !== "string" || !obj[key].startsWith(value))
-                return false;
-        }
-    }
-    if ("$endsWith" in fields) {
-        for (const [key, value] of Object.entries(fields["$endsWith"])) {
-            if (typeof obj[key] !== "string" || !obj[key].endsWith(value))
-                return false;
-        }
-    }
-    return true;
-}
-function checkBetween(obj, fields) {
-    if ("$between" in fields) {
-        for (const [key, [min, max]] of Object.entries(fields["$between"])) {
-            if (typeof obj[key] !== "number" || obj[key] < min || obj[key] > max)
-                return false;
-        }
-    }
-    return true;
+        },
+        startsWith: (data, value) => typeof data === "string" && data.startsWith(value),
+        endsWith: (data, value) => typeof data === "string" && data.endsWith(value),
+        between: (data, [min, max]) => typeof data === "number" && data >= min && data <= max,
+        arrinc: (data, values) => Array.isArray(data) && values.some((val) => data.includes(val)),
+        arrincall: (data, values) => Array.isArray(data) && values.every((val) => data.includes(val)),
+        idGt: (data, value) => compareIds(data, value) > 0,
+        idLt: (data, value) => compareIds(data, value) < 0,
+        idGte: (data, value) => compareIds(data, value) >= 0,
+        idLte: (data, value) => compareIds(data, value) <= 0,
+    });
 }
 function checkNot(obj, fields) {
     if ("$not" in fields) {
@@ -175,3 +81,15 @@ function checkSubset(obj, fields) {
     }
     return true;
 }
+function _for(fields, obj, opts) {
+    for (const [fieldRaw, fieldFn] of Object.entries(opts)) {
+        const field = "$" + fieldRaw;
+        if (field in fields) {
+            for (const [key, value] of Object.entries(fields[field])) {
+                if (!fieldFn(obj?.[key], value, key))
+                    return false;
+            }
+        }
+    }
+    return true;
+}

package/dist/utils/id.d.ts

@@ -2,3 +2,4 @@ export declare function convertIdToUnix(id: string): number;
 export declare function sortByIds<T extends {
     _id: string;
 }>(objects: T[]): T[];
+export declare function compareIds(a: string | number, b: string | number): number;

package/dist/utils/id.js

@@ -2,7 +2,14 @@ export function convertIdToUnix(id) {
     return parseInt(id.split("-")[0], 36);
 }
 export function sortByIds(objects) {
-    return objects.slice().sort((a, b) => {
-        return convertIdToUnix(a._id) - convertIdToUnix(b._id) || a._id.localeCompare(b._id);
-    });
+    return objects.slice().sort((a, b) => compareIds(a._id, b._id));
+}
+export function compareIds(a, b) {
+    if (typeof a === "string" && typeof b === "string")
+        return convertIdToUnix(a) - convertIdToUnix(b) || a.localeCompare(b);
+    if (typeof a === "number" && typeof b === "number")
+        return a - b;
+    const timeA = typeof a === "string" ? convertIdToUnix(a) : a;
+    const timeB = typeof b === "string" ? convertIdToUnix(b) : b;
+    return timeA - timeB;
 }

package/dist/utils/merge.d.ts

@@ -0,0 +1 @@
+export declare function deepMerge(target: any, source: any): any;

package/dist/utils/merge.js

@@ -0,0 +1,22 @@
+export function deepMerge(target, source) {
+    const output = { ...target };
+    if (isObject(target) && isObject(source)) {
+        for (const key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+                if (isObject(source[key])) {
+                    if (!target[key]) {
+                        output[key] = {};
+                    }
+                    output[key] = deepMerge(target[key], source[key]);
+                }
+                else {
+                    output[key] = source[key];
+                }
+            }
+        }
+    }
+    return output;
+}
+function isObject(item) {
+    return item !== null && typeof item === "object" && !Array.isArray(item);
+}

package/dist/utils/updateObject.d.ts

@@ -2,6 +2,6 @@ import { UpdaterArg } from "../types/updater.js";
 /**
  * Updates an object with new values.
  * @param obj - The object to update.
- * @param fields - An object containing new values to update in the target object.
+ * @param field - An object containing new values to update in the target object.
  */
-export default function updateObjectAdvanced(obj: Object, fields: UpdaterArg | UpdaterArg[]): Object;
+export default function updateObjectAdvanced(obj: Object, field: UpdaterArg): Object;

package/dist/utils/updateObject.js

@@ -1,117 +1,86 @@
+import { deepMerge } from "./merge.js";
 /**
  * Updates an object with new values.
  * @param obj - The object to update.
- * @param fields - An object containing new values to update in the target object.
+ * @param field - An object containing new values to update in the target object.
  */
-export default function updateObjectAdvanced(obj, fields) {
-    if (typeof fields !== "object" || fields === null) {
+export default function updateObjectAdvanced(obj, field) {
+    if (typeof field !== "object" || field === null) {
         throw new Error("Fields must be an object or object array");
     }
-    const fieldsArray = Array.isArray(fields) ? fields : [fields];
-    for (const field of fieldsArray) {
-        if (typeof field !== "object" || field === null) {
-            throw new Error("Fields must be an object or object array");
-        }
-        updateAdvanced(obj, field);
-        const fieldsSubset = removeAdvancedOperators({ ...field });
-        updateObject(obj, fieldsSubset);
+    if (typeof field !== "object" || field === null) {
+        throw new Error("Fields must be an object or object array");
     }
+    updateAdvanced(obj, field);
+    const fieldsSubset = { ...field };
+    Object.keys(fieldsSubset).filter(key => key.startsWith("$")).forEach(key => delete fieldsSubset[key]);
+    updateObject(obj, fieldsSubset);
     return obj;
 }
 function updateAdvanced(obj, fields) {
-    updateArray(obj, fields);
-    updateNested(obj, fields);
-    updateIncrement(obj, fields);
+    mainUpdate(obj, fields);
     updateUnset(obj, fields);
-    updateRename(obj, fields);
-}
-function removeAdvancedOperators(fields) {
-    const advancedOperators = [
-        "push", "pushset", "pull", "pullall",
-        "inc", "dec",
-        "unset",
-        "merge",
-        "rename"
-    ].map(operator => "$" + operator);
-    advancedOperators.forEach(operator => delete fields[operator]);
-    return fields;
-}
-function updateArray(obj, fields) {
-    if ("$push" in fields) {
-        for (const [key, value] of Object.entries(fields["$push"])) {
-            if (Array.isArray(obj[key])) {
-                obj[key].push(value);
-            }
-            else {
-                obj[key] = [value];
-            }
-        }
-    }
-    if ("$pushset" in fields) {
-        for (const [key, value] of Object.entries(fields["$pushset"])) {
-            if (Array.isArray(obj[key])) {
-                obj[key].push(value);
-            }
-            else {
-                obj[key] = [value];
-            }
-            obj[key] = [...new Set(obj[key])];
-        }
-    }
-    if ("$pull" in fields) {
-        for (const [key, value] of Object.entries(fields["$pull"])) {
-            if (Array.isArray(obj[key])) {
-                obj[key] = obj[key].filter(item => item !== value);
-            }
-        }
-    }
-    if ("$pullall" in fields) {
-        for (const [key, values] of Object.entries(fields["$pullall"])) {
-            if (Array.isArray(obj[key])) {
-                obj[key] = obj[key].filter(item => !values.includes(item));
-            }
-        }
-    }
 }
-function updateNested(obj, fields) {
-    if ("$merge" in fields) {
-        for (const [key, value] of Object.entries(fields["$merge"])) {
-            if (typeof obj[key] === "object" && typeof value === "object") {
-                obj[key] = { ...obj[key], ...value };
+function mainUpdate(obj, fields) {
+    _for(fields, obj, {
+        push: (item, updater) => {
+            if (Array.isArray(item)) {
+                item.push(updater);
+                return item;
             }
-            else {
-                obj[key] = value;
-            }
-        }
-    }
-}
-function updateIncrement(obj, fields) {
-    if ("$inc" in fields) {
-        for (const [key, value] of Object.entries(fields["$inc"])) {
-            if (typeof obj[key] === "number" && typeof value === "number") {
-                obj[key] += value;
+            return [updater];
+        },
+        pushSet: (item, updater) => {
+            if (Array.isArray(item)) {
+                item.push(updater);
+                return [...new Set(item)];
             }
-            else if (!(key in obj)) {
-                obj[key] = value;
+            return [updater];
+        },
+        pull: (item, updater) => {
+            if (Array.isArray(item))
+                return item.filter(i => i !== updater);
+        },
+        pullall: (item, updater) => {
+            if (Array.isArray(item))
+                return item.filter(i => !updater.includes(i));
+        },
+        merge: (item, updater) => {
+            if (typeof item === "object" && typeof updater === "object") {
+                return { ...item, ...updater };
             }
-            else {
-                throw new Error(`Cannot increment non-numeric value at key: ${key}`);
+            return updater;
+        },
+        deepMerge: (item, updater) => {
+            if (typeof item === "object" && typeof updater === "object") {
+                return deepMerge(item, updater);
             }
-        }
-    }
-    if ("$dec" in fields) {
-        for (const [key, value] of Object.entries(fields["$dec"])) {
-            if (typeof obj[key] === "number" && typeof value === "number") {
-                obj[key] -= value;
+            return updater;
+        },
+        inc: (item, updater, key) => {
+            if (typeof item === "number" && typeof updater === "number") {
+                return item + updater;
             }
-            else if (!(key in obj)) {
-                obj[key] = value;
+            if (!(key in obj))
+                return updater;
+            throw new Error(`Cannot increment non-numeric value at key: ${key}`);
+        },
+        dec: (item, updater, key) => {
+            if (typeof item === "number" && typeof updater === "number") {
+                return item - updater;
             }
-            else {
-                throw new Error(`Cannot decrement non-numeric value at key: ${key}`);
+            if (!(key in obj))
+                return -updater;
+            throw new Error(`Cannot decrement non-numeric value at key: ${key}`);
+        },
+        rename: (_, newKey, oldKey) => {
+            if (oldKey in obj) {
+                obj[newKey] = obj[oldKey];
+                delete obj[oldKey];
             }
-        }
-    }
+        },
+        set: (_, value) => value
+    });
 }
 function updateUnset(obj, fields) {
     if ("$unset" in fields) {
@@ -120,16 +89,6 @@ function updateUnset(obj, fields) {
         }
     }
 }
-function updateRename(obj, fields) {
-    if ("$rename" in fields) {
-        for (const [oldKey, newKey] of Object.entries(fields["$rename"])) {
-            if (oldKey in obj) {
-                obj[newKey] = obj[oldKey];
-                delete obj[oldKey];
-            }
-        }
-    }
-}
 /**
  * Updates an object with new values.
  * @param obj - The object to update.
@@ -143,3 +102,15 @@ function updateObject(obj, newVal) {
     }
     return obj;
 }
+function _for(fields, obj, opts) {
+    for (const [fieldRaw, fieldFn] of Object.entries(opts)) {
+        const field = "$" + fieldRaw;
+        if (field in fields) {
+            for (const [key, value] of Object.entries(fields[field])) {
+                const res = fieldFn(obj?.[key], value, key);
+                if (res !== undefined)
+                    obj[key] = res;
+            }
+        }
+    }
+}

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.2.5";
+export const version = "0.2.7";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/db-core",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "author": "wxn0brP",
@@ -13,12 +13,13 @@
   },
   "homepage": "https://github.com/wxn0brP/ValtheraDB",
   "dependencies": {
-    "@wxn0brp/event-emitter": "^0.0.2"
+    "@wxn0brp/event-emitter": "^0.0.3"
   },
   "devDependencies": {
-    "@types/node": "^24.2.0",
-    "tsc-alias": "^1.8.10",
-    "typescript": "^5.9.2"
+    "@types/bun": "*",
+    "@types/node": "*",
+    "tsc-alias": "*",
+    "typescript": "*"
   },
   "files": [
     "dist"