@wxn0brp/db-core 0.9.0 → 0.10.0-alpha.0

package/dist/base/actions.d.ts

@@ -1,21 +1,21 @@
 import { ActionsBaseInterface } from "../types/action.js";
 import { DataInternal } from "../types/data.js";
-import { ToggleOneResult, UpdateOneOrAddResult, VQuery } from "../types/query.js";
+import * as Query from "../types/query.js";
 export declare abstract class ActionsBase implements ActionsBaseInterface {
     _inited: boolean;
     numberId: boolean;
     init(...args: any[]): Promise<void>;
     abstract getCollections(): Promise<string[]>;
-    abstract ensureCollection(config: VQuery): Promise<boolean>;
-    abstract issetCollection(config: VQuery): Promise<boolean>;
-    abstract add(config: VQuery): Promise<DataInternal>;
-    abstract find(config: VQuery): Promise<DataInternal[]>;
-    abstract findOne(config: VQuery): Promise<DataInternal | null>;
-    abstract update(config: VQuery): Promise<DataInternal[]>;
-    abstract updateOne(config: VQuery): Promise<DataInternal | null>;
-    abstract remove(config: VQuery): Promise<DataInternal[]>;
-    abstract removeOne(config: VQuery): Promise<DataInternal | null>;
-    abstract removeCollection(config: VQuery): Promise<boolean>;
-    updateOneOrAdd(config: VQuery): Promise<UpdateOneOrAddResult<DataInternal>>;
-    toggleOne(config: VQuery): Promise<ToggleOneResult<DataInternal>>;
+    abstract ensureCollection(collection: string): Promise<boolean>;
+    abstract issetCollection(collection: string): Promise<boolean>;
+    abstract removeCollection(collection: string): Promise<boolean>;
+    abstract add(config: Query.AddQuery): Promise<DataInternal>;
+    abstract find(config: Query.FindQuery): Promise<DataInternal[]>;
+    abstract findOne(config: Query.FindOneQuery): Promise<DataInternal | null>;
+    abstract update(config: Query.UpdateQuery): Promise<DataInternal[]>;
+    abstract updateOne(config: Query.UpdateQuery): Promise<DataInternal | null>;
+    abstract remove(config: Query.RemoveQuery): Promise<DataInternal[]>;
+    abstract removeOne(config: Query.RemoveQuery): Promise<DataInternal | null>;
+    updateOneOrAdd(config: Query.UpdateOneOrAddQuery): Promise<Query.UpdateOneOrAddResult<DataInternal>>;
+    toggleOne(config: Query.ToggleOneQuery): Promise<Query.ToggleOneResult<DataInternal>>;
 }

package/dist/base/actions.js

@@ -10,6 +10,7 @@ export class ActionsBase {
                 data: res,
                 type: "updated"
             };
