@wxn0brp/db-core 0.11.5-alpha.2 → 0.11.6

package/dist/base/actions.d.ts

@@ -1,10 +1,15 @@
 import { ActionsBaseInterface } from "../types/action.js";
 import { DataInternal } from "../types/data.js";
+import { AdapterOpts } from "../types/options.js";
 import { VQueryT } from "../types/query.js";
 export declare abstract class ActionsBase implements ActionsBaseInterface {
     _inited: boolean;
-    numberId: boolean;
+    adapterOpts: AdapterOpts;
     smartExecutor: boolean;
+    get numberId(): boolean;
+    set numberId(value: boolean);
+    get idKey(): string;
+    set idKey(value: string);
     init(...args: any[]): Promise<void>;
     close(...args: any[]): Promise<void>;
     abstract getCollections(): Promise<string[]>;

package/dist/base/actions.js

@@ -1,8 +1,23 @@
-import { setDataForToggleOne, setDataForUpdateOneOrAdd } from "../helpers/assignDataPush.js";
+import { setDataForToggleOne, setDataForUpdateOneOrAdd, } from "../helpers/assignDataPush.js";
 export class ActionsBase {
     _inited = true;
-    numberId = false;
+    adapterOpts = {
+        numberId: false,
+        idKey: "_id",
+    };
     smartExecutor = false;
+    get numberId() {
+        return this.adapterOpts.numberId ?? false;
+    }
+    set numberId(value) {
+        this.adapterOpts.numberId = value;
+    }
+    get idKey() {
+        return this.adapterOpts.idKey ?? "_id";
+    }
+    set idKey(value) {
+        this.adapterOpts.idKey = value;
+    }
     async init(...args) { }
     async close(...args) { }
     async updateOneOrAdd(config) {
@@ -10,13 +25,13 @@ export class ActionsBase {
         if (res)
             return {
                 data: res,
-                type: "updated"
+                type: "updated",
             };
         // transform UpdateOneQuery to AddQuery
         setDataForUpdateOneOrAdd(config);
         return {
             data: await this.add(config),
-            type: "added"
+            type: "added",
         };
     }
     async toggleOne(config) {
@@ -24,13 +39,13 @@ export class ActionsBase {
         if (res)
             return {
                 data: res,
-                type: "removed"
+                type: "removed",
             };
         // transform ToggleOneQuery to AddQuery
         setDataForToggleOne(config);
         return {
             data: await this.add(config),
-            type: "added"
+            type: "added",
         };
     }
 }

package/dist/base/custom.d.ts

@@ -4,7 +4,6 @@ import { VQueryT } from "../types/query.js";
 import { ActionsBase } from "./actions.js";
 export declare abstract class CustomActionsBase extends ActionsBase {
     fileCpu: CustomFileCpu;
-    constructor();
     /**
      * Add a new entry to the specified database.
      */

package/dist/base/custom.js

@@ -3,9 +3,6 @@ import { findUtil } from "../utils/action.js";
 import { ActionsBase } from "./actions.js";
 export class CustomActionsBase extends ActionsBase {
     fileCpu;
-    constructor() {
-        super();
-    }
     /**
      * Add a new entry to the specified database.
      */
@@ -21,7 +18,9 @@ export class CustomActionsBase extends ActionsBase {
      */
     async find(query) {
         await this.ensureCollection(query.collection);
-        const data = await findUtil(query, this.fileCpu, [query.collection]);
+        const data = await findUtil(query, this.fileCpu, [
+            query.collection,
+        ]);
         return data;
     }
     /**
@@ -29,7 +28,7 @@ export class CustomActionsBase extends ActionsBase {
      */
     async findOne(query) {
         await this.ensureCollection(query.collection);
-        let data = await this.fileCpu.findOne(query.collection, query);
+        const data = (await this.fileCpu.findOne(query.collection, query));
         return data || null;
     }
     /**

package/dist/customFileCpu.js

@@ -11,16 +11,14 @@ export class CustomFileCpu {
     }
     async add(file, config) {
         file = pathRepair(file);
-        let entries = await this._readFile(file);
+        const entries = await this._readFile(file);
         entries.push(config.data);
         await this._writeFile(file, entries);
     }
     async find(file, config) {
         file = pathRepair(file);
         const entries = await this._readFile(file);
-        return entries
-            .map((entry) => findObj(config, entry))
-            .filter(Boolean);
+        return entries.map(entry => findObj(config, entry)).filter(Boolean);
     }
     async findOne(file, config) {
         file = pathRepair(file);
@@ -36,7 +34,7 @@ export class CustomFileCpu {
         file = pathRepair(file);
         let entries = await this._readFile(file);
         const removed = [];
-        entries = entries.filter((entry) => {
+        entries = entries.filter(entry => {
             if (removed.length && one)
                 return true;
             if (matchObj(config, entry)) {
@@ -53,7 +51,7 @@ export class CustomFileCpu {
         file = pathRepair(file);
         let entries = await this._readFile(file);
         const updated = [];
-        entries = entries.map((entry) => {
+        entries = entries.map(entry => {
             if (updated.length && one)
                 return entry;
             if (matchObj(config, entry)) {

package/dist/db/memory.js

@@ -40,7 +40,9 @@ export class MemoryAction extends CustomActionsBase {
 }
 export class ValtheraMemory extends ValtheraClass {
     constructor(...args) {
-        super({ adapter: new MemoryAction() });
+        super({
+            adapter: new MemoryAction(),
+        });
     }
 }
 export function createMemoryValthera(data) {

package/dist/db/multiStorage.js

@@ -14,57 +14,65 @@ export class MultiBackend extends ActionsBase {
         await Promise.all(this.backends.map(b => b.close(...args)));
     }
     async add(config) {
-        return await this.primaryBackend.add({ ...config });
+        return await this.primaryBackend.add({
+            ...config,
+        });
     }
     async find(config) {
-        const results = await Promise.all(this.backends.map(b => b.find({ ...config })));
+        const results = await Promise.all(this.backends.map(b => b.find({
+            ...config,
+        })));
         return results.flat();
     }
     async findOne(config) {
         for (const backend of this.backends) {
             try {
-                const result = await backend.findOne({ ...config });
+                const result = await backend.findOne({
+                    ...config,
+                });
                 if (result !== null && result !== undefined) {
                     return result;
                 }
             }
-            catch {
-                continue;
-            }
+            catch { }
         }
         return null;
     }
     async update(config) {
-        const results = await Promise.all(this.backends.map(b => b.update({ ...config })));
+        const results = await Promise.all(this.backends.map(b => b.update({
+            ...config,
+        })));
         return results.flat();
     }
     async updateOne(config) {
         for (const backend of this.backends) {
             try {
-                const result = await backend.updateOne({ ...config });
+                const result = await backend.updateOne({
+                    ...config,
+                });
                 if (result)
                     return result;
             }
-            catch (error) {
-                continue;
-            }
+            catch (error) { }
         }
         return null;
     }
     async remove(config) {
-        const results = await Promise.all(this.backends.map(b => b.remove({ ...config })));
+        const results = await Promise.all(this.backends.map(b => b.remove({
+            ...config,
+        })));
         return results.flat();
     }
     async removeOne(config) {
         for (const backend of this.backends) {
             try {
-                const result = await backend.removeOne({ ...config });
+                const result = await backend.removeOne({
+                    ...config,
+                });
                 if (result)
                     return result;
             }
-            catch (error) {
-                continue;
-            }
+            catch (error) { }
         }
         return null;
     }

package/dist/db/routedStorage.js

@@ -5,14 +5,19 @@ export class RoutedStorage extends ActionsBase {
     constructor(rules, defaultBackend) {
         super();
         this.rules = rules;
-        this.defaultBackend = Array.isArray(defaultBackend) ? defaultBackend : [defaultBackend];
+        this.defaultBackend = Array.isArray(defaultBackend)
+            ? defaultBackend
+            : [
+                defaultBackend,
+            ];
     }
     _matchBackends(config) {
         const matched = [];
         const { collection } = config;
         for (const rule of this.rules) {
             const { match, backends } = rule;
-            if ((typeof match === "string" && (match === collection) || match === "*") ||
+            if ((typeof match === "string" && match === collection) ||
+                match === "*" ||
                 (match instanceof RegExp && match.test(collection)) ||
                 (typeof match === "function" && match(config))) {
                 matched.push(...backends);
@@ -44,13 +49,19 @@ export class RoutedStorage extends ActionsBase {
     async close(...args) {
         const all = new Set([
             ...this.rules.flatMap(r => r.backends),
-            ...this.defaultBackend
+            ...this.defaultBackend,
         ]);
         await Promise.all(Array.from(all).map(b => b.close(...args)));
     }
     async add(config) {
         const res = await this._withFirst(config, b => b.add(config));
-        await this._withAll({ ...config, data: res }, b => b.add({ ...config, data: res }));
+        await this._withAll({
+            ...config,
+            data: res,
+        }, b => b.add({
+            ...config,
+            data: res,
+        }));
         return res;
     }
     async find(config) {
@@ -81,8 +92,7 @@ export class RoutedStorage extends ActionsBase {
         return this._withAll(collection, b => b.removeCollection(collection), true);
     }
     async getCollections() {
-        const all = await Promise.all(Array.from(new Set(this.rules.flatMap(r => r.backends)))
-            .map(b => b.getCollections()));
+        const all = await Promise.all(Array.from(new Set(this.rules.flatMap(r => r.backends))).map(b => b.getCollections()));
         const merged = new Set(all.flat());
         return Array.from(merged);
     }

package/dist/db/valthera.js

@@ -37,10 +37,20 @@ export class ValtheraClass {
         this.executor = options.executor || new SmartExecutor(undefined, false);
         options.adapter ??= options.dbAction;
         options.dbAction ??= options.adapter;
+        options.adapterOpts ??= {};
+        if (options.numberId !== undefined &&
+            options.adapterOpts.numberId === undefined)
+            options.adapterOpts.numberId = options.numberId;
+        if (options.idKey !== undefined && options.adapterOpts.idKey === undefined)
+            options.adapterOpts.idKey = options.idKey;
         if (typeof options.adapter === "function")
             return;
-        else
+        else {
             this.adapter = options.adapter;
+            if (options.adapterOpts) {
+                this.adapter.adapterOpts = options.adapterOpts;
+            }
+        }
     }
     async init(...args) {
         if (this.adapter?._inited)
@@ -52,10 +62,16 @@ export class ValtheraClass {
             if (typeof self.options.adapter === "function")
                 self.adapter = await self.options.adapter();
             // if the executor is not set, and the action wants a smart executor
-            if (!self.options.executor && self.adapter.smartExecutor && self.executor instanceof SmartExecutor)
+            if (!self.options.executor &&
+                self.adapter.smartExecutor &&
+                self.executor instanceof SmartExecutor)
                 self.executor.aware = true;
-            if (self.options.numberId)
-                self.adapter.numberId = true;
+            if (self.options.adapterOpts) {
+                self.adapter.adapterOpts = {
+                    ...self.adapter.adapterOpts,
+                    ...self.options.adapterOpts,
+                };
+            }
             await self.adapter.init(...args);
             self.adapter._inited = true;
         });
@@ -83,7 +99,7 @@ export class ValtheraClass {
                 if (idx < plugins.length)
                     return plugins[idx++].execute(ctx);
                 return self.executor.addOp(self.adapter[ctx.op].bind(self.adapter), ctx.query, typeof ctx.query === "string" ? ctx.query : ctx.query.collection);
-            }
+            },
         };
         const result = await ctx.next();
         this.emitter.emit(ctx.op, ctx.query, result);

package/dist/helpers/addId.js

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

package/dist/helpers/assignDataPush.js

@@ -14,7 +14,7 @@ export function assignDataPush(data) {
         const dk = data[key];
         if (Array.isArray(dk))
             continue;
-        Object.keys(dk).forEach((k) => obj[k] = dk[k]);
+        Object.keys(dk).forEach(k => (obj[k] = dk[k]));
     }
     return obj;
 }

package/dist/helpers/collection.js

@@ -6,49 +6,89 @@ export class Collection {
         this.collection = collection;
     }
     add(data, id_gen) {
-        return this.db.add({ collection: this.collection, data, id_gen });
+        return this.db.add({
+            collection: this.collection,
+            data,
+            id_gen,
+        });
     }
     /**
      * Find data in a database.
      */
     find(search = {}, options = {}, findOpts = {}, context = {}) {
-        return this.db.find({ collection: this.collection, search, dbFindOpts: options, findOpts, context });
+        return this.db.find({
+            collection: this.collection,
+            search,
+            dbFindOpts: options,
+            findOpts,
+            context,
+        });
     }
     /**
      * Find one data entry in a database.
      */
     findOne(search = {}, findOpts = {}, context = {}) {
-        return this.db.findOne({ collection: this.collection, search, findOpts, context });
+        return this.db.findOne({
+            collection: this.collection,
+            search,
+            findOpts,
+            context,
+        });
     }
     /**
      * Update data in a database.
      */
     update(search, updater, context = {}) {
-        return this.db.update({ collection: this.collection, search, updater, context });
+        return this.db.update({
+            collection: this.collection,
+            search,
+            updater,
+            context,
+        });
     }
     /**
      * Update one data entry in a database.
      */
     updateOne(search, updater, context = {}) {
-        return this.db.updateOne({ collection: this.collection, search, updater, context });
+        return this.db.updateOne({
+            collection: this.collection,
+            search,
+            updater,
+            context,
+        });
     }
     /**
      * Remove data from a database.
      */
     remove(search, context = {}) {
-        return this.db.remove({ collection: this.collection, search, context });
+        return this.db.remove({
+            collection: this.collection,
+            search,
+            context,
+        });
     }
     /**
      * Remove one data entry from a database.
      */
     removeOne(search, context = {}) {
-        return this.db.removeOne({ collection: this.collection, search, context });
+        return this.db.removeOne({
+            collection: this.collection,
+            search,
+            context,
+        });
     }
     /**
      * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
      */
     updateOneOrAdd(search, updater, { add_arg = {}, context = {}, id_gen = true } = {}) {
-        return this.db.updateOneOrAdd({ collection: this.collection, search, updater, add_arg, context, id_gen });
+        return this.db.updateOneOrAdd({
+            collection: 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.
@@ -57,6 +97,11 @@ export class Collection {
      * after the operation.
      */
     toggleOne(search, data = {}, context = {}) {
-        return this.db.toggleOne({ collection: this.collection, search, data, context });
+        return this.db.toggleOne({
+            collection: this.collection,
+            search,
+            data,
+            context,
+        });
     }
 }

package/dist/helpers/executor.js

@@ -12,9 +12,11 @@ export class Executor {
         return await new Promise((resolve, reject) => {
             this.queue.push({
                 func,
-                param: [query],
+                param: [
+                    query,
+                ],
                 resolve,
-                reject
+                reject,
             });
             this.execute();
         });
@@ -28,7 +30,10 @@ export class Executor {
         this.isExecuting = true;
         while (this.queue.length > 0) {
             const q = this.queue.shift();
-            await q.func(...q.param).then(q.resolve).catch(q.reject);
+            await q
+                .func(...q.param)
+                .then(q.resolve)
+                .catch(q.reject);
         }
         this.isExecuting = false;
     }
@@ -45,14 +50,14 @@ export class SmartExecutor {
         this.aware = aware;
     }
     async addOp(func, query, collection) {
-        const key = this.aware ?
-            collection ?? defaultCollection :
-            defaultCollection;
+        const key = this.aware
+            ? (collection ?? defaultCollection)
+            : defaultCollection;
         let entry = this.collections.get(key);
         if (!entry) {
             entry = {
                 executor: new Executor(),
-                interval: null
+                interval: null,
             };
             this.collections.set(key, entry);
         }

package/dist/helpers/forge.js

@@ -14,6 +14,6 @@ export function forgeTypedValthera(target) {
         },
         set(target, prop, value, receiver) {
             return Reflect.set(target, prop, value, receiver);
-        }
+        },
     });
 }

package/dist/helpers/gen.js

@@ -17,7 +17,10 @@ const defaultIdData = getIdData();
  */
 export function genId(parts = null, idData = defaultIdData) {
     if (parts === null)
-        parts = [1, 1];
+        parts = [
+            1,
+            1,
+        ];
     const time = getTime();
     const id = getUniqueRandom({
         time,
@@ -43,7 +46,10 @@ function getUniqueRandom(opts, idData) {
         const partsLengthSum = opts.partsSchema.reduce((acc, num) => acc + num, 0);
         const partsData = generateBase36InRange(minValue, partsLengthSum, idData);
         const parts = splitStringByArray(opts.partsSchema, partsData);
-        const id = [opts.time, ...parts].join("-");
+        const id = [
+            opts.time,
+            ...parts,
+        ].join("-");
         if (!idData.usedIds.has(id)) {
             idData.usedIds.set(id, true);
             setTimeout(() => idData.usedIds.delete(id), 1000);
@@ -130,11 +136,12 @@ function biasedRandomInRange(min, max) {
  */
 function splitStringByArray(arr, str) {
     let start = 0;
-    return arr.map(length => str.slice(start, start += length));
+    // biome-ignore lint/suspicious/noAssignInExpressions: false positive
+    return arr.map(length => str.slice(start, (start += length)));
 }
 /**
  * Gets the current time in a base36 string format.
  */
 function getTime() {
-    return new Date().getTime().toString(36);
+    return Date.now().toString(36);
 }

package/dist/helpers/relation.d.ts

@@ -2,7 +2,10 @@ import { Search } from "../types/arg.js";
 import { DbFindOpts } from "../types/options.js";
 import { RelationTypes } from "../types/relation.js";
 export declare function pickByPath(obj: any, paths: string[][]): any;
-export declare function autoSelect(rel: RelationTypes.RelationConfig, key: string): [string[] | undefined, boolean];
+export declare function autoSelect(rel: RelationTypes.RelationConfig, key: string): [
+    string[] | undefined,
+    boolean
+];
 export declare function convertSearchObjToSearchArray(obj: Record<string, any>, parentKeys?: string[]): string[][];
 export declare function processRelations(dbs: RelationTypes.DBS, cfg: RelationTypes.Relation, data: any, parentList?: any[] | null): Promise<void>;
 export declare class Relation {

package/dist/helpers/relation.js

@@ -20,23 +20,41 @@ export function pickByPath(obj, paths) {
     return result;
 }
 export function autoSelect(rel, key) {
-    const select = Array.isArray(rel.select) ? [...rel.select] : undefined;
+    const select = Array.isArray(rel.select)
+        ? [
+            ...rel.select,
+        ]
+        : undefined;
     const shouldDelete = select && !select.includes(key);
     if (shouldDelete)
         select.push(key);
-    return [select, shouldDelete];
+    return [
+        select,
+        shouldDelete,
+    ];
 }
 export function convertSearchObjToSearchArray(obj, parentKeys = []) {
     return Object.entries(obj).reduce((acc, [key, value]) => {
-        const currentPath = [...parentKeys, key];
+        const currentPath = [
+            ...parentKeys,
+            key,
+        ];
         if (!value) {
             return acc;
         }
-        else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-            return [...acc, ...convertSearchObjToSearchArray(value, currentPath)];
+        else if (typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value)) {
+            return [
+                ...acc,
+                ...convertSearchObjToSearchArray(value, currentPath),
+            ];
         }
         else {
-            return [...acc, currentPath];
+            return [
+                ...acc,
+                currentPath,
+            ];
         }
     }, []);
 }
@@ -44,23 +62,38 @@ export async function processRelations(dbs, cfg, data, parentList = null) {
     if (!data && !parentList)
         return;
     const batchMode = Array.isArray(parentList);
-    const targets = batchMode ? parentList : [data];
+    const targets = batchMode
+        ? parentList
+        : [
+            data,
+        ];
     for (const key in cfg) {
-        if (!cfg.hasOwnProperty(key))
+        if (!Object.hasOwn(cfg, key))
             continue;
         const rel = cfg[key];
-        const { pk = "_id", fk = "_id", type = "1", path, as = key, select, dbFindOpts = {}, through } = rel;
+        const { pk = "_id", fk = "_id", type = "1", path, as = key, select, dbFindOpts = {}, through, } = rel;
         const [dbKey, collection] = path;
         const db = dbs[dbKey];
         if (type === "1") {
-            const keys = [...new Set(targets.map(i => i[pk]))];
+            const keys = [
+                ...new Set(targets.map(i => i[pk])),
+            ];
             const [selectSafe, deleteSelect] = autoSelect(rel, fk);
             const results = await db.find({
                 collection,
-                search: { $in: { [fk]: keys } },
-                findOpts: { select: selectSafe }
+                search: {
+                    $in: {
+                        [fk]: keys,
+                    },
+                },
+                findOpts: {
+                    select: selectSafe,
+                },
             });
-            const map = new Map(results.map(row => [row[fk], row]));
+            const map = new Map(results.map(row => [
+                row[fk],
+                row,
+            ]));
             for (const item of targets) {
                 const result = map.get(item[pk]) || null;
                 if (result && rel.relations)
@@ -78,8 +111,12 @@ export async function processRelations(dbs, cfg, data, parentList = null) {
                 if (!cache.has(id))
                     cache.set(id, await db.findOne({
                         collection,
-                        search: { [fk]: id },
-                        findOpts: { select: selectSafe }
+                        search: {
+                            [fk]: id,
+                        },
+                        findOpts: {
+                            select: selectSafe,
+                        },
                     }));
                 const result = cache.get(id) || null;
                 if (result && rel.relations)
@@ -94,13 +131,20 @@ export async function processRelations(dbs, cfg, data, parentList = null) {
             const [selectSafe, deleteSelect] = autoSelect(rel, fk);
             const results = await db.find({
                 collection,
-                search: { $in: { [fk]: ids } },
+                search: {
+                    $in: {
+                        [fk]: ids,
+                    },
+                },
                 dbFindOpts,
-                findOpts: { select: selectSafe }
+                findOpts: {
+                    select: selectSafe,
+                },
             });
             const grouped = results.reduce((acc, row) => {
                 const id = row[fk];
-                (acc[id] ||= []).push(row);
+                acc[id] ||= [];
+                acc[id].push(row);
                 return acc;
             }, {});
             for (const item of targets)
@@ -118,13 +162,21 @@ export async function processRelations(dbs, cfg, data, parentList = null) {
                 const pivotDb = dbs[through.db || dbKey];
                 const pivots = await pivotDb.find({
                     collection: through.table,
-                    search: { [through.pk]: item[pk] }
+                    search: {
+                        [through.pk]: item[pk],
+                    },
                 });
                 const ids = pivots.map(p => p[through.fk]);
                 const related = await db.find({
                     collection,
-                    search: { $in: { [fk]: ids } },
-                    findOpts: { select }
+                    search: {
+                        $in: {
+                            [fk]: ids,
+                        },
+                    },
+                    findOpts: {
+                        select,
+                    },
                 });
                 item[as] = related;
                 if (rel.relations) {
@@ -145,7 +197,10 @@ export class Relation {
     async findOne(path, search, relations, select) {
         const [dbKey, collection] = path;
         const db = this.dbs[dbKey];
-        const data = await db.findOne({ collection, search });
+        const data = await db.findOne({
+            collection,
+            search,
+        });
         if (!data)
             return null;
         if (typeof select === "object" && !Array.isArray(select))
@@ -156,7 +211,11 @@ export class Relation {
     async find(path, search, relations, select, dbFindOpts = {}) {
         const [dbKey, collection] = path;
         const db = this.dbs[dbKey];
-        const data = await db.find({ collection, search, dbFindOpts });
+        const data = await db.find({
+            collection,
+            search,
+            dbFindOpts,
+        });
         if (relations)
             await processRelations(this.dbs, relations, null, data);
         if (typeof select === "object" && !Array.isArray(select))

package/dist/types/action.d.ts

@@ -1,8 +1,14 @@
 import { DataInternal } from "./data.js";
+import { AdapterOpts } from "./options.js";
 import { VQueryT } from "./query.js";
 export interface ActionsBaseInterface {
     _inited: boolean;
+    adapterOpts: AdapterOpts;
+    /** @deprecated use `adapterOpts.numberId` */
     numberId: boolean;
+    /** @deprecated use `adapterOpts.idKey` */
+    idKey: string;
+    smartExecutor: boolean;
     init(...args: any[]): Promise<void>;
     close(...args: any[]): Promise<void>;
     getCollections(): Promise<string[]>;

package/dist/types/export.d.ts

@@ -5,6 +5,7 @@ export declare namespace ValtheraTypes {
     type DbFindOpts = import("./options.js").DbFindOpts;
     type FindOpts = import("./options.js").FindOpts;
     type DbOpts = import("./options.js").DbOpts;
+    type AdapterOpts = import("./options.js").AdapterOpts;
     type Data = import("./data.js").Data;
     type SearchOptions = import("./searchOpts.js").SearchOptions;
     type Id = import("./Id.js").Id;

package/dist/types/fileCpu.d.ts

@@ -17,10 +17,10 @@ export interface FileCpu {
      */
     findOne(file: string, config: VQueryT.FindOne, opts?: any): Promise<DataInternal | false>;
     /**
-   * Asynchronously removes entries from a file based on search criteria.
-   * @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`.
-   */
+     * Asynchronously removes entries from a file based on search criteria.
+     * @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, config: VQueryT.Remove, one: boolean, opts?: any): Promise<DataInternal[]>;
     /**
      * Asynchronously updates entries in a file based on search criteria and an updater function or object.

package/dist/types/options.d.ts

@@ -13,18 +13,31 @@ type AdapterOption = {
 };
 export type DbOpts = AdapterOption & {
     executor?: Executor;
+    adapterOpts?: AdapterOpts;
+    /** @deprecated use `adapterOpts.numberId` */
     numberId?: boolean;
+    /** @deprecated use `adapterOpts.idKey` */
+    idKey?: string;
 };
+export interface AdapterOpts {
+    numberId?: boolean;
+    idKey?: string;
+}
 export type FieldPath<T = any> = KeysMatching<T, any> | (string & {}) | string[];
 export interface DbFindOpts<T = any> {
     reverse?: boolean;
     limit?: number;
     offset?: number;
-    sortBy?: KeysMatching<T, any>;
+    sortBy?: KeysMatching<T, any> | {
+        field: KeysMatching<T, any>;
+        asc?: boolean;
+    }[];
     sortAsc?: boolean;
     min?: Record<string, KeysMatching<T, number>>;
     max?: Record<string, KeysMatching<T, number>>;
     avg?: Record<string, KeysMatching<T, number>>;
+    sum?: Record<string, KeysMatching<T, number>>;
+    distinct?: KeysMatching<T, any>;
     groupBy?: KeysMatching<T, any> | KeysMatching<T, any>[];
     count?: Record<string, string>;
 }

package/dist/types/query.js

@@ -1,5 +1 @@
-export var VQueryT;
-(function (VQueryT) {
-    ;
-    ;
-})(VQueryT || (VQueryT = {}));
+export {};

package/dist/types/relation.d.ts

@@ -1,7 +1,10 @@
 import { DbFindOpts } from "./options.js";
 import { ValtheraCompatible } from "./valthera.js";
 export declare namespace RelationTypes {
-    type Path = [string, string];
+    type Path = [
+        string,
+        string
+    ];
     type FieldPath = string[];
     interface DBS {
         [key: string]: ValtheraCompatible;

package/dist/types/searchOpts.d.ts

@@ -20,6 +20,8 @@ export type LogicalOperators<T = any> = {
 };
 /** Comparison Operators with nested support */
 export type ComparisonOperators<T = any> = {
+    /** 5 != 4 */
+    $ne?: NestedValue<T, any>;
     /** 5 > 4 */
     $gt?: NestedValue<T, number, number>;
     /** 5 < 4 */
@@ -29,7 +31,10 @@ export type ComparisonOperators<T = any> = {
     /** 5 <= 4 */
     $lte?: NestedValue<T, number, number>;
     /** 5 between [min, max] */
-    $between?: NestedValue<T, [number, number], number>;
+    $between?: NestedValue<T, [
+        number,
+        number
+    ], number>;
     /** 2 in [1, 2, 3] */
     $in?: {
         [K in keyof T]?: T[K] extends any[] ? T[K] : T[K][];
@@ -87,6 +92,10 @@ export type StringOperators<T = any> = {
     $startsWith?: NestedValue<T, string, string>;
     /** "John" ends with "hn" */
     $endsWith?: NestedValue<T, string, string>;
+    /** "John" starts with "jo" (case-insensitive) */
+    $iStartsWith?: NestedValue<T, string, string>;
+    /** "John" ends with "HN" (case-insensitive) */
+    $iEndsWith?: NestedValue<T, string, string>;
 };
 /** Other Operators with nested support */
 export type OtherOperators<T = any> = {

package/dist/utils/action.js

@@ -1,12 +1,14 @@
 import { compareSafe } from "./compare.js";
 export async function findUtil(query, fileCpuOrData, files, fileCpuOpts) {
     const { dbFindOpts = {} } = query;
-    const { reverse = false, offset = 0, limit = -1, sortBy, sortAsc = true, min, max, avg, groupBy, count, } = dbFindOpts;
-    const needsAllData = min || max || avg || groupBy || count || sortBy;
+    const { reverse = false, offset = 0, limit = -1, sortBy, sortAsc = true, min, max, avg, sum, distinct, groupBy, count, } = dbFindOpts;
+    const needsAllData = min || max || avg || sum || distinct || groupBy || count || sortBy;
     let datas = [];
     let skippedEntries = 0;
     if (Array.isArray(fileCpuOrData)) {
-        datas = [...fileCpuOrData];
+        datas = [
+            ...fileCpuOrData,
+        ];
         if (reverse && !sortBy)
             datas.reverse();
         if (!needsAllData) {
@@ -18,9 +20,13 @@ export async function findUtil(query, fileCpuOrData, files, fileCpuOpts) {
         }
     }
     else {
-        const filesToProcess = reverse && !sortBy ? [...files].reverse() : files;
+        const filesToProcess = reverse && !sortBy
+            ? [
+                ...files,
+            ].reverse()
+            : files;
         for (const f of filesToProcess) {
-            let entries = await fileCpuOrData.find(f, query, fileCpuOpts);
+            let entries = (await fileCpuOrData.find(f, query, fileCpuOpts));
             if (reverse && !sortBy)
                 entries.reverse();
             if (needsAllData) {
@@ -48,19 +54,30 @@ export async function findUtil(query, fileCpuOrData, files, fileCpuOpts) {
     }
     if (!needsAllData)
         return datas;
-    if (min || max || avg || groupBy || count) {
+    const hasAggregations = min || max || avg || sum || groupBy || count;
+    if (hasAggregations) {
         const groups = new Map();
-        const groupKeys = Array.isArray(groupBy) ? groupBy : groupBy ? [groupBy] : [];
+        const groupKeys = Array.isArray(groupBy)
+            ? groupBy
+            : groupBy
+                ? [
+                    groupBy,
+                ]
+                : [];
         if (groupKeys.length) {
             for (const data of datas) {
-                const key = groupKeys.map(k => String(data[k] ?? "")).join("|");
+                const key = groupKeys
+                    .map(k => String(data[k] ?? ""))
+                    .join("|");
                 if (!groups.has(key))
                     groups.set(key, []);
                 groups.get(key).push(data);
             }
         }
         else {
-            groups.set("all", [...datas]);
+            groups.set("all", [
+                ...datas,
+            ]);
         }
         const aggregated = [];
         for (const [, groupItems] of groups) {
@@ -76,25 +93,61 @@ export async function findUtil(query, fileCpuOrData, files, fileCpuOpts) {
                 }
             }
             for (const [outKey, srcField] of Object.entries(min ?? {})) {
-                const nums = groupItems.map(d => Number(d[srcField])).filter(n => !isNaN(n));
+                const nums = groupItems
+                    .map(d => Number(d[srcField]))
+                    .filter(n => !Number.isNaN(n));
                 result[outKey] = nums.length ? Math.min(...nums) : null;
             }
             for (const [outKey, srcField] of Object.entries(max ?? {})) {
-                const nums = groupItems.map(d => Number(d[srcField])).filter(n => !isNaN(n));
+                const nums = groupItems
+                    .map(d => Number(d[srcField]))
+                    .filter(n => !Number.isNaN(n));
                 result[outKey] = nums.length ? Math.max(...nums) : null;
             }
             for (const [outKey, srcField] of Object.entries(avg ?? {})) {
-                const nums = groupItems.map(d => Number(d[srcField])).filter(n => !isNaN(n));
-                result[outKey] = nums.length ? nums.reduce((a, b) => a + b, 0) / nums.length : null;
+                const nums = groupItems
+                    .map(d => Number(d[srcField]))
+                    .filter(n => !Number.isNaN(n));
+                result[outKey] = nums.length
+                    ? nums.reduce((a, b) => a + b, 0) / nums.length
+                    : null;
+            }
+            for (const [outKey, srcField] of Object.entries(sum ?? {})) {
+                const nums = groupItems
+                    .map(d => Number(d[srcField]))
+                    .filter(n => !Number.isNaN(n));
+                result[outKey] = nums.length ? nums.reduce((a, b) => a + b, 0) : null;
             }
             aggregated.push(result);
         }
         datas = aggregated;
     }
+    if (distinct) {
+        const seen = new Set();
+        datas = datas.filter(item => {
+            const val = item[distinct];
+            const key = JSON.stringify(val);
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+    }
     if (sortBy) {
         if (sortBy === "random()") {
             datas.sort(() => Math.random() - 0.5);
         }
+        else if (Array.isArray(sortBy)) {
+            datas.sort((a, b) => {
+                for (const { field, asc = true } of sortBy) {
+                    const dir = asc ? 1 : -1;
+                    const cmp = compareSafe(a[field], b[field]) * dir;
+                    if (cmp !== 0)
+                        return cmp;
+                }
+                return 0;
+            });
+        }
         else {
             const dir = sortAsc ? 1 : -1;
             datas.sort((a, b) => compareSafe(a[sortBy], b[sortBy]) * dir);

package/dist/utils/compare.js

@@ -12,11 +12,12 @@ export function compareSafe(a, b) {
     if (typeA === "string" && typeB === "string") {
         return a.localeCompare(b);
     }
-    if ((typeA === "number" || a instanceof Date) && (typeB === "number" || b instanceof Date)) {
-        return (a < b) ? -1 : (a > b) ? 1 : 0;
+    if ((typeA === "number" || a instanceof Date) &&
+        (typeB === "number" || b instanceof Date)) {
+        return a < b ? -1 : a > b ? 1 : 0;
     }
     if (typeA === "boolean" && typeB === "boolean") {
-        return (a === b) ? 0 : a ? 1 : -1;
+        return a === b ? 0 : a ? 1 : -1;
     }
     // fallback: if both are objects/arrays or different types, consider equal
     return 0;

package/dist/utils/hasFieldsAdvanced.js

@@ -41,6 +41,7 @@ export function hasFieldsAdvanced(obj, fields) {
 }
 function mainCheck(obj, fields) {
     return _for(fields, obj, {
+        ne: (data, value) => data !== value,
         gt: (data, value) => data > value,
         lt: (data, value) => data < value,
         gte: (data, value) => data >= value,
@@ -51,7 +52,7 @@ function mainCheck(obj, fields) {
         exists: (_, shouldExist, key) => {
             if (shouldExist && !(key in obj))
                 return false;
-            if (!shouldExist && (key in obj))
+            if (!shouldExist && key in obj)
                 return false;
             return true;
         },
@@ -69,6 +70,10 @@ function mainCheck(obj, fields) {
         },
         startswith: (data, value) => typeof data === "string" && data.startsWith(value),
         endswith: (data, value) => typeof data === "string" && data.endsWith(value),
+        istartswith: (data, value) => typeof data === "string" &&
+            data.toLowerCase().startsWith(value.toLowerCase()),
+        iendswith: (data, value) => typeof data === "string" &&
+            data.toLowerCase().endsWith(value.toLowerCase()),
         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)),

package/dist/utils/id.d.ts

@@ -1,5 +1,15 @@
 export declare function convertIdToUnix(id: string): number;
+/**
+ * Sorts an array of objects by their _id property
+ */
 export declare function sortByIds<T extends {
     _id: string;
 }>(objects: T[]): T[];
+export declare function sortByIds<T extends Record<string, any>>(objects: T[], key: string): T[];
+/**
+ * Sorts an array of objects using reference
+ * @param objects
+ * @param key default "_id"
+ */
+export declare function sortByIdsRef(objects: Record<string, any>[], key?: string): void;
 export declare function compareIds(a: string | number, b: string | number): number;

package/dist/utils/id.js

@@ -1,8 +1,16 @@
 export function convertIdToUnix(id) {
     return parseInt(id.split("-")[0], 36);
 }
-export function sortByIds(objects) {
-    return objects.slice().sort((a, b) => compareIds(a._id, b._id));
+export function sortByIds(objects, key = "_id") {
+    return objects.slice().sort((a, b) => compareIds(a[key], b[key]));
+}
+/**
+ * Sorts an array of objects using reference
+ * @param objects
+ * @param key default "_id"
+ */
+export function sortByIdsRef(objects, key = "_id") {
+    objects.sort((a, b) => compareIds(a[key], b[key]));
 }
 export function compareIds(a, b) {
     if (typeof a === "string" && typeof b === "string")

package/dist/utils/merge.js

@@ -8,11 +8,15 @@ export function _deepMerge(target, ...sources) {
         for (const key in source) {
             if (isObject(source[key])) {
                 if (!target[key])
-                    Object.assign(target, { [key]: {} });
+                    Object.assign(target, {
+                        [key]: {},
+                    });
                 _deepMerge(target[key], source[key]);
             }
             else {
-                Object.assign(target, { [key]: source[key] });
+                Object.assign(target, {
+                    [key]: source[key],
+                });
             }
         }
     }
@@ -22,5 +26,5 @@ export function deepMerge(target, ...sources) {
     return _deepMerge(structuredClone(target), ...sources.map(s => structuredClone(s)));
 }
 function isObject(item) {
-    return (item && typeof item === "object" && !Array.isArray(item));
+    return item && typeof item === "object" && !Array.isArray(item);
 }

package/dist/utils/process.js

@@ -12,7 +12,9 @@ export function matchObj(config, obj) {
         return true;
     if (typeof search === "function" && search(obj, context))
         return true;
-    if (typeof search === "object" && !Array.isArray(search) && hasFieldsAdvanced(obj, search))
+    if (typeof search === "object" &&
+        !Array.isArray(search) &&
+        hasFieldsAdvanced(obj, search))
         return true;
     return false;
 }

package/dist/utils/updateFindObject.js

@@ -59,7 +59,7 @@ function deleteNested(obj, path) {
  * @returns The updated object.
  */
 export function updateFindObject(obj, findOpts) {
-    const { transform, select, exclude, } = findOpts;
+    const { transform, select, exclude } = findOpts;
     if (typeof transform === "function")
         obj = transform(obj);
     if (Array.isArray(exclude)) {
@@ -72,7 +72,8 @@ export function updateFindObject(obj, findOpts) {
     if (Array.isArray(select)) {
         const result = {};
         for (const field of select) {
-            if ((typeof field === "string" || Array.isArray(field)) && pathExists(obj, field)) {
+            if ((typeof field === "string" || Array.isArray(field)) &&
+                pathExists(obj, field)) {
                 setNested(result, field, getValueAt(obj, field));
             }
         }

package/dist/utils/updateObject.js

@@ -38,7 +38,9 @@ function mainUpdate(obj, fields) {
                 item.push(updater);
                 return item;
             }
-            return [updater];
+            return [
+                updater,
+            ];
         },
         pushall: (item, updater) => {
             if (Array.isArray(item)) {
@@ -50,9 +52,13 @@ function mainUpdate(obj, fields) {
         pushset: (item, updater) => {
             if (Array.isArray(item)) {
                 item.push(updater);
-                return [...new Set(item)];
+                return [
+                    ...new Set(item),
+                ];
             }
-            return [updater];
+            return [
+                updater,
+            ];
         },
         pull: (item, updater) => {
             if (Array.isArray(item))
@@ -95,7 +101,7 @@ function mainUpdate(obj, fields) {
         unset: (_, __, key, deepObj) => {
             if (key in deepObj)
                 delete deepObj[key];
-        }
+        },
     });
 }
 /**
@@ -104,8 +110,8 @@ function mainUpdate(obj, fields) {
  * @param newVal - An object containing new values to update in the target object.
  */
 function updateObject(obj, newVal) {
-    for (let key in newVal)
-        if (newVal.hasOwnProperty(key))
+    for (const key in newVal)
+        if (Object.hasOwn(newVal, key))
             obj[key] = newVal[key];
     return obj;
 }

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.11.5-alpha.2";
+export const version = "0.11.6";

package/package.json

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