@wxn0brp/db-core 0.2.11 → 0.3.0-alpha.0

package/dist/helpers/CollectionManager.d.ts

@@ -14,30 +14,34 @@ declare class CollectionManager<D = Data> {
     /**
      * Find data in a database.
      */
-    find<T = Data>(search?: Search<T & D>, options?: DbFindOpts<T & Data>, findOpts?: FindOpts<T & Data>, context?: VContext): Promise<T[]>;
+    find<T = Data>(search?: Search<T & D>, options?: DbFindOpts<T & D>, findOpts?: FindOpts<T & D>, context?: VContext): Promise<T[]>;
     /**
      * Find one data entry in a database.
      */
-    findOne<T = Data>(search?: Search<T & Data>, findOpts?: FindOpts<T & Data>, context?: VContext): Promise<T>;
+    findOne<T = Data>(search?: Search<T & D>, findOpts?: FindOpts<T & D>, context?: VContext): Promise<T>;
     /**
      * Update data in a database.
      */
-    update<T = Data>(search: Search<T & Data>, updater: Updater<T & Data>, context?: VContext): Promise<boolean>;
+    update<T = Data>(search: Search<T & D>, updater: Updater<T & D>, context?: VContext): Promise<boolean>;
     /**
      * Update one data entry in a database.
      */
-    updateOne<T = Data>(search: Search<T & Data>, updater: Updater<T & Data>, context?: VContext): Promise<boolean>;
+    updateOne<T = Data>(search: Search<T & D>, updater: Updater<T & D>, context?: VContext): Promise<boolean>;
     /**
      * Remove data from a database.
      */
-    remove<T = Data>(search: Search<T & Data>, context?: VContext): Promise<boolean>;
+    remove<T = Data>(search: Search<T & D>, context?: VContext): Promise<boolean>;
     /**
      * Remove one data entry from a database.
      */
-    removeOne<T = Data>(search: Search<T & Data>, context?: VContext): Promise<boolean>;
+    removeOne<T = Data>(search: Search<T & D>, context?: VContext): Promise<boolean>;
     /**
      * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
      */
-    updateOneOrAdd<T = Data>(search: Search<T & Data>, updater: Updater<T & Data>, { add_arg, context, id_gen }: UpdateOneOrAdd<T & Data>): Promise<boolean>;
+    updateOneOrAdd<T = Data>(search: Search<T & D>, updater: Updater<T & D>, { add_arg, context, id_gen }: UpdateOneOrAdd<T & D>): 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>(search: Search<T & D>, data?: Arg<T & D>, context?: VContext): Promise<boolean>;
 }
 export default CollectionManager;

package/dist/helpers/CollectionManager.js

