@wxn0brp/db-core 0.3.2 → 0.5.0-alpha.0

package/dist/helpers/collection.d.ts

@@ -0,0 +1,49 @@
+import { Arg, Search, Updater } from "../types/arg.js";
+import { Data } from "../types/data.js";
+import { DbFindOpts, FindOpts } from "../types/options.js";
+import { VContext } from "../types/types.js";
+import { UpdateOneOrAdd, ValtheraCompatible } from "../types/valthera.js";
+export declare class Collection<D = Data> {
+    db: ValtheraCompatible;
+    collection: string;
+    constructor(db: ValtheraCompatible, collection: string);
+    /**
+     * Add data to a database.
+     */
+    add(data: Arg<D>, id_gen: true): Promise<D>;
+    add(data: Arg<D>, id_gen?: true): Promise<D & {
+        _id: string;
+    }>;
+    /**
+     * Find data in a database.
+     */
+    find(search?: Search<D>, options?: DbFindOpts<D>, findOpts?: FindOpts<D>, context?: VContext): Promise<D[]>;
+    /**
+     * Find one data entry in a database.
+     */
+    findOne(search?: Search<D>, findOpts?: FindOpts<D>, context?: VContext): Promise<D>;
+    /**
+     * Update data in a database.
+     */
+    update(search: Search<D>, updater: Updater<D>, context?: VContext): Promise<D[]>;
+    /**
+     * Update one data entry in a database.
+     */
+    updateOne(search: Search<D>, updater: Updater<D>, context?: VContext): Promise<D>;
+    /**
+     * Remove data from a database.
+     */
+    remove(search: Search<D>, context?: VContext): Promise<D[]>;
+    /**
+     * Remove one data entry from a database.
+     */
+    removeOne(search: Search<D>, context?: VContext): Promise<D>;
+    /**
+     * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
+     */
+    updateOneOrAdd(search: Search<D>, updater: Updater<D>, { add_arg, context, id_gen }?: UpdateOneOrAdd<D>): Promise<D>;
+    /**
+     * 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(search: Search<D>, data?: Arg<D>, context?: VContext): Promise<D>;
+}

package/dist/helpers/collection.js

@@ -0,0 +1,59 @@
+export class Collection {
+    db;
+    collection;
+    constructor(db, collection) {
+        this.db = db;
+        this.collection = collection;
+    }
+    add(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 });
+    }
+    /**
+     * Find one data entry in a database.
+     */
+    findOne(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 });
+    }
+    /**
+     * Update one data entry in a database.
+     */
+    updateOne(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 });
+    }
+    /**
+     * Remove one data entry from a database.
+     */
+    removeOne(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 });
+    }
+    /**
+     * 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(search, data = {}, context = {}) {
+        return this.db.toggleOne({ collection: this.collection, search, data, context });
+    }
+}

package/dist/helpers/executor.d.ts

@@ -1,4 +1,4 @@
-interface Task {
+export interface Task {
     func: Function;
     param: any[];
     resolve: Function;
@@ -8,7 +8,7 @@ interface Task {
  * A simple executor for queuing and executing asynchronous operations sequentially.
  * @class
  */
