@wxn0brp/db-core 0.2.6-alpha.0 → 0.2.8

package/dist/base/actions.d.ts

@@ -2,6 +2,7 @@ import Data from "../types/data.js";
 import { VQuery } from "../types/query.js";
 declare class ActionsBase {
     _inited: boolean;
+    numberId: boolean;
     init(...args: any[]): Promise<void>;
     getCollections(): Promise<string[]>;
     ensureCollection(config: VQuery): Promise<boolean>;
@@ -15,5 +16,6 @@ declare class ActionsBase {
     removeOne(config: VQuery): Promise<boolean>;
     removeCollection(config: VQuery): Promise<boolean>;
     updateOneOrAdd(config: VQuery): Promise<boolean>;
+    toggleOne(config: VQuery): Promise<boolean>;
 }
 export default ActionsBase;

package/dist/base/actions.js

@@ -1,6 +1,7 @@
 import { setDataUsingUpdateOneOrAdd } from "../helpers/updateOneOrAdd.js";
 class ActionsBase {
     _inited = true;
+    numberId = false;
     async init(...args) { }
     async getCollections() {
         throw new Error("Not implemented");
@@ -54,5 +55,11 @@ class ActionsBase {
         }
         return res;
     }
+    async toggleOne(config) {
+        const res = await this.removeOne(config);
+        if (!res)
+            await this.add(config);
+        return res;
+    }
 }
 export default ActionsBase;

package/dist/base/custom.d.ts

@@ -8,7 +8,7 @@ export declare class CustomActionsBase extends ActionsBase {
     /**
      * Add a new entry to the specified database.
      */
-    add({ collection, data, id_gen }: VQuery): Promise<import("../types/arg.js").Arg>;
+    add(query: VQuery): Promise<import("../types/arg.js").Arg>;
     /**
      * Find entries in the specified database based on search criteria.
      */

package/dist/base/custom.js

@@ -1,4 +1,4 @@
-import genId from "../helpers/gen.js";
+import { addId } from "../helpers/addId.js";
 import { findUtil } from "../utils/action.js";
 import ActionsBase from "./actions.js";
 export class CustomActionsBase extends ActionsBase {
@@ -9,10 +9,10 @@ export class CustomActionsBase extends ActionsBase {
     /**
      * Add a new entry to the specified database.
      */
-    async add({ collection, data, id_gen = true }) {
-        await this.ensureCollection(arguments[0]);
-        if (id_gen)
-            data._id = data._id || genId();
+    async add(query) {
+        await this.ensureCollection(query);
+        await addId(query, this);
+        const { collection, data } = query;
         await this.fileCpu.add(collection, data);
         return data;
     }

package/dist/customFileCpu.d.ts

@@ -11,9 +11,9 @@ declare class CustomFileCpu implements FileCpu {
     _writeFile: WriteFile;
     constructor(readFile: ReadFile, writeFile: WriteFile);
     add(file: string, data: Data): Promise<void>;
-    find(file: string, arg: Search, context?: VContext, findOpts?: FindOpts): Promise<any[] | false>;
-    findOne(file: string, arg: Search, context?: VContext, findOpts?: FindOpts): Promise<any | false>;
-    remove(file: string, one: boolean, arg: Search, context?: VContext): Promise<boolean>;
-    update(file: string, one: boolean, arg: Search, updater: Updater, context?: VContext): Promise<boolean>;
+    find(file: string, search: Search, context?: VContext, findOpts?: FindOpts): Promise<any[] | false>;
+    findOne(file: string, search: Search, context?: VContext, findOpts?: FindOpts): Promise<any | false>;
+    remove(file: string, one: boolean, search: Search, context?: VContext): Promise<boolean>;
+    update(file: string, one: boolean, search: Search, updater: Updater, context?: VContext): Promise<boolean>;
 }
 export default CustomFileCpu;

package/dist/customFileCpu.js

@@ -1,5 +1,6 @@
 import hasFieldsAdvanced from "./utils/hasFieldsAdvanced.js";
 import updateFindObject from "./utils/updateFindObject.js";
+import updateObjectAdvanced from "./utils/updateObject.js";
 export function pathRepair(path) {
     return path.replaceAll("//", "/");
 }
@@ -16,26 +17,26 @@ class CustomFileCpu {
         entries.push(data);
         await this._writeFile(file, entries);
     }
-    async find(file, arg, context = {}, findOpts = {}) {
+    async find(file, search, context = {}, findOpts = {}) {
         file = pathRepair(file);
         const entries = await this._readFile(file);
-        const results = entries.filter(entry => typeof arg === "function" ? arg(entry, context) : hasFieldsAdvanced(entry, arg));
+        const results = entries.filter(entry => typeof search === "function" ? search(entry, context) : hasFieldsAdvanced(entry, search));
         return results.length ? results.map(res => updateFindObject(res, findOpts)) : [];
     }
-    async findOne(file, arg, context = {}, findOpts = {}) {
+    async findOne(file, search, context = {}, findOpts = {}) {
         file = pathRepair(file);
         const entries = await this._readFile(file);
-        const result = entries.find(entry => typeof arg === "function" ? arg(entry, context) : hasFieldsAdvanced(entry, arg));
+        const result = entries.find(entry => typeof search === "function" ? search(entry, context) : hasFieldsAdvanced(entry, search));
         return result ? updateFindObject(result, findOpts) : false;
     }
-    async remove(file, one, arg, context = {}) {
+    async remove(file, one, search, context = {}) {
         file = pathRepair(file);
         let entries = await this._readFile(file);
         let removed = false;
         entries = entries.filter(entry => {
             if (removed && one)
                 return true;
-            let match = typeof arg === "function" ? arg(entry, context) : hasFieldsAdvanced(entry, arg);
+            let match = typeof search === "function" ? search(entry, context) : hasFieldsAdvanced(entry, search);
             if (match) {
                 removed = true;
                 return false;
@@ -47,17 +48,17 @@ class CustomFileCpu {
         await this._writeFile(file, entries);
         return true;
     }
-    async update(file, one, arg, updater, context = {}) {
+    async update(file, one, search, updater, context = {}) {
         file = pathRepair(file);
         let entries = await this._readFile(file);
         let updated = false;
         entries = entries.map(entry => {
             if (updated && one)
                 return entry;
-            let match = typeof arg === "function" ? arg(entry, context) : hasFieldsAdvanced(entry, arg);
+            let match = typeof search === "function" ? search(entry, context) : hasFieldsAdvanced(entry, search);
             if (match) {
                 updated = true;
-                return typeof updater === "function" ? updater(entry, context) : { ...entry, ...updater };
+                return typeof updater === "function" ? updater(entry, context) : updateObjectAdvanced(entry, updater);
             }
             return entry;
         });

package/dist/db/valthera.d.ts

@@ -2,7 +2,7 @@ import { VEE } from "@wxn0brp/event-emitter";
 import ActionsBase from "../base/actions.js";
 import CollectionManager from "../helpers/CollectionManager.js";
 import executorC from "../helpers/executor.js";
-import { Search, Updater } from "../types/arg.js";
+import { Arg, Search, Updater } from "../types/arg.js";
 import Data from "../types/data.js";
 import { DbFindOpts, DbOpts, FindOpts } from "../types/options.js";
 import { VQuery } from "../types/query.js";
@@ -74,6 +74,10 @@ declare class ValtheraClass implements ValtheraCompatible {
      * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
      */
     updateOneOrAdd<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, { add_arg, context, id_gen }?: UpdateOneOrAdd<T>): Promise<boolean>;
+    /**
+     * Asynchronously removes one entry in a database or adds a new one if it doesn't exist. Usage e.g. for toggling a flag.
+     */
+    toggleOne<T = Data>(collection: string, search: Search<T>, data: Arg<T>, context?: VContext): Promise<boolean>;
     /**
      * Removes a database collection from the file system.
      */

package/dist/db/valthera.js

@@ -16,6 +16,8 @@ class ValtheraClass {
         this.dbAction = options.dbAction || new ActionsBase();
         this.executor = options.executor || new executorC();
         this.emiter = new VEE();
+        if (options.numberId)
+            this.dbAction.numberId = true;
     }
     async init(...args) {
         if (this.dbAction._inited)
@@ -105,6 +107,12 @@ class ValtheraClass {
     async updateOneOrAdd(collection, search, updater, { add_arg = {}, context = {}, id_gen = true } = {}) {
         return await this.execute("updateOneOrAdd", { collection, search, updater, add_arg, context, id_gen });
     }
+    /**
+     * Asynchronously removes one entry in a database or adds a new one if it doesn't exist. Usage e.g. for toggling a flag.
+     */
+    async toggleOne(collection, search, data, context = {}) {
+        return await this.execute("toggleOne", { collection, search, data, context, id_gen: false });
+    }
     /**
      * Removes a database collection from the file system.
      */

package/dist/helpers/addId.d.ts

@@ -0,0 +1,3 @@
+import ActionsBase from "../base/actions.js";
+import { VQuery } from "../types/query.js";
+export declare function addId(query: VQuery, actions: ActionsBase, defaultGen?: boolean): Promise<import("../types/arg.js").Arg>;

package/dist/helpers/addId.js

@@ -0,0 +1,24 @@
+import genId from "./gen.js";
+export async function addId(query, actions, defaultGen = true) {
+    const { collection, data } = query;
+    const id_gen = query.id_gen ?? defaultGen;
+    if (!id_gen)
+        return data;
+    if (data._id)
+        return data;
+    const { numberId } = actions;
+    if (!numberId) {
+        data._id = genId();
+        return;
+    }
+    const find = await actions.findOne({ collection: "__vdb_id", search: { c: collection } });
+    data._id = find ? find.i + 1 : 1;
+    await actions.updateOneOrAdd({
+        collection: "__vdb_id",
+        search: { c: collection },
+        updater: {
+            $inc: { i: 1 }
+        },
+        id_gen: false,
+    });
+}

package/dist/helpers/executor.d.ts

@@ -8,7 +8,7 @@ interface Task {
  * A simple executor for queuing and executing asynchronous operations sequentially.
  * @class
  */
-declare class executorC {
+declare class ExecutorC {
     quote: Task[];
     isExecuting: boolean;
     /**
@@ -25,4 +25,5 @@ declare class executorC {
      */
     execute(): Promise<void>;
 }
-export default executorC;
+export default ExecutorC;
+export { ExecutorC as executorC };

package/dist/helpers/executor.js

@@ -2,7 +2,7 @@
  * A simple executor for queuing and executing asynchronous operations sequentially.
  * @class
  */
-class executorC {
+class ExecutorC {
     quote;
     isExecuting;
     /**
@@ -42,4 +42,5 @@ class executorC {
         this.isExecuting = false;
     }
 }
-export default executorC;
+export default ExecutorC;
+export { ExecutorC as executorC };

package/dist/helpers/relation.js

@@ -111,7 +111,7 @@ async function processRelations(dbs, cfg, data, parentList = null) {
                 const pivotDb = dbs[through.db || dbKey];
                 const pivots = await pivotDb.find(through.table, { [through.pk]: item[pk] });
                 const ids = pivots.map(p => p[through.fk]);
-                const related = await db.find(coll, { $in: { [fk]: ids } }, {}, {}, { select });
+                const related = await db.find(coll, { $in: { [fk]: ids } }, {}, { select });
                 item[as] = related;
                 if (rel.relations) {
                     await Promise.all(related.map(row => processRelations(dbs, rel.relations, row)));

package/dist/types/fileCpu.d.ts

@@ -13,39 +13,39 @@ interface FileCpu {
     /**
      * Asynchronously finds multiple entries in a file based on search criteria.
      * @param file The path to the file.
-     * @param arg The search criteria.
+     * @param search The search criteria.
      * @param context Additional context for the search.
      * @param findOpts Additional options for searching.
      * @returns A promise resolving to an array of found entries, or `false` if the file does not exist.
      */
-    find(file: string, arg: Search, context?: VContext, findOpts?: FindOpts): Promise<any[] | false>;
+    find(file: string, search: Search, context?: VContext, findOpts?: FindOpts): Promise<any[] | false>;
     /**
      * Asynchronously finds one entry in a file based on search criteria.
      * @param file The path to the file.
-     * @param arg The search criteria.
+     * @param search The search criteria.
      * @param context Additional context for the search.
      * @param findOpts Additional options for searching.
      * @returns A promise resolving to the found entry or `false` if not found.
      */
-    findOne(file: string, arg: Search, context?: VContext, findOpts?: FindOpts): Promise<any | false>;
+    findOne(file: string, search: Search, context?: VContext, findOpts?: FindOpts): Promise<any | false>;
     /**
    * Asynchronously removes entries from a file based on search criteria.
    * @param file The path to the file.
-   * @param arg The search criteria.
+   * @param search The search criteria.
    * @param context Additional context for the operation.
    * @param one If `true`, removes only the first matching entry.
    * @returns A promise resolving to `true` if at least one entry was removed, otherwise `false`.
    */
-    remove(file: string, one: boolean, arg: Search, context?: VContext): Promise<boolean>;
+    remove(file: string, one: boolean, search: Search, context?: VContext): Promise<boolean>;
     /**
      * Asynchronously updates entries in a file based on search criteria and an updater function or object.
      * @param file The path to the file.
-     * @param arg The search criteria.
+     * @param search The search criteria.
      * @param updater The updater function or object.
      * @param context Additional context for the operation.
      * @param one If `true`, updates only the first matching entry.
      * @returns A promise resolving to `true` if at least one entry was updated, otherwise `false`.
      */
-    update(file: string, one: boolean, arg: Search, updater: Updater, context?: VContext): Promise<boolean>;
+    update(file: string, one: boolean, search: Search, updater: Updater, context?: VContext): Promise<boolean>;
 }
 export default FileCpu;

package/dist/types/options.d.ts

@@ -5,6 +5,7 @@ export interface DbOpts {
     maxFileSize?: number;
     dbAction?: ActionsBase;
     executor?: executorC;
+    numberId?: boolean;
 }
 export interface DbFindOpts<T = any> {
     reverse?: boolean;

package/dist/types/query.d.ts

@@ -9,7 +9,6 @@ export interface VQuery {
     findOpts?: FindOpts;
     data?: Arg;
     id_gen?: boolean;
-    limit?: number;
     add_arg?: Arg;
     updater?: Updater;
 }

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.3";
+export const version = "0.2.8";

package/package.json

@@ -1,41 +1,39 @@
 {
-    "name": "@wxn0brp/db-core",
-    "version": "0.2.6-alpha.0",
-    "types": "dist/index.d.ts",
-    "main": "dist/index.js",
-    "author": "wxn0brP",
-    "license": "MIT",
-    "type": "module",
-    "description": "ValtheraDB Core",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/wxn0brP/ValtheraDB-core.git"
+  "name": "@wxn0brp/db-core",
+  "version": "0.2.8",
+  "types": "dist/index.d.ts",
+  "main": "dist/index.js",
+  "author": "wxn0brP",
+  "license": "MIT",
+  "type": "module",
+  "description": "ValtheraDB Core",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wxn0brP/ValtheraDB-core.git"
+  },
+  "homepage": "https://github.com/wxn0brP/ValtheraDB",
+  "dependencies": {
+    "@wxn0brp/event-emitter": "^0.0.3"
+  },
+  "devDependencies": {
+    "@types/bun": "*",
+    "@types/node": "*",
+    "tsc-alias": "*",
+    "typescript": "*"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     },
-    "homepage": "https://github.com/wxn0brP/ValtheraDB",
-    "scripts": {
-        "build": "tsc && tsc-alias"
-    },
-    "dependencies": {
-        "@wxn0brp/event-emitter": "^0.0.3"
-    },
-    "devDependencies": {
-        "@types/node": "*",
-        "tsc-alias": "*",
-        "typescript": "*"
-    },
-    "files": [
-        "dist"
-    ],
-    "exports": {
-        ".": {
-            "types": "./dist/index.d.ts",
-            "import": "./dist/index.js",
-            "default": "./dist/index.js"
-        },
-        "./*": {
-            "types": "./dist/*.d.ts",
-            "import": "./dist/*.js",
-            "default": "./dist/*.js"
-        }
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.js",
+      "default": "./dist/*.js"
     }
+  }
 }