@@ -53,5 +53,11 @@ class CollectionManager {
     async updateOneOrAdd(search, updater, { add_arg = {}, context = {}, id_gen = true }) {
         return await this.db.updateOneOrAdd(this.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(search, data = {}, context = {}) {
+        return await this.db.toggleOne(this.collection, search, data, context);
+    }
 }
 export default CollectionManager;

package/dist/types/options.d.ts

@@ -9,7 +9,7 @@ export interface DbOpts {
 }
 export interface DbFindOpts<T = any> {
     reverse?: boolean;
-    max?: number;
+    limit?: number;
     offset?: number;
     sortBy?: KeysMatching<T, any>;
     sortAsc?: boolean;

package/dist/types/searchOpts.d.ts

@@ -1,11 +1,4 @@
-/**
- * Predefined Search Options Quick Reference
- *
- * This module defines the types and structures for search operators used
- * to validate and query data objects.
- */
-import { Arg } from "./arg.js";
-import { PartialOfType, PartialPickMatching } from "./utils.js";
+import { DeepPartial, NestedValue } from "./utils.js";
 /** Logical Operators */
 export type LogicalOperators<T = any> = {
     /**
@@ -24,44 +17,68 @@ export type LogicalOperators<T = any> = {
      */
     $not?: SearchOptions<T>;
 };
-/** Comparison Operators */
+/** Comparison Operators with nested support */
 export type ComparisonOperators<T = any> = {
-    $gt?: PartialOfType<T, number>;
-    $lt?: PartialOfType<T, number>;
-    $gte?: PartialOfType<T, number>;
-    $lte?: PartialOfType<T, number>;
-    $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>;
+    /** 5 > 4 */
+    $gt?: NestedValue<T, number, number>;
+    /** 5 < 4 */
+    $lt?: NestedValue<T, number, number>;
+    /** 5 >= 4 */
+    $gte?: NestedValue<T, number, number>;
+    /** 5 <= 4 */
+    $lte?: NestedValue<T, number, number>;
+    /** 5 between [min, max] */
+    $between?: NestedValue<T, [number, number], number>;
+    /** 2 in [1, 2, 3] */
+    $in?: DeepPartial<T> & {
+        [K in keyof T]?: T[K] extends any[] ? T[K] : T[K][];
+    };
+    /** 5 not in [1, 2, 3] */
+    $nin?: DeepPartial<T> & {
+        [K in keyof T]?: T[K] extends any[] ? T[K] : T[K][];
+    };
+    /** id > 4 */
+    $idGt?: NestedValue<T, string | number, string | number>;
+    /** id < 4 */
+    $idLt?: NestedValue<T, string | number, string | number>;
+    /** id >= 4 */
+    $idGte?: NestedValue<T, string | number, string | number>;
+    /** id <= 4 */
+    $idLte?: NestedValue<T, string | number, string | number>;
 };
-/** Type and Existence Operators */
+/** Type and Existence Operators with nested support */
 export type TypeAndExistenceOperators<T = any> = {
-    $exists?: PartialOfType<T, boolean, any>;
-    $type?: PartialOfType<T, string>;
+    /** "name" in { name: "John" } */
+    $exists?: NestedValue<T, boolean>;
+    /** "name" == "string" in { name: "John" } */
+    $type?: NestedValue<T, string>;
 };
-/** Array Operators */
+/** Array Operators with nested support */
 export type ArrayOperators<T = any> = {
-    $arrinc?: PartialPickMatching<T, any[]>;
-    $arrincall?: PartialPickMatching<T, any[]>;
-    $size?: PartialOfType<T, number>;
+    /** [1, 2, 3] includes 2 */
+    $arrinc?: DeepPartial<T>;
+    /** [1, 2, 3] array includes all elements e.g. [1, 2] */
+    $arrincall?: DeepPartial<T>;
+    /** [1, 2, 3] has size 3 */
+    $size?: NestedValue<T, number>;
 };
-/** String Operators */
+/** String Operators with nested support */
 export type StringOperators<T = any> = {
-    $regex?: PartialOfType<T, RegExp | string, string>;
-    $startsWith?: PartialOfType<T, string>;
-    $endsWith?: PartialOfType<T, string>;
+    /** "John" matches /oh/ */
+    $regex?: NestedValue<T, RegExp | string, string>;
+    /** "John" starts with "Jo" */
+    $startsWith?: NestedValue<T, string, string>;
+    /** "John" ends with "hn" */
+    $endsWith?: NestedValue<T, string, string>;
 };
-/** Other Operators */
+/** Other Operators with nested support */
 export type OtherOperators<T = any> = {
-    $subset?: Partial<Record<keyof T, T[keyof T]>>;
+    /** { $type: "name" } matches { $type: "name" } literally - Ignore $ operators */
+    $subset?: DeepPartial<T>;
 };
 /** Predefined Search Operators */
 export type PredefinedSearchOperators<T = any> = LogicalOperators<T> & ComparisonOperators<T> & TypeAndExistenceOperators<T> & ArrayOperators<T> & StringOperators<T> & OtherOperators<T>;
 /**
  * SearchOptions can be either a function or an object with predefined operators.
  */
-export type SearchOptions<T = any> = PredefinedSearchOperators<T> & Arg<T>;
+export type SearchOptions<T = any> = PredefinedSearchOperators<T> & DeepPartial<T> & Record<string, any>;

package/dist/types/searchOpts.js

@@ -1,7 +1 @@
-/**
- * Predefined Search Options Quick Reference
- *
- * This module defines the types and structures for search operators used
- * to validate and query data objects.
- */
 export {};

package/dist/types/updater.d.ts

@@ -1,28 +1,37 @@
-/**
- * Predefined type for updating data.
- */
-import { Arg } from "./arg.js";
-import { PartialOfType } from "./utils.js";
+import { DeepPartial, NestedValue } from "./utils.js";
 /** Arrays */
 export type ArrayUpdater<T = any> = {
-    $push?: PartialOfType<T, any>;
-    /** Pushes items into an array and removes duplicates */
-    $pushset?: PartialOfType<T, any>;
-    $pull?: PartialOfType<T, any>;
-    $pullall?: PartialOfType<T, any>;
+    /** [1,2] -> $push 3 -> [1,2,3] */
+    $push?: NestedValue<T, any>;
+    /** [1,2] -> $pushset 2,3 -> [1,2,3] */
+    $pushset?: NestedValue<T, any>;
+    /** [1,2,3] -> $pull 2 -> [1,3] */
+    $pull?: NestedValue<T, any>;
+    /** [1,2,2,3] -> $pullall [2] -> [1,3] */
+    $pullall?: NestedValue<T, any>;
 };
 /** Objects */
 export type ObjectUpdater<T = any> = {
-    $merge?: PartialOfType<T, any>;
-    $deepMerge?: PartialOfType<T, any>;
+    /** { a: 1 } -> $merge { b: 2 } -> { a: 1, b: 2 } */
+    $merge?: NestedValue<T, any>;
+    /** { a: { x: 1 } } -> $deepMerge { a: { y: 2 } } -> { a: { x: 1, y: 2 } } */
+    $deepMerge?: NestedValue<T, any>;
 };
 /** Values */
 export type ValueUpdater<T = any> = {
-    $inc?: PartialOfType<T, number>;
-    $dec?: PartialOfType<T, number>;
-    $unset?: PartialOfType<T, any>;
-    $rename?: PartialOfType<T, any>;
-    /** same as { name: value } */
-    $set?: PartialOfType<T, any>;
+    /** { count: 1 } -> $inc 2 -> { count: 3 } */
+    $inc?: NestedValue<T, number>;
+    /** { count: 5 } -> $dec 2 -> { count: 3 } */
+    $dec?: NestedValue<T, number>;
+    /** { name: "John" } -> $unset "name" -> {} */
+    $unset?: NestedValue<T, any>;
+    /** { oldName: "value" } -> $rename "oldName" to "newName" -> { newName: "value" } */
+    $rename?: NestedValue<T, any>;
+    /**
+     * {} -> $set { name: "John" } -> { name: "John" }
+     *
+     * Note: same as { name: value }
+     */
+    $set?: NestedValue<T, any>;
 };
-export type UpdaterArg<T = any> = ArrayUpdater<T> & ObjectUpdater<T> & ValueUpdater<T> & Arg<T>;
+export type UpdaterArg<T = any> = ArrayUpdater<T> & ObjectUpdater<T> & ValueUpdater<T> & DeepPartial<T> & Record<string, any>;

package/dist/types/updater.js

@@ -1,4 +1 @@
-/**
- * Predefined type for updating data.
- */
 export {};

package/dist/types/utils.d.ts

@@ -3,3 +3,11 @@ export type KeysMatching<T, V, C = V> = {
 }[keyof T];
 export type PartialOfType<T, V, C = V> = Partial<Record<KeysMatching<T, V, C>, V>>;
 export type PartialPickMatching<T, V, C = V> = Partial<Pick<T, KeysMatching<T, V, C>>>;
+/** Helper type for nested path values with type filtering */
+export type NestedValue<T, V, C = V> = {
+    [K in keyof T as T[K] extends C ? K : T[K] extends object ? K : never]?: T[K] extends C ? V : T[K] extends object ? NestedValue<T[K], V, C> : never;
+};
+/** Helper type for nested path structure */
+export type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};

package/dist/utils/action.js

@@ -1,7 +1,7 @@
 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;
+    const { reverse = false, offset = 0, limit = -1, sortBy, sortAsc = true } = dbFindOpts;
     if (reverse && !sortBy)
         files.reverse();
     let datas = [];
@@ -21,18 +21,18 @@ export async function findUtil(query, fileCpu, files) {
                 entries = entries.slice(remainingSkip);
                 skippedEntries = offset;
             }
-            if (max !== -1) {
-                if (totalEntries + entries.length > max) {
-                    const remaining = max - totalEntries;
+            if (limit !== -1) {
+                if (totalEntries + entries.length > limit) {
+                    const remaining = limit - totalEntries;
                     entries = entries.slice(0, remaining);
-                    totalEntries = max;
+                    totalEntries = limit;
                 }
                 else {
                     totalEntries += entries.length;
                 }
             }
             datas.push(...entries);
-            if (max !== -1 && totalEntries >= max)
+            if (limit !== -1 && totalEntries >= limit)
                 break;
         }
         else {
@@ -43,7 +43,7 @@ export async function findUtil(query, fileCpu, files) {
         const dir = sortAsc ? 1 : -1;
         datas.sort((a, b) => compareSafe(a[sortBy], b[sortBy]) * dir);
         const start = offset;
-        const end = max !== -1 ? offset + max : undefined;
+        const end = limit !== -1 ? offset + limit : undefined;
         datas = datas.slice(start, end);
     }
     return datas;

package/dist/utils/hasFieldsAdvanced.js

@@ -15,14 +15,19 @@ export default function hasFieldsAdvanced(obj, fields) {
     if ("$or" in fields) {
         return fields["$or"].some((subFields) => hasFieldsAdvanced(obj, subFields));
     }
-    // Check various conditions
-    if (!checkConditions(obj, fields))
+    const $fields = {};
+    const subsetFields = {};
+    Object.keys(fields).forEach(key => {
+        if (key.startsWith("$"))
+            $fields[key.toLowerCase()] = fields[key];
+        else
+            subsetFields[key] = fields[key];
+    });
+    if (!checkConditions(obj, $fields))
         return false;
-    const fieldsSubset = { ...fields };
-    Object.keys(fieldsSubset).filter(key => key.startsWith("$")).forEach(key => delete fieldsSubset[key]);
-    if (!Object.keys(fieldsSubset).length)
+    if (!Object.keys(subsetFields).length)
         return true;
-    return hasFields(obj, fieldsSubset);
+    return hasFields(obj, subsetFields);
 }
 function checkConditions(obj, fields) {
     return (mainCheck(obj, fields) &&
@@ -57,15 +62,15 @@ function mainCheck(obj, fields) {
                 return false;
             }
         },
-        startsWith: (data, value) => typeof data === "string" && data.startsWith(value),
-        endsWith: (data, value) => typeof data === "string" && data.endsWith(value),
+        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,
+        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) {
@@ -86,10 +91,33 @@ function _for(fields, obj, 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;
+                const targetValue = obj?.[key];
+                if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+                    if (!deepCheck(value, targetValue, fieldFn))
+                        return false;
+                }
+                else {
+                    if (!fieldFn(targetValue, value, key))
+                        return false;
+                }
             }
         }
     }
     return true;
 }
+function deepCheck(valueObj, targetObj, fieldFn) {
+    if (typeof targetObj !== "object" || targetObj === null)
+        return false;
+    for (const [k, v] of Object.entries(valueObj)) {
+        const targetValue = targetObj[k];
+        if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+            if (!deepCheck(v, targetValue, fieldFn))
+                return false;
+        }
+        else {
+            if (!fieldFn(targetValue, v, k))
+                return false;
+        }
+    }
+    return true;
+}

