@wxn0brp/db 0.7.6 → 0.8.1

package/dist/actions/action.d.ts

@@ -1,15 +1,13 @@
-import { Context } from "../types/types.js";
-import { Arg, Search, Updater } from "../types/arg.js";
+import dbActionBase from "../base/actions.js";
 import Data from "../types/data.js";
 import FileCpu from "../types/fileCpu.js";
-import { DbOpts, DbFindOpts, FindOpts } from "../types/options.js";
-import { SearchOptions } from "../types/searchOpts.js";
-import { Transaction } from "../types/transactions.js";
+import { DbOpts } from "../types/options.js";
+import { VQuery } from "../types/query.js";
 /**
  * A class representing database actions on files.
  * @class
  */
-declare class dbActionC {
+declare class dbActionC extends dbActionBase {
     folder: string;
     options: DbOpts;
     fileCpu: FileCpu;
@@ -28,47 +26,49 @@ declare class dbActionC {
     /**
      * Check and create the specified collection if it doesn't exist.
      */
-    checkCollection(collection: string): Promise<void>;
+    checkCollection({ collection }: VQuery): Promise<boolean>;
     /**
      * Check if a collection exists.
      */
-    issetCollection(collection: string): Promise<boolean>;
+    issetCollection({ collection }: VQuery): Promise<boolean>;
     /**
      * Add a new entry to the specified database.
      */
-    add(collection: string, arg: Arg, id_gen?: boolean): Promise<Arg>;
+    add({ collection, data, id_gen }: VQuery): Promise<import("../types/arg.js").Arg>;
     /**
      * Find entries in the specified database based on search criteria.
      */
-    find(collection: string, arg: Search, context?: Context, options?: DbFindOpts, findOpts?: FindOpts): Promise<any[]>;
+    find({ collection, search, context, dbFindOpts, findOpts }: VQuery): Promise<any[]>;
     /**
      * Find the first matching entry in the specified database based on search criteria.
      */
-    findOne(collection: string, arg: SearchOptions, context?: Context, findOpts?: FindOpts): Promise<Data>;
-    findStream(collection: string, arg: Search, context?: Context, findOpts?: FindOpts, limit?: number): AsyncGenerator<any>;
+    findOne({ collection, search, context, findOpts }: VQuery): Promise<Data>;
+    findStream({ collection, search, context, findOpts, limit }: VQuery): AsyncGenerator<any>;
     /**
      * Update entries in the specified database based on search criteria and an updater function or object.
      */
-    update(collection: string, arg: Search, updater: Updater, context?: {}): Promise<boolean>;
+    update({ collection, search, updater, context }: VQuery): Promise<boolean>;
     /**
      * Update the first matching entry in the specified database based on search criteria and an updater function or object.
      */
-    updateOne(collection: string, arg: Search, updater: Updater, context?: Context): Promise<boolean>;
+    updateOne({ collection, search, updater, context }: VQuery): Promise<boolean>;
     /**
      * Remove entries from the specified database based on search criteria.
      */
-    remove(collection: string, arg: Search, context?: Context): Promise<boolean>;
+    remove({ collection, search, context }: VQuery): Promise<boolean>;
     /**
      * Remove the first matching entry from the specified database based on search criteria.
      */
-    removeOne(collection: string, arg: Search, context?: Context): Promise<boolean>;
+    removeOne({ collection, search, context }: VQuery): Promise<boolean>;
     /**
      * Removes a database collection from the file system.
      */
-    removeCollection(collection: string): Promise<void>;
+    removeCollection({ collection }: {
+        collection: any;
+    }): Promise<boolean>;
     /**
      * Apply a series of transactions to a database collection.
      */
-    transaction(collection: string, transactions: Transaction[]): Promise<void>;
+    transaction({ collection, transaction }: VQuery): Promise<boolean>;
 }
 export default dbActionC;

package/dist/actions/action.js

@@ -1,11 +1,11 @@
-import { promises } from "fs";
-import { existsSync, mkdirSync, statSync } from "fs";
+import { existsSync, mkdirSync, promises, statSync } from "fs";
+import dbActionBase from "../base/actions.js";
 import gen from "../helpers/gen.js";
 /**
  * A class representing database actions on files.
  * @class
  */
-class dbActionC {
+class dbActionC extends dbActionBase {
     folder;
     options;
     fileCpu;
@@ -16,6 +16,7 @@ class dbActionC {
      * @param options - The options object.
      */
     constructor(folder, options, fileCpu) {
+        super();
         this.folder = folder;
         this.options = {
             maxFileSize: 2 * 1024 * 1024, //2 MB
@@ -45,16 +46,17 @@ class dbActionC {
     /**
      * Check and create the specified collection if it doesn't exist.
      */
-    async checkCollection(collection) {
+    async checkCollection({ collection }) {
         if (await this.issetCollection(collection))
             return;
         const cpath = this._getCollectionPath(collection);
         await promises.mkdir(cpath, { recursive: true });
+        return true;
     }
     /**
      * Check if a collection exists.
      */
-    async issetCollection(collection) {
+    async issetCollection({ collection }) {
         const path = this._getCollectionPath(collection);
         try {
             await promises.access(path);
@@ -67,44 +69,44 @@ class dbActionC {
     /**
      * Add a new entry to the specified database.
      */
-    async add(collection, arg, id_gen = true) {
-        await this.checkCollection(collection);
+    async add({ collection, data, id_gen = true }) {
+        await this.checkCollection(arguments[0]);
         const cpath = this._getCollectionPath(collection);
         const file = cpath + await getLastFile(cpath, this.options.maxFileSize);
         if (id_gen)
-            arg._id = arg._id || gen();
-        await this.fileCpu.add(file, arg);
-        return arg;
+            data._id = data._id || gen();
+        await this.fileCpu.add(file, data);
+        return data;
     }
     /**
      * Find entries in the specified database based on search criteria.
      */
-    async find(collection, arg, context = {}, options = {}, findOpts = {}) {
-        options.reverse = options.reverse || false;
-        options.max = options.max || -1;
-        await this.checkCollection(collection);
+    async find({ collection, search, context = {}, dbFindOpts = {}, findOpts = {} }) {
+        dbFindOpts.reverse = dbFindOpts.reverse || false;
+        dbFindOpts.max = dbFindOpts.max || -1;
+        await this.checkCollection(arguments[0]);
         const cpath = this._getCollectionPath(collection);
         const files = await getSortedFiles(cpath);
-        if (options.reverse)
+        if (dbFindOpts.reverse)
             files.reverse();
         let datas = [];
         let totalEntries = 0;
         for (let f of files) {
-            let data = await this.fileCpu.find(cpath + f, arg, context, findOpts);
-            if (options.reverse)
+            let data = await this.fileCpu.find(cpath + f, search, context, findOpts);
+            if (dbFindOpts.reverse)
                 data.reverse();
-            if (options.max !== -1) {
-                if (totalEntries + data.length > options.max) {
-                    let remainingEntries = options.max - totalEntries;
+            if (dbFindOpts.max !== -1) {
+                if (totalEntries + data.length > dbFindOpts.max) {
+                    let remainingEntries = dbFindOpts.max - totalEntries;
                     data = data.slice(0, remainingEntries);
-                    totalEntries = options.max;
+                    totalEntries = dbFindOpts.max;
                 }
                 else {
                     totalEntries += data.length;
                 }
             }
             datas = datas.concat(data);
-            if (options.max !== -1 && totalEntries >= options.max)
+            if (dbFindOpts.max !== -1 && totalEntries >= dbFindOpts.max)
                 break;
         }
         return datas;
@@ -112,24 +114,24 @@ class dbActionC {
     /**
      * Find the first matching entry in the specified database based on search criteria.
      */
-    async findOne(collection, arg, context = {}, findOpts = {}) {
-        await this.checkCollection(collection);
+    async findOne({ collection, search, context = {}, findOpts = {} }) {
+        await this.checkCollection(arguments[0]);
         const cpath = this._getCollectionPath(collection);
         const files = await getSortedFiles(cpath);
         for (let f of files) {
-            let data = await this.fileCpu.findOne(cpath + f, arg, context, findOpts);
+            let data = await this.fileCpu.findOne(cpath + f, search, context, findOpts);
             if (data)
                 return data;
         }
         return null;
     }
-    async *findStream(collection, arg, context = {}, findOpts = {}, limit = -1) {
-        await this.checkCollection(collection);
+    async *findStream({ collection, search, context = {}, findOpts = {}, limit = -1 }) {
+        await this.checkCollection(arguments[0]);
         const cpath = this._getCollectionPath(collection);
         const files = await getSortedFiles(cpath);
         let count = 0;
         for (let f of files) {
-            for await (const data of this.fileCpu.findStream(cpath + f, arg, context, findOpts, limit)) {
+            for await (const data of this.fileCpu.findStream(cpath + f, search, context, findOpts, limit)) {
                 yield data;
                 count++;
                 if (limit !== -1 && count >= limit) {
@@ -141,53 +143,55 @@ class dbActionC {
     /**
      * Update entries in the specified database based on search criteria and an updater function or object.
      */
-    async update(collection, arg, updater, context = {}) {
-        await this.checkCollection(collection);
-        return await operationUpdater(this._getCollectionPath(collection), this.fileCpu.update.bind(this.fileCpu), false, arg, updater, context);
+    async update({ collection, search, updater, context = {} }) {
+        await this.checkCollection(arguments[0]);
+        return await operationUpdater(this._getCollectionPath(collection), this.fileCpu.update.bind(this.fileCpu), false, search, updater, context);
     }
     /**
      * Update the first matching entry in the specified database based on search criteria and an updater function or object.
      */
-    async updateOne(collection, arg, updater, context = {}) {
-        await this.checkCollection(collection);
-        return await operationUpdater(this._getCollectionPath(collection), this.fileCpu.update.bind(this.fileCpu), true, arg, updater, context);
+    async updateOne({ collection, search, updater, context = {} }) {
+        await this.checkCollection(arguments[0]);
+        return await operationUpdater(this._getCollectionPath(collection), this.fileCpu.update.bind(this.fileCpu), true, search, updater, context);
     }
     /**
      * Remove entries from the specified database based on search criteria.
      */
-    async remove(collection, arg, context = {}) {
-        await this.checkCollection(collection);
-        return await operationUpdater(this._getCollectionPath(collection), this.fileCpu.remove.bind(this.fileCpu), false, arg, context);
+    async remove({ collection, search, context = {} }) {
+        await this.checkCollection(arguments[0]);
+        return await operationUpdater(this._getCollectionPath(collection), this.fileCpu.remove.bind(this.fileCpu), false, search, context);
     }
     /**
      * Remove the first matching entry from the specified database based on search criteria.
      */
-    async removeOne(collection, arg, context = {}) {
-        await this.checkCollection(collection);
-        return await operationUpdater(this._getCollectionPath(collection), this.fileCpu.remove.bind(this.fileCpu), true, arg, context);
+    async removeOne({ collection, search, context = {} }) {
+        await this.checkCollection(arguments[0]);
+        return await operationUpdater(this._getCollectionPath(collection), this.fileCpu.remove.bind(this.fileCpu), true, search, context);
     }
     /**
      * Removes a database collection from the file system.
      */
-    async removeCollection(collection) {
+    async removeCollection({ collection }) {
         await promises.rm(this.folder + "/" + collection, { recursive: true, force: true });
+        return true;
     }
     /**
      * Apply a series of transactions to a database collection.
      */
-    async transaction(collection, transactions) {
-        await this.checkCollection(collection);
+    async transaction({ collection, transaction }) {
+        await this.checkCollection(arguments[0]);
         const files = await getSortedFiles(this._getCollectionPath(collection));
         if (files.length == 0) {
             await promises.writeFile(this._getCollectionPath(collection) + "1.db", "");
             files.push("1.db");
         }
         for (const file of files) {
-            await this.fileCpu.transactions(this._getCollectionPath(collection) + file, transactions);
+            await this.fileCpu.transactions(this._getCollectionPath(collection) + file, transaction);
         }
         console.log("Transactions applied successfully.");
         console.log("Files:", files);
-        console.log("Transactions:", transactions);
+        console.log("Transactions:", transaction);
+        return true;
     }
 }
 /**

package/dist/actions/memory.d.ts

@@ -1,13 +1,10 @@
+import dbActionBase from "../base/actions.js";
 import Valthera from "../db/valthera.js";
-import { Arg, Search, Updater } from "../types/arg.js";
 import Data from "../types/data.js";
 import FileCpu from "../types/fileCpu.js";
-import { DbFindOpts, DbOpts, FindOpts } from "../types/options.js";
-import { SearchOptions } from "../types/searchOpts.js";
-import { Transaction } from "../types/transactions.js";
-import { Context } from "../types/types.js";
-import dbActionC from "./action.js";
-export declare class MemoryAction implements dbActionC {
+import { DbOpts } from "../types/options.js";
+import { VQuery } from "../types/query.js";
+export declare class MemoryAction extends dbActionBase {
     folder: string;
     options: DbOpts;
     fileCpu: FileCpu;
@@ -29,52 +26,43 @@ export declare class MemoryAction implements dbActionC {
     /**
      * Check and create the specified collection if it doesn't exist.
      */
-    checkCollection(collection: string): Promise<void>;
+    checkCollection({ collection }: VQuery): Promise<boolean>;
     /**
      * Check if a collection exists.
      */
-    issetCollection(collection: string): Promise<boolean>;
+    issetCollection({ collection }: VQuery): Promise<boolean>;
     /**
      * Add a new entry to the specified database.
      */
-    add(collection: string, arg: Arg, id_gen?: boolean): Promise<Arg>;
+    add({ collection, data, id_gen }: VQuery): Promise<import("../types/arg.js").Arg>;
     /**
      * Find entries in the specified database based on search criteria.
      */
-    find(collection: string, arg: Search, context?: Context, options?: DbFindOpts, findOpts?: FindOpts): Promise<Data[]>;
+    find({ collection, search, context, dbFindOpts, findOpts }: VQuery): Promise<Data[]>;
     /**
      * Find the first matching entry in the specified database based on search criteria.
      */
-    findOne(collection: string, arg: SearchOptions, context?: Context, findOpts?: FindOpts): Promise<Data>;
-    /**
-     * Find entries in the specified database based on search criteria and return a stream of results.
-     */
-    findStream(collection: string, arg: Search, context?: Context, findOpts?: FindOpts, limit?: number): AsyncGenerator<any>;
+    findOne({ collection, search, context, findOpts }: VQuery): Promise<Data>;
     /**
      * Update entries in the specified database based on search criteria and an updater function or object.
      */
-    update(collection: string, arg: Search, updater: Updater, context?: {}): Promise<boolean>;
+    update({ collection, search, updater, context }: VQuery): Promise<boolean>;
     /**
      * Update the first matching entry in the specified database based on search criteria and an updater function or object.
      */
-    updateOne(collection: string, arg: Search, updater: Updater, context?: Context): Promise<boolean>;
+    updateOne({ collection, search, updater, context }: VQuery): Promise<boolean>;
     /**
      * Remove entries from the specified database based on search criteria.
      */
-    remove(collection: string, arg: Search, context?: Context): Promise<boolean>;
+    remove({ collection, search, context }: VQuery): Promise<boolean>;
     /**
      * Remove the first matching entry from the specified database based on search criteria.
      */
-    removeOne(collection: string, arg: Search, context?: Context): Promise<boolean>;
+    removeOne({ collection, search, context }: VQuery): Promise<boolean>;
     /**
      * Removes a database collection from the file system.
      */
-    removeCollection(collection: string): Promise<void>;
-    /**
-     * Executes a list of transactions on the specified database collection.
-     * @throws Error - Method not supported in memory.
-     */
-    transaction(collection: string, transactions: Transaction[]): Promise<void>;
+    removeCollection({ collection }: VQuery): Promise<boolean>;
 }
 export default class ValtheraMemory extends Valthera {
     constructor(...args: any[]);

package/dist/actions/memory.js

@@ -1,7 +1,8 @@
+import dbActionBase from "../base/actions.js";
 import Valthera from "../db/valthera.js";
 import CustomFileCpu from "../file/customFileCpu.js";
 import genId from "../helpers/gen.js";
-export class MemoryAction {
+export class MemoryAction extends dbActionBase {
     folder;
     options;
     fileCpu;
@@ -13,6 +14,7 @@ export class MemoryAction {
      * @param options - The options object.
      */
     constructor() {
+        super();
         this.memory = new Map();
         this.fileCpu = new CustomFileCpu(this._readMemory.bind(this), this._writeMemory.bind(this));
     }
@@ -37,95 +39,84 @@ export class MemoryAction {
     /**
      * Check and create the specified collection if it doesn't exist.
      */
-    async checkCollection(collection) {
+    async checkCollection({ collection }) {
         if (this.issetCollection(collection))
             return;
         this.memory.set(collection, []);
+        return true;
     }
     /**
      * Check if a collection exists.
      */
-    async issetCollection(collection) {
+    async issetCollection({ collection }) {
         return this.memory.has(collection);
     }
     /**
      * Add a new entry to the specified database.
      */
-    async add(collection, arg, id_gen = true) {
-        await this.checkCollection(collection);
+    async add({ collection, data, id_gen = true }) {
+        await this.checkCollection(arguments[0]);
         if (id_gen)
-            arg._id = arg._id || genId();
-        await this.fileCpu.add(collection, arg);
-        return arg;
+            data._id = data._id || genId();
+        await this.fileCpu.add(collection, data);
+        return data;
     }
     /**
      * Find entries in the specified database based on search criteria.
      */
-    async find(collection, arg, context = {}, options = {}, findOpts = {}) {
-        options.reverse = options.reverse || false;
-        options.max = options.max || -1;
-        await this.checkCollection(collection);
-        let data = await this.fileCpu.find(collection, arg, context, findOpts);
-        if (options.reverse)
+    async find({ collection, search, context = {}, dbFindOpts = {}, findOpts = {} }) {
+        dbFindOpts.reverse = dbFindOpts.reverse || false;
+        dbFindOpts.max = dbFindOpts.max || -1;
+        await this.checkCollection(arguments[0]);
+        let data = await this.fileCpu.find(collection, search, context, findOpts);
+        if (dbFindOpts.reverse)
             data.reverse();
-        if (options.max !== -1 && data.length > options.max)
-            data = data.slice(0, options.max);
+        if (dbFindOpts.max !== -1 && data.length > dbFindOpts.max)
+            data = data.slice(0, dbFindOpts.max);
         return data;
     }
     /**
      * Find the first matching entry in the specified database based on search criteria.
      */
-    async findOne(collection, arg, context = {}, findOpts = {}) {
-        await this.checkCollection(collection);
-        let data = await this.fileCpu.findOne(collection, arg, context, findOpts);
+    async findOne({ collection, search, context = {}, findOpts = {} }) {
+        await this.checkCollection(arguments[0]);
+        let data = await this.fileCpu.findOne(collection, search, context, findOpts);
         return data || null;
     }
-    /**
-     * Find entries in the specified database based on search criteria and return a stream of results.
-     */
-    async *findStream(collection, arg, context, findOpts, limit) {
-        throw new Error("Method not implemented.");
-    }
     /**
      * Update entries in the specified database based on search criteria and an updater function or object.
      */
-    async update(collection, arg, updater, context = {}) {
-        await this.checkCollection(collection);
-        return await this.fileCpu.update(collection, false, arg, updater, context);
+    async update({ collection, search, updater, context = {} }) {
+        await this.checkCollection(arguments[0]);
+        return await this.fileCpu.update(collection, false, search, updater, context);
     }
     /**
      * Update the first matching entry in the specified database based on search criteria and an updater function or object.
      */
-    async updateOne(collection, arg, updater, context = {}) {
-        await this.checkCollection(collection);
-        return await this.fileCpu.update(collection, true, arg, updater, context);
+    async updateOne({ collection, search, updater, context = {} }) {
+        await this.checkCollection(arguments[0]);
+        return await this.fileCpu.update(collection, true, search, updater, context);
     }
     /**
      * Remove entries from the specified database based on search criteria.
      */
-    async remove(collection, arg, context = {}) {
-        await this.checkCollection(collection);
-        return await this.fileCpu.remove(collection, false, arg, context);
+    async remove({ collection, search, context = {} }) {
+        await this.checkCollection(arguments[0]);
+        return await this.fileCpu.remove(collection, false, search, context);
     }
     /**
      * Remove the first matching entry from the specified database based on search criteria.
      */
-    async removeOne(collection, arg, context = {}) {
-        await this.checkCollection(collection);
-        return await this.fileCpu.remove(collection, true, arg, context);
+    async removeOne({ collection, search, context = {} }) {
+        await this.checkCollection(arguments[0]);
+        return await this.fileCpu.remove(collection, true, search, context);
     }
     /**
      * Removes a database collection from the file system.
      */
-    async removeCollection(collection) {
+    async removeCollection({ collection }) {
         this.memory.delete(collection);
-    }
-    /**
-     * Executes a list of transactions on the specified database collection.
-     * @throws Error - Method not supported in memory.
-     */
-    transaction(collection, transactions) {
-        throw new Error("Method not supported in memory.");
+        return true;
     }
 }
 export default class ValtheraMemory extends Valthera {

package/dist/base/actions.d.ts

@@ -0,0 +1,19 @@
+import Data from "../types/data.js";
+import { VQuery } from "../types/query.js";
+declare class dbActionBase {
+    getCollections(): Promise<string[]>;
+    checkCollection(config: VQuery): Promise<boolean>;
+    issetCollection(config: VQuery): Promise<boolean>;
+    add(config: VQuery): Promise<Data>;
+    find(config: VQuery): Promise<Data[]>;
+    findOne(config: VQuery): Promise<Data | null>;
+    findStream(config: VQuery): AsyncGenerator<any>;
+    update(config: VQuery): Promise<boolean>;
+    updateOne(config: VQuery): Promise<boolean>;
+    remove(config: VQuery): Promise<boolean>;
+    removeOne(config: VQuery): Promise<boolean>;
+    removeCollection(config: VQuery): Promise<boolean>;
+    transaction(config: VQuery): Promise<boolean>;
+    updateOneOrAdd(config: VQuery): Promise<boolean>;
+}
+export default dbActionBase;

package/dist/base/actions.js

@@ -0,0 +1,64 @@
+import { setDataUsingUpdateOneOrAdd } from "../helpers/updateOneOrAdd.js";
+class dbActionBase {
+    async getCollections() {
+        throw new Error("Not implemented");
+        return [];
+    }
+    async checkCollection(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async issetCollection(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async add(config) {
+        throw new Error("Not implemented");
+        return {};
+    }
+    async find(config) {
+        throw new Error("Not implemented");
+        return [];
+    }
+    async findOne(config) {
+        throw new Error("Not implemented");
+        return {};
+    }
+    async *findStream(config) {
+        throw new Error("Not implemented");
+        return {};
+    }
+    async update(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async updateOne(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async remove(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async removeOne(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async removeCollection(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async transaction(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async updateOneOrAdd(config) {
+        const res = await this.updateOne(config);
+        if (!res) {
+            setDataUsingUpdateOneOrAdd(config);
+            await this.add(config);
+        }
+        return res;
+    }
+}
+export default dbActionBase;

package/dist/base/db.d.ts

@@ -0,0 +1,23 @@
+import CollectionManager from "../helpers/CollectionManager.js";
+import Data from "../types/data.js";
+import { VQuery } from "../types/query.js";
+import { ValtheraCompatibleInternal } from "../types/valthera.js";
+declare class ValtheraBase implements ValtheraCompatibleInternal {
+    version: string;
+    c(config: VQuery): CollectionManager;
+    getCollections(): Promise<any[]>;
+    checkCollection(config: VQuery): Promise<boolean>;
+    issetCollection(config: VQuery): Promise<boolean>;
+    add<T = Data>(config: VQuery): Promise<T>;
+    find<T = Data>(config: VQuery): Promise<T[]>;
+    findOne<T = Data>(config: VQuery): Promise<T>;
+    findStream<T = Data>(config: VQuery): Promise<AsyncGenerator<T, any, any>>;
+    remove(config: VQuery): Promise<boolean>;
+    removeCollection(config: VQuery): Promise<boolean>;
+    removeOne(config: VQuery): Promise<boolean>;
+    update(config: VQuery): Promise<boolean>;
+    updateOne(config: VQuery): Promise<boolean>;
+    updateOneOrAdd(config: VQuery): Promise<boolean>;
+    transaction(config: VQuery): Promise<boolean>;
+}
+export default ValtheraBase;

package/dist/base/db.js

@@ -0,0 +1,64 @@
+import { version } from "../version.js";
+class ValtheraBase {
+    version = version;
+    c(config) {
+        throw new Error("Not implemented");
+    }
+    async getCollections() {
+        throw new Error("Not implemented");
+        return [];
+    }
+    async checkCollection(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async issetCollection(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async add(config) {
+        throw new Error("Not implemented");
+        return {};
+    }
+    async find(config) {
+        throw new Error("Not implemented");
+        return [];
+    }
+    async findOne(config) {
+        throw new Error("Not implemented");
+        return {};
+    }
+    async findStream(config) {
+        throw new Error("Not implemented");
+        return {};
+    }
+    async remove(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async removeCollection(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async removeOne(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async update(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async updateOne(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async updateOneOrAdd(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async transaction(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+}
+export default ValtheraBase;

package/dist/client/valthera.d.ts

@@ -13,6 +13,7 @@ import { ValtheraCompatible } from "../types/valthera.js";
  */
 declare class ValtheraRemote implements ValtheraCompatible {
     remote: Remote;
+    version: string;
     constructor(remote: Remote | string);
     /**
      * Make a request to the remote database.

package/dist/client/valthera.js

@@ -1,6 +1,7 @@
 import ky from "ky";
 import CollectionManager from "../helpers/CollectionManager.js";
 import serializeFunctions from "./function.js";
+import { version } from "../version.js";
 /**
  * Represents a database management class for performing CRUD operations.
  * Uses a remote database.
@@ -8,6 +9,7 @@ import serializeFunctions from "./function.js";
  */
 class ValtheraRemote {
     remote;
+    version = version;
     constructor(remote) {
         if (typeof remote === "string") {
             const urlObj = new URL(remote);

package/dist/db/valthera.d.ts

@@ -17,6 +17,7 @@ declare class Valthera implements ValtheraCompatible {
     dbAction: dbActionC;
     executor: executorC;
     emiter: EventEmitter;
+    version: string;
     constructor(folder: string, options?: DbOpts, fileCpu?: FileCpu);
     private execute;
     /**
@@ -42,7 +43,7 @@ declare class Valthera implements ValtheraCompatible {
     /**
      * Find data in a database.
      */
-    find<T = Data>(collection: string, search: Search, context?: Context, options?: DbFindOpts, findOpts?: FindOpts): Promise<T[]>;
+    find<T = Data>(collection: string, search: Search, context?: Context, dbFindOpts?: DbFindOpts, findOpts?: FindOpts): Promise<T[]>;
     /**
      * Find one data entry in a database.
      */

package/dist/db/valthera.js

@@ -3,6 +3,7 @@ import executorC from "../helpers/executor.js";
 import CollectionManager from "../helpers/CollectionManager.js";
 import vFileCpu from "../file/index.js";
 import { EventEmitter } from "events";
+import { version } from "../version.js";
 /**
  * Represents a database management class for performing CRUD operations.
  * @class
@@ -11,6 +12,7 @@ class Valthera {
     dbAction;
     executor;
     emiter;
+    version = version;
     constructor(folder, options = {}, fileCpu) {
         if (!fileCpu)
             fileCpu = vFileCpu;
@@ -42,102 +44,79 @@ class Valthera {
      * Check and create the specified collection if it doesn't exist.
      */
     async checkCollection(collection) {
-        return await this.execute("checkCollection", collection);
+        return await this.execute("checkCollection", { collection });
     }
     /**
      * Check if a collection exists.
      */
     async issetCollection(collection) {
-        return await this.execute("issetCollection", collection);
+        return await this.execute("issetCollection", { collection });
     }
     /**
      * Add data to a database.
      */
     async add(collection, data, id_gen = true) {
-        return await this.execute("add", collection, data, id_gen);
+        return await this.execute("add", { collection, data, id_gen });
     }
     /**
      * Find data in a database.
      */
-    async find(collection, search, context = {}, options = {}, findOpts = {}) {
-        return await this.execute("find", collection, search, context, options, findOpts);
+    async find(collection, search, context = {}, dbFindOpts = {}, findOpts = {}) {
+        return await this.execute("find", { collection, search, context, dbFindOpts, findOpts });
     }
     /**
      * Find one data entry in a database.
      */
     async findOne(collection, search, context = {}, findOpts = {}) {
-        return await this.execute("findOne", collection, search, context, findOpts);
+        return await this.execute("findOne", { collection, search, context, findOpts });
     }
     /**
      * Find data in a database as a stream.
      */
     async findStream(collection, search, context = {}, findOpts = {}, limit = -1) {
-        return await this.execute("findStream", collection, search, context, findOpts, limit);
+        return await this.execute("findStream", { collection, search, context, findOpts, limit });
     }
     /**
      * Update data in a database.
      */
     async update(collection, search, updater, context = {}) {
-        return await this.execute("update", collection, search, updater, context);
+        return await this.execute("update", { collection, search, updater, context });
     }
     /**
      * Update one data entry in a database.
      */
     async updateOne(collection, search, updater, context = {}) {
-        return await this.execute("updateOne", collection, search, updater, context);
+        return await this.execute("updateOne", { collection, search, updater, context });
     }
     /**
      * Remove data from a database.
      */
     async remove(collection, search, context = {}) {
-        return await this.execute("remove", collection, search, context);
+        return await this.execute("remove", { collection, search, context });
     }
     /**
      * Remove one data entry from a database.
      */
     async removeOne(collection, search, context = {}) {
-        return await this.execute("removeOne", collection, search, context);
+        return await this.execute("removeOne", { collection, search, context });
     }
     /**
      * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
      */
     async updateOneOrAdd(collection, search, updater, add_arg = {}, context = {}, id_gen = true) {
-        const res = await this.updateOne(collection, search, updater, context);
-        if (!res) {
-            const assignData = [];
-            function assignDataPush(data) {
-                if (typeof data !== "object" || Array.isArray(data))
-                    return;
-                const obj = {};
-                for (const key of Object.keys(data)) {
-                    if (key.startsWith("$")) {
-                        Object.keys(data[key]).forEach((k) => {
-                            obj[k] = data[key][k];
-                        });
-                    }
-                    else
-                        obj[key] = data[key];
-                }
-                assignData.push(obj);
-            }
-            assignDataPush(search);
-            assignDataPush(updater);
-            assignDataPush(add_arg);
-            await this.add(collection, Object.assign({}, ...assignData), id_gen);
-        }
-        return res;
+        return await this.execute("updateOneOrAdd", { collection, search, updater, add_arg, context, id_gen });
     }
     /**
      * Removes a database collection from the file system.
      */
     async removeCollection(collection) {
-        return await this.execute("removeCollection", collection);
+        return await this.execute("removeCollection", { collection });
     }
     /**
      * Execute a transaction.
      */
     async transaction(collection, transaction) {
-        return await this.execute("transaction", collection, transaction);
+        return await this.execute("transaction", { collection, transaction });
     }
 }
 export default Valthera;

package/dist/file/utils.d.ts

@@ -2,7 +2,7 @@
  * Repairs a file path by replacing double slashes
  */
 export declare function pathRepair(path: string): string;
-/**
- * Creates a Readline interface for reading large files with a specified high water mark.
- */
-export declare function createRL(file: string): import("readline").Interface;
+export interface LineReader extends AsyncIterable<string> {
+    close: () => void;
+}
+export declare function createRL(file: string): LineReader;

package/dist/file/utils.js

@@ -1,19 +1,84 @@
 import { createReadStream } from "fs";
-import { createInterface } from "readline";
 /**
  * Repairs a file path by replacing double slashes
  */
 export function pathRepair(path) {
     return path.replaceAll("//", "/");
 }
-/**
- * Creates a Readline interface for reading large files with a specified high water mark.
- */
 export function createRL(file) {
-    const read_stream = createReadStream(file, { highWaterMark: 10 * 1024 * 1024 }); //10MB
-    const rl = createInterface({
-        input: read_stream,
-        crlfDelay: Infinity
+    const stream = createReadStream(file, { highWaterMark: 64 * 1024 });
+    let buffer = "";
+    let done = false;
+    let error = null;
+    const lines = [];
+    let waiting = null;
+    stream.on("data", (chunk) => {
+        buffer += chunk.toString("utf8");
+        let index;
+        while ((index = buffer.search(/\r?\n/)) >= 0) {
+            const line = buffer.slice(0, index);
+            lines.push(line);
+            buffer = buffer.slice(index + (buffer[index] === "\r" && buffer[index + 1] === "\n" ? 2 : 1));
+        }
+        feed();
+    });
+    stream.on("end", () => {
+        if (buffer.length > 0) {
+            lines.push(buffer);
+            buffer = "";
+        }
+        done = true;
+        feed();
+    });
+    stream.on("error", (err) => {
+        error = err;
+        done = true;
+        feed();
     });
+    const feed = () => {
+        if (waiting) {
+            if (error) {
+                waiting(Promise.reject(error));
+            }
+            else if (lines.length > 0) {
+                waiting({ value: lines.shift(), done: false });
+            }
+            else if (done) {
+                waiting({ value: undefined, done: true });
+            }
+            else {
+                return;
+            }
+            waiting = null;
+        }
+    };
+    const iterator = {
+        next() {
+            if (error)
+                return Promise.reject(error);
+            if (lines.length > 0)
+                return Promise.resolve({ value: lines.shift(), done: false });
+            if (done)
+                return Promise.resolve({ value: undefined, done: true });
+            return new Promise(res => {
+                waiting = res;
+            });
+        },
+        return() {
+            rl.close();
+            return Promise.resolve({ value: undefined, done: true });
+        }
+    };
+    const rl = {
+        [Symbol.asyncIterator]() {
+            return iterator;
+        },
+        close() {
+            if (!done) {
+                done = true;
+                stream.destroy();
+            }
+        }
+    };
     return rl;
 }

package/dist/helpers/updateOneOrAdd.d.ts

@@ -0,0 +1,2 @@
+import { VQuery } from "../types/query.js";
+export declare function setDataUsingUpdateOneOrAdd(query: VQuery): void;

package/dist/helpers/updateOneOrAdd.js

@@ -0,0 +1,18 @@
+function assignDataPush(data) {
+    if (typeof data !== "object" || Array.isArray(data))
+        return;
+    const obj = {};
+    for (const key of Object.keys(data)) {
+        if (key.startsWith("$")) {
+            Object.keys(data[key]).forEach((k) => {
+                obj[k] = data[key][k];
+            });
+        }
+        else
+            obj[key] = data[key];
+    }
+    return obj;
+}
+export function setDataUsingUpdateOneOrAdd(query) {
+    query.data = Object.assign({}, assignDataPush(query.search), assignDataPush(query.updater), assignDataPush(query.add_arg));
+}

package/dist/index.d.ts

@@ -9,17 +9,8 @@ import ValtheraMemory, { createMemoryValthera } from "./actions/memory.js";
 import { ValtheraAutoCreate } from "./helpers/autoCreate.js";
 import { RelationTypes } from "./types/relation.js";
 import { ValtheraCompatible } from "./types/valthera.js";
+import { ValtheraTypes } from "./types/export.js";
 export { Valthera, Graph, ValtheraRemote, GraphRemote, Relation, genId, CustomFileCpu, ValtheraMemory, createMemoryValthera, ValtheraAutoCreate, };
 type GraphCompatible = Graph | GraphRemote;
-export type { ValtheraCompatible, RelationTypes, GraphCompatible, };
+export type { ValtheraCompatible, RelationTypes, GraphCompatible, ValtheraTypes };
 export type Id = import("./types/Id.js").Id;
-export declare namespace ValtheraTypes {
-    type Arg = import("./types/arg.js").Arg;
-    type Search = import("./types/arg.js").Search;
-    type Updater = import("./types/arg.js").Updater;
-    type DbFindOpts = import("./types/options.js").DbFindOpts;
-    type FindOpts = import("./types/options.js").FindOpts;
-    type DbOpts = import("./types/options.js").DbOpts;
-    type Data = import("./types/data.js").Data;
-    type SearchOptions = import("./types/searchOpts.js").SearchOptions;
-}

package/dist/types/export.d.ts

@@ -0,0 +1,11 @@
+export declare namespace ValtheraTypes {
+    type Arg = import("./arg.js").Arg;
+    type Search = import("./arg.js").Search;
+    type Updater = import("./arg.js").Updater;
+    type DbFindOpts = import("./options.js").DbFindOpts;
+    type FindOpts = import("./options.js").FindOpts;
+    type DbOpts = import("./options.js").DbOpts;
+    type Data = import("./data.js").Data;
+    type SearchOptions = import("./searchOpts.js").SearchOptions;
+    type Id = import("./Id.js").Id;
+}

package/dist/types/export.js

@@ -0,0 +1 @@
+export {};

package/dist/types/query.d.ts

@@ -0,0 +1,17 @@
+import { Context } from "./types.js";
+import { Arg, Search, Updater } from "./arg.js";
+import { DbFindOpts, FindOpts } from "./options.js";
+import { Transaction } from "./transactions.js";
+export interface VQuery {
+    collection?: string;
+    search?: Search;
+    context?: Context;
+    dbFindOpts?: DbFindOpts;
+    findOpts?: FindOpts;
+    data?: Arg;
+    id_gen?: boolean;
+    limit?: number;
+    add_arg?: Arg;
+    updater?: Updater;
+    transaction?: Transaction[];
+}

package/dist/types/query.js

@@ -0,0 +1 @@
+export {};

package/dist/types/valthera.d.ts

@@ -2,6 +2,7 @@ import CollectionManager from "../helpers/CollectionManager.js";
 import { Arg, Search, Updater } from "./arg.js";
 import Data from "./data.js";
 import { DbFindOpts, FindOpts } from "./options.js";
+import { VQuery } from "./query.js";
 import { Transaction } from "./transactions.js";
 import { Context } from "./types.js";
 export interface ValtheraCompatible {
@@ -21,3 +22,20 @@ export interface ValtheraCompatible {
     transaction(collection: string, transaction: Transaction[]): Promise<boolean>;
     updateOneOrAdd(collection: string, search: Search, updater: Updater, add_arg?: Arg, context?: Context, id_gen?: boolean): Promise<boolean>;
 }
+export interface ValtheraCompatibleInternal {
+    c(config: VQuery): CollectionManager;
+    getCollections(): Promise<string[]>;
+    checkCollection(config: VQuery): Promise<boolean>;
+    issetCollection(config: VQuery): Promise<boolean>;
+    add<T = Data>(config: VQuery): Promise<T>;
+    find<T = Data>(config: VQuery): Promise<T[]>;
+    findOne<T = Data>(config: VQuery): Promise<T | null>;
+    findStream<T = Data>(config: VQuery): Promise<AsyncGenerator<T>>;
+    update(config: VQuery): Promise<boolean>;
+    updateOne(config: VQuery): Promise<boolean>;
+    remove(config: VQuery): Promise<boolean>;
+    removeOne(config: VQuery): Promise<boolean>;
+    removeCollection(config: VQuery): Promise<boolean>;
+    transaction(config: VQuery): Promise<boolean>;
+    updateOneOrAdd(config: VQuery): Promise<boolean>;
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "0.0.1";

package/dist/version.js

@@ -0,0 +1 @@
+export const version = "0.8.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/db",
-  "version": "0.7.6",
+  "version": "0.8.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "description": "A simple file-based database management system with support for CRUD operations, custom queries, and graph structures.",
@@ -21,8 +21,7 @@
   "type": "module",
   "dependencies": {
     "json5": "^2.2.3",
-    "ky": "^1.7.4",
-    "readline": "^1.3.0"
+    "ky": "^1.7.4"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",