-declare class ExecutorC {
+export declare class Executor {
     quote: Task[];
     isExecuting: boolean;
     /**
@@ -25,5 +25,3 @@ declare class ExecutorC {
      */
     execute(): Promise<void>;
 }
-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 {
+export class Executor {
     quote;
     isExecuting;
     /**
@@ -42,5 +42,3 @@ class ExecutorC {
         this.isExecuting = false;
     }
 }
-export default ExecutorC;
-export { ExecutorC as executorC };

package/dist/helpers/forge.d.ts

@@ -1,5 +1,5 @@
-import CollectionManager from "./CollectionManager.js";
-import Data from "../types/data.js";
+import { Collection } from "./collection.js";
+import { Data } from "../types/data.js";
 import { ValtheraCompatible } from "../types/valthera.js";
-export declare function forgeValthera<T extends string>(target: ValtheraCompatible): ValtheraCompatible & { [K in T]: CollectionManager; };
-export declare function forgeTypedValthera<T extends Record<string, Data>>(target: ValtheraCompatible): ValtheraCompatible & { [K in keyof T]: CollectionManager<T[K]>; };
+export declare function forgeValthera<T extends string>(target: ValtheraCompatible): ValtheraCompatible & { [K in T]: Collection; };
+export declare function forgeTypedValthera<T extends Record<string, Data>>(target: ValtheraCompatible): ValtheraCompatible & { [K in keyof T]: Collection<T[K]>; };

package/dist/helpers/forge.js

@@ -1,11 +1,11 @@
-import CollectionManager from "./CollectionManager.js";
+import { Collection } from "./collection.js";
 export function forgeValthera(target) {
     return new Proxy(target, {
         get(target, prop, receiver) {
             if (prop in target) {
                 return Reflect.get(target, prop, receiver);
             }
-            const collection = new CollectionManager(target, prop);
+            const collection = new Collection(target, prop);
             target[prop] = collection;
             return collection;
         },

package/dist/helpers/gen.d.ts

@@ -1,8 +1,24 @@
-import Id from "../types/Id.js";
+import { Id } from "../types/Id.js";
+export declare function getIdData(): {
+    usedIds: Map<any, any>;
+    lastId: Id;
+    recentIdsTimestamps: number[];
+    startIndex: number;
+    lastGeneratedMs: number;
+    lastRandomValue: number;
+};
+export type IdData = ReturnType<typeof getIdData>;
 /**
  * Generates a unique random identifier based on time and parts.
  *
  * @param {number[]} [parts] - an array of lengths of parts of the identifier
  * @returns {Id} - a new unique identifier
  */
-export default function genId(parts?: number[]): Id;
+export declare function genId(parts?: number[], idData?: {
+    usedIds: Map<any, any>;
+    lastId: Id;
+    recentIdsTimestamps: number[];
+    startIndex: number;
+    lastGeneratedMs: number;
+    lastRandomValue: number;
+}): Id;

package/dist/helpers/gen.js

@@ -1,16 +1,21 @@
-const usedIdsMap = new Map();
-let lastId;
-const recentIdsTimestamps = [];
-let startIndex = 0;
-let lastGeneratedMs = 0;
-let lastRandomValue = 0;
+export function getIdData() {
+    return {
+        usedIds: new Map(),
+        lastId: undefined,
+        recentIdsTimestamps: [],
+        startIndex: 0,
+        lastGeneratedMs: 0,
+        lastRandomValue: 0,
+    };
+}
+const defaultIdData = getIdData();
 /**
  * Generates a unique random identifier based on time and parts.
  *
  * @param {number[]} [parts] - an array of lengths of parts of the identifier
  * @returns {Id} - a new unique identifier
  */
-export default function genId(parts = null) {
+export function genId(parts = null, idData = defaultIdData) {
     if (parts === null)
         parts = [1, 1];
     const time = getTime();
@@ -18,17 +23,17 @@ export default function genId(parts = null) {
         time,
         partsSchema: parts,
         s: 0,
-    });
+    }, idData);
     return id;
 }
 /**
  * Generates a unique random identifier based on time and parts.
  */
-function getUniqueRandom(opts) {
+function getUniqueRandom(opts, idData) {
     while (true) {
         let minValue = 0;
-        if (lastId) {
-            const parts = lastId.split("-");
+        if (idData.lastId) {
+            const parts = idData.lastId.split("-");
             const lastTime = parts.shift();
             if (lastTime === opts.time) {
                 const int36 = parts.join("");
@@ -36,13 +41,13 @@ function getUniqueRandom(opts) {
             }
         }
         const partsLengthSum = opts.partsSchema.reduce((acc, num) => acc + num, 0);
-        const partsData = generateBase36InRange(minValue, partsLengthSum);
+        const partsData = generateBase36InRange(minValue, partsLengthSum, idData);
         const parts = splitStringByArray(opts.partsSchema, partsData);
         const id = [opts.time, ...parts].join("-");
-        if (!usedIdsMap.has(id)) {
-            usedIdsMap.set(id, true);
-            setTimeout(() => usedIdsMap.delete(id), 1000);
-            lastId = id;
+        if (!idData.usedIds.has(id)) {
+            idData.usedIds.set(id, true);
+            setTimeout(() => idData.usedIds.delete(id), 1000);
+            idData.lastId = id;
             return id;
         }
         opts.s++;
@@ -56,13 +61,14 @@ function getUniqueRandom(opts) {
  * Tracks the current load of the application by counting the number of ids that have been generated in the last second.
  * @returns The number of ids that have been generated in the last second.
  */
-function trackLoad() {
+function trackLoad(idData) {
     const now = Date.now();
-    recentIdsTimestamps.push(now);
-    while (startIndex < recentIdsTimestamps.length && recentIdsTimestamps[startIndex] < now - 1) {
-        startIndex++;
+    idData.recentIdsTimestamps.push(now);
+    while (idData.startIndex < idData.recentIdsTimestamps.length &&
+        idData.recentIdsTimestamps[idData.startIndex] < now - 1) {
+        idData.startIndex++;
     }
-    return recentIdsTimestamps.length - startIndex;
+    return idData.recentIdsTimestamps.length - idData.startIndex;
 }
 /**
  * Generates a base-36 encoded string with a specified length based on a random value within a range.
@@ -77,27 +83,27 @@ function trackLoad() {
  * @param length - The length of the resulting base-36 string.
  * @returns A base-36 encoded string representation of the random value, padded to the specified length.
  */
-function generateBase36InRange(minValue, length) {
+function generateBase36InRange(minValue, length, idData) {
     const maxValue = Math.pow(36, length) - 1;
-    const load = trackLoad();
+    const load = trackLoad(idData);
     const currentMs = Date.now();
-    if (load < 3 || currentMs !== lastGeneratedMs) {
-        lastRandomValue = biasedRandomInRange(minValue, maxValue);
-        lastGeneratedMs = currentMs;
+    if (load < 3 || currentMs !== idData.lastGeneratedMs) {
+        idData.lastRandomValue = biasedRandomInRange(minValue, maxValue);
+        idData.lastGeneratedMs = currentMs;
     }
     else {
         const rand = Math.random();
         if (rand < 0.6) {
-            lastRandomValue += 1;
+            idData.lastRandomValue += 1;
         }
         else if (rand < 0.9) {
-            lastRandomValue += 2;
+            idData.lastRandomValue += 2;
         }
         else {
-            lastRandomValue = biasedRandomInRange(lastRandomValue, maxValue);
+            idData.lastRandomValue = biasedRandomInRange(idData.lastRandomValue, maxValue);
         }
     }
-    return lastRandomValue.toString(36).padStart(length, "0");
+    return idData.lastRandomValue.toString(36).padStart(length, "0");
 }
 /**
  * Generates a random number between the specified range, but with a bias towards the lower

package/dist/helpers/relation.d.ts

@@ -1,10 +1,13 @@
 import { Search } from "../types/arg.js";
 import { DbFindOpts } from "../types/options.js";
 import { RelationTypes } from "../types/relation.js";
-declare class Relation {
+export declare function pickByPath(obj: any, paths: string[][]): any;
+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 {
     dbs: RelationTypes.DBS;
     constructor(dbs: RelationTypes.DBS);
     findOne(path: RelationTypes.Path, search: Search, relations: RelationTypes.Relation, select?: string[][] | Record<string, any>): Promise<any>;
     find(path: RelationTypes.Path, search: Search, relations: RelationTypes.Relation, select?: string[][] | Record<string, any>, dbFindOpts?: DbFindOpts): Promise<any[]>;
 }
-export default Relation;

package/dist/helpers/relation.js

@@ -1,4 +1,4 @@
-function pickByPath(obj, paths) {
+export function pickByPath(obj, paths) {
     const result = {};
     for (const path of paths) {
         let src = obj;
@@ -19,14 +19,14 @@ function pickByPath(obj, paths) {
     }
     return result;
 }
-function autoSelect(rel, key) {
+export function autoSelect(rel, key) {
     const select = Array.isArray(rel.select) ? [...rel.select] : undefined;
     const shouldDelete = select && !select.includes(key);
     if (shouldDelete)
         select.push(key);
     return [select, shouldDelete];
 }
-function convertSearchObjToSearchArray(obj, parentKeys = []) {
+export function convertSearchObjToSearchArray(obj, parentKeys = []) {
     return Object.entries(obj).reduce((acc, [key, value]) => {
         const currentPath = [...parentKeys, key];
         if (!value) {
@@ -40,7 +40,7 @@ function convertSearchObjToSearchArray(obj, parentKeys = []) {
         }
     }, []);
 }
-async function processRelations(dbs, cfg, data, parentList = null) {
+export async function processRelations(dbs, cfg, data, parentList = null) {
     if (!data && !parentList)
         return;
     const batchMode = Array.isArray(parentList);
@@ -49,19 +49,22 @@ async function processRelations(dbs, cfg, data, parentList = null) {
         if (!cfg.hasOwnProperty(key))
             continue;
         const rel = cfg[key];
-        const { pk = "_id", fk = "_id", type = "1", path, as = key, select, findOpts = {}, through } = rel;
-        const [dbKey, coll] = path;
+        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 [selectSafe, deleteSelect] = autoSelect(rel, fk);
-            const results = await db.find(coll, { $in: { [fk]: keys } }, {}, {}, { select: selectSafe });
+            const results = await db.find({
+                collection,
+                search: { $in: { [fk]: keys } },
+                findOpts: { select: selectSafe }
+            });
             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) {
+                if (result && rel.relations)
                     await processRelations(dbs, rel.relations, result);
-                }
                 if (deleteSelect && result)
                     delete result[fk];
                 item[as] = result;
@@ -72,13 +75,15 @@ async function processRelations(dbs, cfg, data, parentList = null) {
             const [selectSafe, deleteSelect] = autoSelect(rel, fk);
             for (const item of targets) {
                 const id = item[pk];
-                if (!cache.has(id)) {
-                    cache.set(id, await db.findOne(coll, { [fk]: id }, {}, { select: selectSafe }));
-                }
+                if (!cache.has(id))
+                    cache.set(id, await db.findOne({
+                        collection,
+                        search: { [fk]: id },
+                        findOpts: { select: selectSafe }
+                    }));
                 const result = cache.get(id) || null;
-                if (result && rel.relations) {
+                if (result && rel.relations)
                     await processRelations(dbs, rel.relations, result);
-                }
                 if (deleteSelect && result)
                     delete result[fk];
                 item[as] = result;
@@ -87,31 +92,40 @@ async function processRelations(dbs, cfg, data, parentList = null) {
         else if (type === "1n") {
             const ids = targets.map(i => i[pk]);
             const [selectSafe, deleteSelect] = autoSelect(rel, fk);
-            const results = await db.find(coll, { $in: { [fk]: ids } }, findOpts || {}, { select: selectSafe });
+            const results = await db.find({
+                collection,
+                search: { $in: { [fk]: ids } },
+                dbFindOpts,
+                findOpts: { select: selectSafe }
+            });
             const grouped = results.reduce((acc, row) => {
                 const id = row[fk];
                 (acc[id] ||= []).push(row);
                 return acc;
             }, {});
-            for (const item of targets) {
+            for (const item of targets)
                 item[as] = grouped[item[pk]] || [];
-            }
-            if (rel.relations) {
+            if (rel.relations)
                 await Promise.all(results.map(row => processRelations(dbs, rel.relations, row)));
-            }
             if (deleteSelect)
                 for (const r of results)
                     delete r[fk];
         }
         else if (type === "nm") {
-            if (!through || !through.table || !through.pk || !through.fk) {
+            if (!through || !through.table || !through.pk || !through.fk)
                 throw new Error(`Relation type "nm" requires a defined "through" in "${key}"`);
-            }
             for (const item of targets) {
                 const pivotDb = dbs[through.db || dbKey];
-                const pivots = await pivotDb.find(through.table, { [through.pk]: item[pk] });
+                const pivots = await pivotDb.find({
+                    collection: through.table,
+                    search: { [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({
+                    collection,
+                    search: { $in: { [fk]: ids } },
+                    findOpts: { select }
+                });
                 item[as] = related;
                 if (rel.relations) {
                     await Promise.all(related.map(row => processRelations(dbs, rel.relations, row)));
@@ -123,33 +137,30 @@ async function processRelations(dbs, cfg, data, parentList = null) {
         }
     }
 }
-class Relation {
+export class Relation {
     dbs;
     constructor(dbs) {
         this.dbs = dbs;
     }
     async findOne(path, search, relations, select) {
-        const [dbKey, coll] = path;
+        const [dbKey, collection] = path;
         const db = this.dbs[dbKey];
-        const data = await db.findOne(coll, search);
+        const data = await db.findOne({ collection, search });
         if (!data)
             return null;
-        if (typeof select === "object" && !Array.isArray(select)) {
+        if (typeof select === "object" && !Array.isArray(select))
             select = convertSearchObjToSearchArray(select);
-        }
         await processRelations(this.dbs, relations, data);
         return select ? pickByPath(data, select) : data;
     }
     async find(path, search, relations, select, dbFindOpts = {}) {
-        const [dbKey, coll] = path;
+        const [dbKey, collection] = path;
         const db = this.dbs[dbKey];
-        const data = await db.find(coll, 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)) {
+        if (typeof select === "object" && !Array.isArray(select))
             select = convertSearchObjToSearchArray(select);
-        }
         return select ? data.map(d => pickByPath(d, select)) : data;
     }
 }
-export default Relation;

package/dist/index.d.ts

@@ -1,13 +1,11 @@
-import CustomFileCpu from "./customFileCpu.js";
-import ValtheraMemory, { createMemoryValthera } from "./db/memory.js";
-import ValtheraClass from "./db/valthera.js";
-import genId from "./helpers/gen.js";
-import Relation from "./helpers/relation.js";
-import { ValtheraTypes } from "./types/export.js";
-import { RelationTypes } from "./types/relation.js";
-import { ValtheraCompatible } from "./types/valthera.js";
-import { forgeTypedValthera, forgeValthera } from "./helpers/forge.js";
-import { sortByIds, convertIdToUnix } from "./utils/id.js";
-export { createMemoryValthera, CustomFileCpu, forgeTypedValthera, forgeValthera, genId, Relation, ValtheraClass, ValtheraMemory, sortByIds, convertIdToUnix, };
-export type { RelationTypes, ValtheraCompatible, ValtheraTypes, };
-export type Id = import("./types/Id.js").Id;
+export { CustomFileCpu } from "./customFileCpu.js";
+export { createMemoryValthera, ValtheraMemory } from "./db/memory.js";
+export { ValtheraClass } from "./db/valthera.js";
+export { forgeTypedValthera, forgeValthera } from "./helpers/forge.js";
+export { genId } from "./helpers/gen.js";
+export { Relation } from "./helpers/relation.js";
+export { convertIdToUnix, sortByIds } from "./utils/id.js";
+export type { ValtheraTypes } from "./types/export.js";
+export type { Id } from "./types/Id.js";
+export type { RelationTypes } from "./types/relation.js";
+export type { ValtheraCompatible } from "./types/valthera.js";

package/dist/index.js

@@ -1,8 +1,7 @@
-import CustomFileCpu from "./customFileCpu.js";
-import ValtheraMemory, { createMemoryValthera } from "./db/memory.js";
-import ValtheraClass from "./db/valthera.js";
-import genId from "./helpers/gen.js";
-import Relation from "./helpers/relation.js";
-import { forgeTypedValthera, forgeValthera } from "./helpers/forge.js";
-import { sortByIds, convertIdToUnix } from "./utils/id.js";
-export { createMemoryValthera, CustomFileCpu, forgeTypedValthera, forgeValthera, genId, Relation, ValtheraClass, ValtheraMemory, sortByIds, convertIdToUnix, };
+export { CustomFileCpu } from "./customFileCpu.js";
+export { createMemoryValthera, ValtheraMemory } from "./db/memory.js";
+export { ValtheraClass } from "./db/valthera.js";
+export { forgeTypedValthera, forgeValthera } from "./helpers/forge.js";
+export { genId } from "./helpers/gen.js";
+export { Relation } from "./helpers/relation.js";
+export { convertIdToUnix, sortByIds } from "./utils/id.js";

package/dist/types/Id.d.ts

@@ -1,3 +1,2 @@
 type Id = string;
-export default Id;
-export { Id };
+export type { Id };

package/dist/types/data.d.ts

@@ -1,4 +1,3 @@
 export interface Data {
     [key: string]: any;
 }
-export default Data;

package/dist/types/fileCpu.d.ts

@@ -1,8 +1,8 @@
 import { Search, Updater } from "./arg.js";
-import Data from "./data.js";
+import { Data } from "./data.js";
 import { FindOpts } from "./options.js";
 import { VContext } from "./types.js";
-interface FileCpu {
+export interface FileCpu {
     /**
      * Asynchronously adds an entry to a file.
      * @param file The path to the file.
@@ -18,7 +18,7 @@ interface FileCpu {
      * @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, search: Search, context?: VContext, findOpts?: FindOpts): Promise<any[] | false>;
+    find(file: string, search: Search, context?: VContext, findOpts?: FindOpts): Promise<Data[]>;
     /**
      * Asynchronously finds one entry in a file based on search criteria.
      * @param file The path to the file.
@@ -27,7 +27,7 @@ interface FileCpu {
      * @param findOpts Additional options for searching.
      * @returns A promise resolving to the found entry or `false` if not found.
      */
-    findOne(file: string, search: Search, context?: VContext, findOpts?: FindOpts): Promise<any | false>;
+    findOne(file: string, search: Search, context?: VContext, findOpts?: FindOpts): Promise<Data | false>;
     /**
    * Asynchronously removes entries from a file based on search criteria.
    * @param file The path to the file.
@@ -36,7 +36,7 @@ interface FileCpu {
    * @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, search: Search, context?: VContext): Promise<boolean>;
+    remove(file: string, one: boolean, search: Search, context?: VContext): Promise<Data[]>;
     /**
      * Asynchronously updates entries in a file based on search criteria and an updater function or object.
      * @param file The path to the file.
@@ -46,6 +46,5 @@ interface FileCpu {
      * @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, search: Search, updater: Updater, context?: VContext): Promise<boolean>;
+    update(file: string, one: boolean, search: Search, updater: Updater, context?: VContext): Promise<Data[]>;
 }
-export default FileCpu;

package/dist/types/options.d.ts

@@ -1,10 +1,10 @@
-import ActionsBase from "../base/actions.js";
-import executorC from "../helpers/executor.js";
+import { ActionsBase } from "../base/actions.js";
+import { Executor } from "../helpers/executor.js";
 import { KeysMatching } from "./utils.js";
 export interface DbOpts {
     maxFileSize?: number;
     dbAction?: ActionsBase;
-    executor?: executorC;
+    executor?: Executor;
     numberId?: boolean;
 }
 export interface DbFindOpts<T = any> {

package/dist/types/query.d.ts

@@ -1,6 +1,17 @@
 import { VContext } from "./types.js";
 import { Arg, Search, Updater } from "./arg.js";
 import { DbFindOpts, FindOpts } from "./options.js";
+/**
+ * To extend via adapters
+ * @example
+ * declare module "@wxn0brp/db-core" {
+ *   export interface VQuery_Control {
+ *     key?: "value";
+ *   }
+ * }
+ */
+export interface VQuery_Control {
+}
 export interface VQuery {
     collection?: string;
     search?: Search;
@@ -11,4 +22,5 @@ export interface VQuery {
     id_gen?: boolean;
     add_arg?: Arg;
     updater?: Updater;
+    control?: VQuery_Control;
 }