package/dist/utils/merge.d.ts

@@ -1 +1,2 @@
-export declare function deepMerge(target: any, source: any): any;
+export declare function _deepMerge(target: Record<string, any>, ...sources: Record<string, any>[]): Record<string, any>;
+export declare function deepMerge(target: Record<string, any>, ...sources: Record<string, any>[]): Record<string, any>;

package/dist/utils/merge.js

@@ -1,22 +1,26 @@
-export function deepMerge(target, source) {
-    const output = { ...target };
+export function _deepMerge(target, ...sources) {
+    if (!sources.length)
+        return target;
+    const source = sources.shift();
+    if (!target)
+        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];
-                }
+            if (isObject(source[key])) {
+                if (!target[key])
+                    Object.assign(target, { [key]: {} });
+                _deepMerge(target[key], source[key]);
+            }
+            else {
+                Object.assign(target, { [key]: source[key] });
             }
         }
     }
-    return output;
+    return _deepMerge(target, ...sources);
+}
+export function deepMerge(target, ...sources) {
+    return _deepMerge(structuredClone(target), ...sources.map(s => structuredClone(s)));
 }
 function isObject(item) {
-    return item !== null && typeof item === "object" && !Array.isArray(item);
+    return (item && typeof item === "object" && !Array.isArray(item));
 }