+        // transform UpdateOneQuery to AddQuery
         setDataForUpdateOneOrAdd(config);
         return {
             data: await this.add(config),
@@ -23,6 +24,7 @@ export class ActionsBase {
                 data: res,
                 type: "removed"
             };
+        // transform ToggleOneQuery to AddQuery
         setDataForToggleOne(config);
         return {
             data: await this.add(config),

package/dist/base/custom.d.ts

@@ -1,6 +1,6 @@
 import { CustomFileCpu } from "../customFileCpu.js";
 import { Data } from "../types/data.js";
-import { VQuery } from "../types/query.js";
+import * as Query from "../types/query.js";
 import { ActionsBase } from "./actions.js";
 export declare abstract class CustomActionsBase extends ActionsBase {
     fileCpu: CustomFileCpu;
@@ -8,29 +8,29 @@ export declare abstract class CustomActionsBase extends ActionsBase {
     /**
      * Add a new entry to the specified database.
      */
-    add(query: VQuery): Promise<import("../types/arg.js").Arg<Data>>;
+    add(query: Query.AddQuery): Promise<import("../types/arg.js").Arg<Data>>;
     /**
      * Find entries in the specified database based on search criteria.
      */
-    find(query: VQuery): Promise<Data[]>;
+    find(query: Query.FindQuery): Promise<Data[]>;
     /**
      * Find the first matching entry in the specified database based on search criteria.
      */
-    findOne({ collection, search, context, findOpts }: VQuery): Promise<Data>;
+    findOne(query: Query.FindOneQuery): Promise<Data>;
     /**
      * Update entries in the specified database based on search criteria and an updater function or object.
      */
-    update({ collection, search, updater, context }: VQuery): Promise<Data[]>;
+    update(query: Query.UpdateQuery): Promise<Data[]>;
     /**
      * Update the first matching entry in the specified database based on search criteria and an updater function or object.
      */
-    updateOne({ collection, search, updater, context }: VQuery): Promise<Data>;
+    updateOne(query: Query.UpdateQuery): Promise<Data>;
     /**
      * Remove entries from the specified database based on search criteria.
      */
-    remove({ collection, search, context }: VQuery): Promise<Data[]>;
+    remove(query: Query.RemoveQuery): Promise<Data[]>;
     /**
      * Remove the first matching entry from the specified database based on search criteria.
      */
-    removeOne({ collection, search, context }: VQuery): Promise<Data>;
+    removeOne(query: Query.RemoveQuery): Promise<Data>;
 }

package/dist/base/custom.js

@@ -10,56 +10,56 @@ export class CustomActionsBase extends ActionsBase {
      * Add a new entry to the specified database.
      */
     async add(query) {
-        await this.ensureCollection(query);
+        await this.ensureCollection(query.collection);
         await addId(query, this);
         const { collection, data } = query;
-        await this.fileCpu.add(collection, data);
+        await this.fileCpu.add({ collection, data });
         return data;
     }
     /**
      * Find entries in the specified database based on search criteria.
      */
     async find(query) {
-        await this.ensureCollection(query);
+        await this.ensureCollection(query.collection);
         const data = await findUtil(query, this.fileCpu, [query.collection]);
         return data;
     }
     /**
      * Find the first matching entry in the specified database based on search criteria.
      */
-    async findOne({ collection, search, context = {}, findOpts = {} }) {
-        await this.ensureCollection(arguments[0]);
-        let data = await this.fileCpu.findOne(collection, search, context, findOpts);
+    async findOne(query) {
+        await this.ensureCollection(query.collection);
+        let data = await this.fileCpu.findOne(query);
         return data || null;
     }
     /**
      * Update entries in the specified database based on search criteria and an updater function or object.
      */
-    async update({ collection, search, updater, context = {} }) {
-        await this.ensureCollection(arguments[0]);
-        return await this.fileCpu.update(collection, false, search, updater, context);
+    async update(query) {
+        await this.ensureCollection(query.collection);
+        return await this.fileCpu.update(query, false);
     }
     /**
      * Update the first matching entry in the specified database based on search criteria and an updater function or object.
      */
-    async updateOne({ collection, search, updater, context = {} }) {
-        await this.ensureCollection(arguments[0]);
-        const res = await this.fileCpu.update(collection, true, search, updater, context);
+    async updateOne(query) {
+        await this.ensureCollection(query.collection);
+        const res = await this.fileCpu.update(query, true);
         return res.length ? res[0] : null;
     }
     /**
      * Remove entries from the specified database based on search criteria.
      */
-    async remove({ collection, search, context = {} }) {
-        await this.ensureCollection(arguments[0]);
-        return await this.fileCpu.remove(collection, false, search, context);
+    async remove(query) {
+        await this.ensureCollection(query.collection);
+        return await this.fileCpu.remove(query, false);
     }
     /**
      * Remove the first matching entry from the specified database based on search criteria.
      */
-    async removeOne({ collection, search, context = {} }) {
-        await this.ensureCollection(arguments[0]);
-        const res = await this.fileCpu.remove(collection, true, search, context);
+    async removeOne(query) {
+        await this.ensureCollection(query.collection);
+        const res = await this.fileCpu.remove(query, true);
         return res.length ? res[0] : null;
     }
 }

package/dist/customFileCpu.d.ts

@@ -1,8 +1,6 @@
-import { Search, Updater } from "./types/arg.js";
 import { Data } from "./types/data.js";
 import { FileCpu } from "./types/fileCpu.js";
-import { FindOpts } from "./types/options.js";
-import { VContext } from "./types/types.js";
+import * as Query from "./types/query.js";
 export type WriteFile = (file: string, data: any[]) => Promise<void>;
 export type ReadFile = (file: string) => Promise<any[]>;
 export declare function pathRepair(path: string): string;
@@ -10,9 +8,9 @@ export declare class CustomFileCpu implements FileCpu {
     _readFile: ReadFile;
     _writeFile: WriteFile;
     constructor(readFile: ReadFile, writeFile: WriteFile);
-    add(file: string, data: Data): Promise<void>;
-    find(file: string, search: Search, context?: VContext, findOpts?: FindOpts): Promise<Data[]>;
-    findOne(file: string, search: Search, context?: VContext, findOpts?: FindOpts): Promise<Data | false>;
-    remove(file: string, one: boolean, search: Search, context?: VContext): Promise<Data[]>;
-    update(file: string, one: boolean, search: Search, updater: Updater, context?: VContext): Promise<Data[]>;
+    add(config: Query.AddQuery): Promise<void>;
+    find(config: Query.FindQuery): Promise<Data[]>;
+    findOne(config: Query.FindOneQuery): Promise<Data | false>;
+    remove(config: Query.RemoveQuery, one: boolean): Promise<Data[]>;
+    update(config: Query.UpdateQuery, one: boolean): Promise<Data[]>;
 }

package/dist/customFileCpu.js

@@ -11,32 +11,35 @@ export class CustomFileCpu {
         this._readFile = readFile;
         this._writeFile = writeFile;
     }
-    async add(file, data) {
-        file = pathRepair(file);
+    async add(config) {
+        const file = pathRepair(config.collection);
         let entries = await this._readFile(file);
-        entries.push(data);
+        entries.push(config.data);
         await this._writeFile(file, entries);
     }
-    async find(file, search, context = {}, findOpts = {}) {
-        file = pathRepair(file);
+    async find(config) {
+        const file = pathRepair(config.collection);
         const entries = await this._readFile(file);
+        const { search, context = {}, findOpts = {} } = config;
         const results = entries.filter(entry => typeof search === "function" ? search(entry, context) : hasFieldsAdvanced(entry, search));
         return results.length ?
             results.map(res => updateFindObject(res, findOpts)) :
             [];
     }
-    async findOne(file, search, context = {}, findOpts = {}) {
-        file = pathRepair(file);
+    async findOne(config) {
+        const file = pathRepair(config.collection);
         const entries = await this._readFile(file);
+        const { search, context = {}, findOpts = {} } = config;
         const result = entries.find(entry => typeof search === "function" ? search(entry, context) : hasFieldsAdvanced(entry, search));
         return result ?
             updateFindObject(result, findOpts) :
             false;
     }
-    async remove(file, one, search, context = {}) {
-        file = pathRepair(file);
+    async remove(config, one) {
+        const file = pathRepair(config.collection);
         let entries = await this._readFile(file);
         const removed = [];
+        const { search, context = {} } = config;
         entries = entries.filter(entry => {
             if (removed.length && one)
                 return true;
@@ -51,10 +54,11 @@ export class CustomFileCpu {
             await this._writeFile(file, entries);
         return removed;
     }
-    async update(file, one, search, updater, context = {}) {
-        file = pathRepair(file);
+    async update(config, one) {
+        const file = pathRepair(config.collection);
         let entries = await this._readFile(file);
         const updated = [];
+        const { search, updater, context = {} } = config;
         entries = entries.map(entry => {
             if (updated.length && one)
                 return entry;

package/dist/db/memory.d.ts

@@ -1,7 +1,6 @@
 import { CustomActionsBase } from "../base/custom.js";
 import { Collection } from "../helpers/collection.js";
 import { Data } from "../types/data.js";
-import { VQuery } from "../types/query.js";
 import { ValtheraClass } from "./valthera.js";
 export declare class MemoryAction extends CustomActionsBase {
     memory: Map<string, any[]>;
@@ -9,9 +8,9 @@ export declare class MemoryAction extends CustomActionsBase {
     _readMemory(key: string): any[];
     _writeMemory(key: string, data: any[]): void;
     getCollections(): Promise<string[]>;
-    ensureCollection({ collection }: VQuery): Promise<boolean>;
-    issetCollection({ collection }: VQuery): Promise<boolean>;
-    removeCollection({ collection }: VQuery): Promise<boolean>;
+    ensureCollection(collection: string): Promise<boolean>;
+    issetCollection(collection: string): Promise<boolean>;
+    removeCollection(collection: string): Promise<boolean>;
 }
 export declare class ValtheraMemory extends ValtheraClass {
     constructor(...args: any[]);

package/dist/db/memory.js

@@ -21,16 +21,16 @@ export class MemoryAction extends CustomActionsBase {
         const collections = Array.from(this.memory.keys());
         return collections;
     }
-    async ensureCollection({ collection }) {
+    async ensureCollection(collection) {
         if (this.issetCollection(collection))
             return;
         this.memory.set(collection, []);
         return true;
     }
-    async issetCollection({ collection }) {
+    async issetCollection(collection) {
         return this.memory.has(collection);
     }
-    async removeCollection({ collection }) {
+    async removeCollection(collection) {
         this.memory.delete(collection);
         return true;
     }

package/dist/db/multiStorage.d.ts

@@ -1,19 +1,19 @@
 import { ActionsBase } from "../base/actions.js";
-import { VQuery } from "../types/query.js";
+import * as Query from "../types/query.js";
 export declare class MultiBackend extends ActionsBase {
     backends: ActionsBase[];
     primaryBackend: ActionsBase;
     constructor(backends: ActionsBase[], primaryIndex?: number);
     init(...args: any[]): Promise<void>;
-    add(config: VQuery): Promise<import("../types/data.js").DataInternal>;
-    find(config: VQuery): Promise<import("../types/data.js").DataInternal[]>;
-    findOne(config: VQuery): Promise<import("../types/data.js").DataInternal>;
-    update(config: VQuery): Promise<import("../types/data.js").DataInternal[]>;
-    updateOne(config: VQuery): Promise<import("../types/data.js").DataInternal>;
-    remove(config: VQuery): Promise<import("../types/data.js").DataInternal[]>;
-    removeOne(config: VQuery): Promise<import("../types/data.js").DataInternal>;
-    ensureCollection(config: VQuery): Promise<boolean>;
-    issetCollection(config: VQuery): Promise<boolean>;
-    removeCollection(config: VQuery): Promise<boolean>;
+    add(config: Query.AddQuery): Promise<import("../types/data.js").DataInternal>;
+    find(config: Query.FindQuery): Promise<import("../types/data.js").DataInternal[]>;
+    findOne(config: Query.FindOneQuery): Promise<import("../types/data.js").DataInternal>;
+    update(config: Query.UpdateQuery): Promise<import("../types/data.js").DataInternal[]>;
+    updateOne(config: Query.UpdateQuery): Promise<import("../types/data.js").DataInternal>;
+    remove(config: Query.RemoveQuery): Promise<import("../types/data.js").DataInternal[]>;
+    removeOne(config: Query.RemoveQuery): Promise<import("../types/data.js").DataInternal>;
+    ensureCollection(collection: string): Promise<boolean>;
+    issetCollection(collection: string): Promise<boolean>;
+    removeCollection(collection: string): Promise<boolean>;
     getCollections(): Promise<string[]>;
 }

package/dist/db/multiStorage.js

@@ -65,20 +65,20 @@ export class MultiBackend extends ActionsBase {
         }
         return null;
     }
-    async ensureCollection(config) {
-        const results = await Promise.all(this.backends.map(b => b.ensureCollection({ ...config })));
+    async ensureCollection(collection) {
+        const results = await Promise.all(this.backends.map(b => b.ensureCollection(collection)));
         return results.some(Boolean);
     }
-    async issetCollection(config) {
+    async issetCollection(collection) {
         for (const backend of this.backends) {
-            if (await backend.issetCollection({ ...config })) {
+            if (await backend.issetCollection(collection)) {
                 return true;
             }
         }
         return false;
     }
-    async removeCollection(config) {
-        const results = await Promise.all(this.backends.map(b => b.removeCollection({ ...config })));
+    async removeCollection(collection) {
+        const results = await Promise.all(this.backends.map(b => b.removeCollection(collection)));
         return results.some(Boolean);
     }
     async getCollections() {

package/dist/db/routedStorage.d.ts

@@ -1,6 +1,6 @@
 import { ActionsBase } from "../base/actions.js";
-import { VQuery } from "../types/query.js";
-export type MatchRule = string | RegExp | ((query: VQuery) => boolean);
+import * as Query from "../types/query.js";
+export type MatchRule = string | RegExp | ((config: Query.VQuery) => boolean);
 export interface RouteEntry {
     match: MatchRule;
     backends: ActionsBase[];
@@ -9,19 +9,19 @@ export declare class RoutedStorage extends ActionsBase {
     rules: RouteEntry[];
     defaultBackend: ActionsBase[];
     constructor(rules: RouteEntry[], defaultBackend: ActionsBase | ActionsBase[]);
-    _matchBackends(config: VQuery): ActionsBase[];
-    _withAll<T>(config: VQuery, fn: (b: ActionsBase) => Promise<T>, gather?: boolean): Promise<T>;
-    _withFirst<T>(config: VQuery, fn: (b: ActionsBase) => Promise<T>): Promise<T>;
+    _matchBackends(config: Query.VQuery): ActionsBase[];
+    _withAll<T>(config: Query.VQuery | string, fn: (b: ActionsBase) => Promise<T>, gather?: boolean): Promise<T>;
+    _withFirst<T>(config: Query.VQuery | string, fn: (b: ActionsBase) => Promise<T>): Promise<T>;
     init(...args: any[]): Promise<void>;
-    add(config: VQuery): Promise<import("../types/data.js").DataInternal>;
-    find(config: VQuery): Promise<import("../types/data.js").DataInternal[]>;
-    findOne(config: VQuery): Promise<import("../types/data.js").DataInternal>;
-    update(config: VQuery): Promise<import("../types/data.js").DataInternal[]>;
-    updateOne(config: VQuery): Promise<import("../types/data.js").DataInternal>;
-    remove(config: VQuery): Promise<import("../types/data.js").DataInternal[]>;
-    removeOne(config: VQuery): Promise<import("../types/data.js").DataInternal>;
-    ensureCollection(config: VQuery): Promise<boolean>;
-    issetCollection(config: VQuery): Promise<boolean>;
-    removeCollection(config: VQuery): Promise<boolean>;
+    add(config: Query.AddQuery): Promise<import("../types/data.js").DataInternal>;
+    find(config: Query.FindQuery): Promise<import("../types/data.js").DataInternal[]>;
+    findOne(config: Query.FindOneQuery): Promise<import("../types/data.js").DataInternal>;
+    update(config: Query.UpdateQuery): Promise<import("../types/data.js").DataInternal[]>;
+    updateOne(config: Query.UpdateQuery): Promise<import("../types/data.js").DataInternal>;
+    remove(config: Query.RemoveQuery): Promise<import("../types/data.js").DataInternal[]>;
+    removeOne(config: Query.RemoveQuery): Promise<import("../types/data.js").DataInternal>;
+    ensureCollection(collection: string): Promise<boolean>;
+    issetCollection(collection: string): Promise<boolean>;
+    removeCollection(collection: string): Promise<boolean>;
     getCollections(): Promise<string[]>;
 }

package/dist/db/routedStorage.js

@@ -64,14 +64,14 @@ export class RoutedStorage extends ActionsBase {
     async removeOne(config) {
         return this._withAll(config, b => b.removeOne(config), true);
     }
-    async ensureCollection(config) {
-        return this._withAll(config, b => b.ensureCollection(config), true);
+    async ensureCollection(collection) {
+        return this._withAll(collection, b => b.ensureCollection(collection), true);
     }
-    async issetCollection(config) {
-        return this._withFirst(config, b => b.issetCollection(config));
+    async issetCollection(collection) {
+        return this._withFirst(collection, b => b.issetCollection(collection));
     }
-    async removeCollection(config) {
-        return this._withAll(config, b => b.removeCollection(config), true);
+    async removeCollection(collection) {
+        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)))

package/dist/types/action.d.ts

@@ -1,20 +1,20 @@
 import { DataInternal } from "./data.js";
-import { ToggleOneResult, UpdateOneOrAddResult, VQuery } from "./query.js";
+import * as Query from "./query.js";
 export interface ActionsBaseInterface {
     _inited: boolean;
     numberId: boolean;
     init(...args: any[]): Promise<void>;
     getCollections(): Promise<string[]>;
-    ensureCollection(config: VQuery): Promise<boolean>;
-    issetCollection(config: VQuery): Promise<boolean>;
-    add(config: VQuery): Promise<DataInternal>;
-    find(config: VQuery): Promise<DataInternal[]>;
-    findOne(config: VQuery): Promise<DataInternal | null>;
-    update(config: VQuery): Promise<DataInternal[]>;
-    updateOne(config: VQuery): Promise<DataInternal | null>;
-    remove(config: VQuery): Promise<DataInternal[]>;
-    removeOne(config: VQuery): Promise<DataInternal | null>;
-    removeCollection(config: VQuery): Promise<boolean>;
-    updateOneOrAdd(config: VQuery): Promise<UpdateOneOrAddResult<DataInternal>>;
-    toggleOne(config: VQuery): Promise<ToggleOneResult<DataInternal>>;
+    ensureCollection(collection: string): Promise<boolean>;
+    issetCollection(collection: string): Promise<boolean>;
+    removeCollection(collection: string): Promise<boolean>;
+    add(query: Query.AddQuery): Promise<DataInternal>;
+    find(query: Query.FindQuery): Promise<DataInternal[]>;
+    findOne(query: Query.FindOneQuery): Promise<DataInternal | null>;
+    update(query: Query.UpdateQuery): Promise<DataInternal[]>;
+    updateOne(query: Query.UpdateQuery): Promise<DataInternal | null>;
+    remove(query: Query.RemoveQuery): Promise<DataInternal[]>;
+    removeOne(query: Query.RemoveQuery): Promise<DataInternal | null>;
+    updateOneOrAdd(query: Query.UpdateOneOrAddQuery): Promise<Query.UpdateOneOrAddResult<DataInternal>>;
+    toggleOne(query: Query.ToggleOneQuery): Promise<Query.ToggleOneResult<DataInternal>>;
 }

package/dist/types/fileCpu.d.ts

@@ -1,50 +1,31 @@
-import { Search, Updater } from "./arg.js";
-import { Data, DataInternal } from "./data.js";
-import { FindOpts } from "./options.js";
-import { VContext } from "./types.js";
+import { DataInternal } from "./data.js";
+import * as Query from "./query.js";
 export interface FileCpu {
     /**
      * Asynchronously adds an entry to a file.
-     * @param file The path to the file.
-     * @param data The data to add.
      * @returns A promise resolving to `void`.
      */
-    add(file: string, data: Data): Promise<void>;
+    add(config: Query.AddQuery): Promise<void>;
     /**
      * Asynchronously finds multiple entries in a file based on search criteria.
-     * @param file The path to the file.
-     * @param search The search criteria.
-     * @param context Additional context for the search.
-     * @param findOpts Additional options for searching.
      * @returns A promise resolving to an array of found entries, or `false` if the file does not exist.
      */
-    find(file: string, search: Search, context?: VContext, findOpts?: FindOpts): Promise<DataInternal[]>;
+    find(config: Query.FindQuery): Promise<DataInternal[]>;
     /**
      * Asynchronously finds one entry in a file based on search criteria.
-     * @param file The path to the file.
-     * @param search The search criteria.
-     * @param context Additional context for the search.
-     * @param findOpts Additional options for searching.
      * @returns A promise resolving to the found entry or `false` if not found.
      */
-    findOne(file: string, search: Search, context?: VContext, findOpts?: FindOpts): Promise<DataInternal | false>;
+    findOne(config: Query.FindOneQuery): Promise<DataInternal | false>;
     /**
    * Asynchronously removes entries from a file based on search criteria.
-   * @param file The path to the file.
-   * @param search The search criteria.
-   * @param context Additional context for the operation.
    * @param one If `true`, removes only the first matching entry.
    * @returns A promise resolving to `true` if at least one entry was removed, otherwise `false`.
    */
-    remove(file: string, one: boolean, search: Search, context?: VContext): Promise<DataInternal[]>;
+    remove(config: Query.RemoveQuery, one: boolean): Promise<DataInternal[]>;
     /**
      * Asynchronously updates entries in a file based on search criteria and an updater function or object.
-     * @param file The path to the file.
-     * @param search The search criteria.
-     * @param updater The updater function or object.
-     * @param context Additional context for the operation.
      * @param one If `true`, updates only the first matching entry.
      * @returns A promise resolving to `true` if at least one entry was updated, otherwise `false`.
      */
-    update(file: string, one: boolean, search: Search, updater: Updater, context?: VContext): Promise<DataInternal[]>;
+    update(config: Query.UpdateQuery, one: boolean): Promise<DataInternal[]>;
 }

package/dist/types/query.d.ts

@@ -14,6 +14,7 @@ import { VContext } from "./types.js";
 export interface VQuery_Control {
 }
 export interface VQuery<T = Data> {
+    /** logic path, dir or file, depends on context */
     collection?: string;
     search?: Search<T>;
     context?: VContext;

package/dist/types/valthera.d.ts

@@ -1,19 +1,19 @@
 import { Collection } from "../helpers/collection.js";
 import { Data } from "./data.js";
-import { AddQuery, FindOneQuery, FindQuery, RemoveQuery, ToggleOneQuery, ToggleOneResult, UpdateOneOrAddQuery, UpdateOneOrAddResult, UpdateQuery } from "./query.js";
+import * as Query from "./query.js";
 export interface ValtheraCompatible {
     c<T = Data>(collection: string): Collection<T>;
     getCollections(): Promise<string[]>;
     ensureCollection(collection: string): Promise<boolean>;
     issetCollection(collection: string): Promise<boolean>;
-    add<T = Data>(query: AddQuery<T>): Promise<T>;
-    find<T = Data>(query: FindQuery<T>): Promise<T[]>;
-    findOne<T = Data>(query: FindOneQuery<T>): Promise<T | null>;
-    update<T = Data>(query: UpdateQuery<T>): Promise<T[]>;
-    updateOne<T = Data>(query: UpdateQuery<T>): Promise<T | null>;
-    remove<T = Data>(query: RemoveQuery<T>): Promise<T[]>;
-    removeOne<T = Data>(query: RemoveQuery<T>): Promise<T | null>;
+    add<T = Data>(query: Query.AddQuery<T>): Promise<T>;
+    find<T = Data>(query: Query.FindQuery<T>): Promise<T[]>;
+    findOne<T = Data>(query: Query.FindOneQuery<T>): Promise<T | null>;
+    update<T = Data>(query: Query.UpdateQuery<T>): Promise<T[]>;
+    updateOne<T = Data>(query: Query.UpdateQuery<T>): Promise<T | null>;
+    remove<T = Data>(query: Query.RemoveQuery<T>): Promise<T[]>;
+    removeOne<T = Data>(query: Query.RemoveQuery<T>): Promise<T | null>;
     removeCollection(collection: string): Promise<boolean>;
-    updateOneOrAdd<T = Data>(query: UpdateOneOrAddQuery<T>): Promise<UpdateOneOrAddResult<T>>;
-    toggleOne<T = Data>(query: ToggleOneQuery<T>): Promise<ToggleOneResult<T>>;
+    updateOneOrAdd<T = Data>(query: Query.UpdateOneOrAddQuery<T>): Promise<Query.UpdateOneOrAddResult<T>>;
+    toggleOne<T = Data>(query: Query.ToggleOneQuery<T>): Promise<Query.ToggleOneResult<T>>;
 }

package/dist/utils/action.js

@@ -1,6 +1,6 @@
 import { compareSafe } from "./compare.js";
 export async function findUtil(query, fileCpu, files) {
-    const { search, context = {}, dbFindOpts = {}, findOpts = {} } = query;
+    const { dbFindOpts = {} } = query;
     const { reverse = false, offset = 0, limit = -1, sortBy, sortAsc = true } = dbFindOpts;
     if (reverse && !sortBy)
         files.reverse();
@@ -8,7 +8,7 @@ export async function findUtil(query, fileCpu, files) {
     let totalEntries = 0;
     let skippedEntries = 0;
     for (const f of files) {
-        let entries = await fileCpu.find(f, search, context, findOpts);
+        let entries = await fileCpu.find(Object.assign({}, query, { collection: f }));
         if (reverse && !sortBy)
             entries.reverse();
         if (!sortBy) {

package/dist/version.js

@@ -1 +1 @@
-export const version = "0.9.0";
+export const version = "0.10.0-alpha.0";

package/package.json

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