package/dist/utils/updateObject.d.ts

@@ -4,4 +4,4 @@ import { UpdaterArg } from "../types/updater.js";
  * @param obj - The object to update.
  * @param field - An object containing new values to update in the target object.
  */
-export default function updateObjectAdvanced(obj: Object, field: UpdaterArg): Object;
+export default function updateObjectAdvanced(obj: Record<string, any>, field: UpdaterArg): Record<string, any>;

package/dist/utils/updateObject.js

@@ -1,4 +1,4 @@
-import { deepMerge } from "./merge.js";
+import { _deepMerge } from "./merge.js";
 /**
  * Updates an object with new values.
  * @param obj - The object to update.
@@ -8,18 +8,30 @@ export default function updateObjectAdvanced(obj, field) {
     if (typeof field !== "object" || field === null) {
         throw new Error("Fields must be an object or object array");
     }
-    if (typeof field !== "object" || field === null) {
-        throw new Error("Fields must be an object or object array");
+    if (Object.keys(field).length === 0) {
+        return obj;
     }
-    updateAdvanced(obj, field);
-    const fieldsSubset = { ...field };
-    Object.keys(fieldsSubset).filter(key => key.startsWith("$")).forEach(key => delete fieldsSubset[key]);
-    updateObject(obj, fieldsSubset);
-    return obj;
+    const newObj = structuredClone(obj);
+    const $fields = {};
+    const subsetFields = {};
+    Object.keys(field).forEach(key => {
+        if (key.startsWith("$"))
+            $fields[key.toLowerCase()] = field[key];
+        else
+            subsetFields[key] = field[key];
+    });
+    mainUpdate(newObj, $fields);
+    const mergedObj = deepMerge(newObj, $fields);
+    updateObject(mergedObj, subsetFields);
+    return mergedObj;
 }
-function updateAdvanced(obj, fields) {
-    mainUpdate(obj, fields);
-    updateUnset(obj, fields);
+function deepMerge(obj, fields) {
+    if (!("$deepmerge" in fields))
+        return obj;
+    if (Object.keys(obj).length === 0)
+        return fields.$deepmerge;
+    _deepMerge(obj, fields.$deepmerge);
+    return obj;
 }
 function mainUpdate(obj, fields) {
     _for(fields, obj, {
@@ -30,7 +42,14 @@ function mainUpdate(obj, fields) {
             }
             return [updater];
         },
-        pushSet: (item, updater) => {
+        pushall: (item, updater) => {
+            if (Array.isArray(item)) {
+                item.push(...updater);
+                return item;
+            }
+            return updater;
+        },
+        pushset: (item, updater) => {
             if (Array.isArray(item)) {
                 item.push(updater);
                 return [...new Set(item)];
@@ -47,47 +66,39 @@ function mainUpdate(obj, fields) {
         },
         merge: (item, updater) => {
             if (typeof item === "object" && typeof updater === "object") {
-                return { ...item, ...updater };
-            }
-            return updater;
-        },
-        deepMerge: (item, updater) => {
-            if (typeof item === "object" && typeof updater === "object") {
-                return deepMerge(item, updater);
+                Object.assign(item, updater);
+                return item;
             }
             return updater;
         },
-        inc: (item, updater, key) => {
+        inc: (item, updater, key, deepObj) => {
             if (typeof item === "number" && typeof updater === "number") {
                 return item + updater;
             }
-            if (!(key in obj))
+            if (!(key in deepObj))
                 return updater;
             throw new Error(`Cannot increment non-numeric value at key: ${key}`);
         },
-        dec: (item, updater, key) => {
+        dec: (item, updater, key, deepObj) => {
             if (typeof item === "number" && typeof updater === "number") {
                 return item - updater;
             }
-            if (!(key in obj))
+            if (!(key in deepObj))
                 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];
+        rename: (_, newKey, oldKey, deepObj) => {
+            if (oldKey in deepObj) {
+                deepObj[newKey] = deepObj[oldKey];
+                delete deepObj[oldKey];
             }
         },
-        set: (_, value) => value
-    });
-}
-function updateUnset(obj, fields) {
-    if ("$unset" in fields) {
-        for (const key of Object.keys(fields["$unset"])) {
-            delete obj[key];
+        set: (_, value) => value,
+        unset: (_, __, key, deepObj) => {
+            if (key in deepObj)
+                delete deepObj[key];
         }
-    }
+    });
 }
 /**
  * Updates an object with new values.
@@ -107,10 +118,31 @@ function _for(fields, obj, 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;
+                if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+                    if (!obj[key])
+                        obj[key] = {};
+                    deepUpdateCheck(value, obj[key], fieldFn);
+                }
+                else {
+                    const res = fieldFn(obj?.[key], value, key, obj);
+                    if (res !== undefined)
+                        obj[key] = res;
+                }
             }
         }
     }
 }
+function deepUpdateCheck(valueObj, targetObj, fieldFn) {
+    for (const [k, v] of Object.entries(valueObj)) {
+        if (typeof v === "object" && v !== null && !Array.isArray(v)) {
+            if (!targetObj[k])
+                targetObj[k] = {};
+            deepUpdateCheck(v, targetObj[k], fieldFn);
+        }
+        else {
+            const res = fieldFn(targetObj[k], v, k, targetObj);
+            if (res !== undefined)
+                targetObj[k] = res;
+        }
+    }
+}

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.2.11";
+export const version = "0.3.0-alpha.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/db-core",
-  "version": "0.2.11",
+  "version": "0.3.0-alpha.0",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "author": "wxn0brP",