@wxn0brp/db 0.4.0 → 0.4.2

package/dist/action.d.ts

@@ -4,6 +4,7 @@ import { Context } from "./types/types.js";
 import { SearchOptions } from "./types/searchOpts.js";
 import Data from "./types/data.js";
 import FileCpu from "./types/fileCpu.js";
+import { Transaction } from "./types/transactions.js";
 /**
  * A class representing database actions on files.
  * @class
@@ -64,5 +65,9 @@ declare class dbActionC {
      * Removes a database collection from the file system.
      */
     removeCollection(collection: string): Promise<void>;
+    /**
+     * Apply a series of transactions to a database collection.
+     */
+    transaction(collection: string, transactions: Transaction[]): Promise<void>;
 }
 export default dbActionC;

package/dist/action.js

@@ -156,6 +156,23 @@ class dbActionC {
     async removeCollection(collection) {
         await promises.rm(this.folder + "/" + collection, { recursive: true, force: true });
     }
+    /**
+     * Apply a series of transactions to a database collection.
+     */
+    async transaction(collection, transactions) {
+        await this.checkCollection(collection);
+        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);
+        }
+        console.log("Transactions applied successfully.");
+        console.log("Files:", files);
+        console.log("Transactions:", transactions);
+    }
 }
 /**
  * Get the last file in the specified directory.
@@ -196,9 +213,9 @@ async function operationUpdater(cpath, worker, one, ...args) {
     let update = false;
     for (const file of files) {
         const updated = await worker(cpath + file, one, ...args);
+        update = update || updated;
         if (one && updated)
             break;
-        update = update || updated;
     }
     return update;
 }

package/dist/client/database.d.ts

@@ -4,6 +4,7 @@ import { Arg, Search, Updater } from "../types/arg.js";
 import { DbFindOpts, FindOpts } from "../types/options.js";
 import { Context } from "../types/types.js";
 import Data from "../types/data.js";
+import { Transaction } from "../types/transactions.js";
 /**
  * Represents a database management class for performing CRUD operations.
  * Uses a remote database.
@@ -68,5 +69,9 @@ declare class DataBaseRemote {
      * Removes a database collection from the file system.
      */
     removeCollection(name: string): Promise<boolean>;
+    /**
+     * Execute a transaction.
+     */
+    transaction(collection: string, transaction: Transaction[]): Promise<boolean>;
 }
 export default DataBaseRemote;

package/dist/client/database.js

@@ -110,5 +110,11 @@ class DataBaseRemote {
     async removeCollection(name) {
         return await this._request("removeCollection", [name]);
     }
+    /**
+     * Execute a transaction.
+     */
+    async transaction(collection, transaction) {
+        return await this._request("transaction", [collection, transaction]);
+    }
 }
 export default DataBaseRemote;

package/dist/database.d.ts

@@ -6,6 +6,8 @@ import { Arg, Search, Updater } from "./types/arg.js";
 import Data from "./types/data.js";
 import { Context } from "./types/types.js";
 import FileCpu from "./types/fileCpu.js";
+import { Transaction } from "./types/transactions.js";
+import EventEmitter from "events";
 /**
  * Represents a database management class for performing CRUD operations.
  * @class
@@ -13,7 +15,9 @@ import FileCpu from "./types/fileCpu.js";
 declare class DataBase {
     dbAction: dbActionC;
     executor: executorC;
+    emiter: EventEmitter;
     constructor(folder: string, options?: DbOpts, fileCpu?: FileCpu);
+    private execute;
     /**
      * Create a new instance of a CollectionManager class.
      */
@@ -25,7 +29,7 @@ declare class DataBase {
     /**
      * Check and create the specified collection if it doesn't exist.
      */
-    checkCollection(collection: string): Promise<void>;
+    checkCollection(collection: string): Promise<boolean>;
     /**
      * Check if a collection exists.
      */
@@ -65,6 +69,10 @@ declare class DataBase {
     /**
      * Removes a database collection from the file system.
      */
-    removeCollection(collection: string): Promise<void>;
+    removeCollection(collection: string): Promise<boolean>;
+    /**
+     * Execute a transaction.
+     */
+    transaction(collection: string, transaction: Transaction[]): Promise<boolean>;
 }
 export default DataBase;

package/dist/database.js

@@ -2,6 +2,7 @@ import dbActionC from "./action.js";
 import executorC from "./executor.js";
 import CollectionManager from "./CollectionManager.js";
 import vFileCpu from "./file/index.js";
+import EventEmitter from "events";
 /**
  * Represents a database management class for performing CRUD operations.
  * @class
@@ -9,11 +10,21 @@ import vFileCpu from "./file/index.js";
 class DataBase {
     dbAction;
     executor;
+    emiter;
     constructor(folder, options = {}, fileCpu) {
         if (!fileCpu)
             fileCpu = vFileCpu;
         this.dbAction = options.dbAction || new dbActionC(folder, options, fileCpu);
         this.executor = options.executor || new executorC();
+        this.emiter = new EventEmitter();
+    }
+    async execute(name, ...args) {
+        const result = await this.executor.addOp(this.dbAction[name].bind(this.dbAction), ...args);
+        if (this.emiter.listeners(name).length !== 0)
+            this.emiter.emit(name, args, result);
+        if (this.emiter.listeners("*").length !== 0)
+            this.emiter.emit("*", name, args, result);
+        return result;
     }
     /**
      * Create a new instance of a CollectionManager class.
@@ -25,61 +36,61 @@ class DataBase {
      * Get the names of all available databases.
      */
     async getCollections() {
-        return await this.dbAction.getCollections();
+        return await this.execute("getCollections");
     }
     /**
      * Check and create the specified collection if it doesn't exist.
      */
     async checkCollection(collection) {
-        await this.dbAction.checkCollection(collection);
+        return await this.execute("checkCollection", collection);
     }
     /**
      * Check if a collection exists.
      */
     async issetCollection(collection) {
-        return await this.dbAction.issetCollection(collection);
+        return await this.execute("issetCollection", collection);
     }
     /**
      * Add data to a database.
      */
     async add(collection, data, id_gen = true) {
-        return await this.executor.addOp(this.dbAction.add.bind(this.dbAction), 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.executor.addOp(this.dbAction.find.bind(this.dbAction), collection, search, context, options, findOpts);
+        return await this.execute("find", collection, search, context, options, findOpts);
     }
     /**
      * Find one data entry in a database.
      */
     async findOne(collection, search, context = {}, findOpts = {}) {
-        return await this.executor.addOp(this.dbAction.findOne.bind(this.dbAction), collection, search, context, findOpts);
+        return await this.execute("findOne", collection, search, context, findOpts);
     }
     /**
      * Update data in a database.
      */
     async update(collection, search, updater, context = {}) {
-        return await this.executor.addOp(this.dbAction.update.bind(this.dbAction), 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.executor.addOp(this.dbAction.updateOne.bind(this.dbAction), 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.executor.addOp(this.dbAction.remove.bind(this.dbAction), 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.executor.addOp(this.dbAction.removeOne.bind(this.dbAction), 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.
@@ -88,12 +99,24 @@ class DataBase {
         const res = await this.updateOne(collection, search, updater, context);
         if (!res) {
             const assignData = [];
-            if (typeof search === "object" && !Array.isArray(search))
-                assignData.push(search);
-            if (typeof updater === "object" && !Array.isArray(updater))
-                assignData.push(updater);
-            if (typeof add_arg === "object" && !Array.isArray(add_arg))
-                assignData.push(add_arg);
+            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;
@@ -102,7 +125,13 @@ class DataBase {
      * Removes a database collection from the file system.
      */
     async removeCollection(collection) {
-        await this.dbAction.removeCollection(collection);
+        return await this.execute("removeCollection", collection);
+    }
+    /**
+     * Execute a transaction.
+     */
+    async transaction(collection, transaction) {
+        return await this.execute("transaction", collection, transaction);
     }
 }
 export default DataBase;

package/dist/file/customFileCpu.d.ts

@@ -3,6 +3,7 @@ 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 { Transaction } from "../types/transactions.js";
 export type WriteFile = (file: string, data: any[]) => Promise<void>;
 export type ReadFile = (file: string) => Promise<any[]>;
 declare class CustomFileCpu implements FileCpu {
@@ -14,5 +15,6 @@ declare class CustomFileCpu implements FileCpu {
     findOne(file: string, arg: Search, context?: Context, findOpts?: FindOpts): Promise<any | false>;
     remove(file: string, one: boolean, arg: Search, context?: Context): Promise<boolean>;
     update(file: string, one: boolean, arg: Search, updater: Updater, context?: Context): Promise<boolean>;
+    transactions(file: string, transactions: Transaction[]): Promise<void>;
 }
 export default CustomFileCpu;

package/dist/file/customFileCpu.js

@@ -64,5 +64,8 @@ class CustomFileCpu {
         await this._writeFile(file, entries);
         return true;
     }
+    transactions(file, transactions) {
+        throw new Error("Method not implemented.");
+    }
 }
 export default CustomFileCpu;

package/dist/file/index.js

@@ -3,6 +3,7 @@ import remove from "./remove.js";
 import { find, findOne } from "./find.js";
 import { appendFileSync } from "fs";
 import { stringify } from "../format.js";
+import transactions from "./transactions.js";
 const vFileCpu = {
     add: async (file, data) => {
         const dataString = stringify(data);
@@ -11,6 +12,7 @@ const vFileCpu = {
     find,
     findOne,
     update,
-    remove
+    remove,
+    transactions
 };
 export default vFileCpu;

package/dist/file/transactions.d.ts

@@ -0,0 +1,3 @@
+import { Transaction } from "../types/transactions.js";
+declare function processTransactions(file: string, transactions: Transaction[]): Promise<void>;
+export default processTransactions;

package/dist/file/transactions.js

@@ -0,0 +1,119 @@
+import { existsSync, promises } from "fs";
+import { parse, stringify } from "../format.js";
+import genId from "../gen.js";
+import hasFieldsAdvanced from "../utils/hasFieldsAdvanced.js";
+import updateObjectAdvanced from "../utils/updateObject.js";
+import { createRL, pathRepair } from "./utils.js";
+async function processTransactions(file, transactions) {
+    file = pathRepair(file);
+    const tempFile = file + ".tmp";
+    const processedTransactions = transactions.map(t => ({
+        ...t,
+        applied: false
+    }));
+    if (existsSync(file)) {
+        await promises.copyFile(file, tempFile);
+    }
+    else {
+        await promises.writeFile(file, "");
+        await promises.writeFile(tempFile, "");
+    }
+    await promises.writeFile(file, "");
+    const rl = createRL(tempFile);
+    for await (const line of rl) {
+        const originalLine = line.trim();
+        if (!originalLine)
+            continue;
+        let data = parse(originalLine);
+        let shouldRemove = false;
+        let modified = false;
+        for (const transaction of processedTransactions) {
+            if (shouldRemove)
+                break;
+            let matches = false;
+            if (typeof transaction.search === 'function') {
+                matches = transaction.search(data, transaction.context || {}) || false;
+            }
+            else if (typeof transaction.search === 'object') {
+                matches = hasFieldsAdvanced(data, transaction.search);
+            }
+            if (!matches)
+                continue;
+            switch (transaction.type) {
+                case 'update':
+                    if (transaction.updater) {
+                        data = applyUpdater(data, transaction.updater, transaction.context || {});
+                        modified = true;
+                    }
+                    break;
+                case 'updateOne':
+                    if (!transaction.applied && transaction.updater) {
+                        data = applyUpdater(data, transaction.updater, transaction.context || {});
+                        modified = true;
+                        transaction.applied = true;
+                    }
+                    break;
+                case 'updateOneOrAdd':
+                    if (!transaction.applied && transaction.updater) {
+                        data = applyUpdater(data, transaction.updater, transaction.context || {});
+                        modified = true;
+                        transaction.applied = true;
+                    }
+                    break;
+                case 'remove':
+                    shouldRemove = true;
+                    modified = true;
+                    break;
+                case 'removeOne':
+                    if (!transaction.applied) {
+                        shouldRemove = true;
+                        modified = true;
+                        transaction.applied = true;
+                    }
+                    break;
+            }
+        }
+        if (!shouldRemove) {
+            const outputLine = modified ? await stringify(data) : originalLine;
+            await promises.appendFile(file, outputLine + "\n");
+        }
+    }
+    for (const transaction of processedTransactions) {
+        if (transaction.type === 'updateOneOrAdd' && !transaction.applied) {
+            const assignData = [];
+            if (typeof transaction.search === 'object' && !Array.isArray(transaction.search)) {
+                assignData.push(transaction.search);
+            }
+            if (transaction.updater && typeof transaction.updater === 'object' && !Array.isArray(transaction.updater)) {
+                const newData = {};
+                Object.keys(transaction.updater).filter(key => !key.startsWith('$')).forEach(key => newData[key] = transaction.updater[key]);
+                assignData.push(newData);
+            }
+            if (transaction.addArg && typeof transaction.addArg === 'object' && !Array.isArray(transaction.addArg)) {
+                assignData.push(transaction.addArg);
+            }
+            let newData = Object.assign({}, ...assignData);
+            if (transaction.updater && typeof transaction.updater === 'object' && !Array.isArray(transaction.updater)) {
+                newData = applyUpdater(newData, transaction.updater, transaction.context || {});
+            }
+            await add(file, newData, transaction.idGen !== false);
+        }
+    }
+    await promises.unlink(tempFile);
+}
+function applyUpdater(data, updater, context = {}) {
+    if (typeof updater === 'function') {
+        const result = updater(data, context);
+        return data === null ? result : (result || data);
+    }
+    if (typeof updater === 'object' && !Array.isArray(updater)) {
+        return updateObjectAdvanced(data || {}, updater);
+    }
+    return data;
+}
+async function add(file, data, idGen) {
+    if (idGen && !data._id)
+        data._id = genId();
+    await promises.appendFile(file, await stringify(data) + "\n");
+}
+export default processTransactions;

package/dist/memory.js

@@ -114,6 +114,13 @@ class MemoryAction {
     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.");
+    }
 }
 export default class ValtheraMemory extends DataBase {
     constructor(...args) {

package/dist/types/fileCpu.d.ts

@@ -1,6 +1,7 @@
 import { Search, Updater } from "./arg.js";
 import Data from "./data.js";
 import { FindOpts } from "./options.js";
+import { Transaction } from "./transactions.js";
 import { Context } from "./types.js";
 interface FileCpu {
     /**
@@ -47,5 +48,12 @@ interface FileCpu {
      * @returns A promise resolving to `true` if at least one entry was updated, otherwise `false`.
      */
     update(file: string, one: boolean, arg: Search, updater: Updater, context?: Context): Promise<boolean>;
+    /**
+     * Executes a list of transactions on the specified database collection.
+     * @param file The path to the file.
+     * @param transactions An array of transactions to execute.
+     * @returns A promise resolved when all transactions have been executed.
+     */
+    transactions(file: string, transactions: Transaction[]): Promise<void>;
 }
 export default FileCpu;

package/dist/types/transactions.d.ts

@@ -0,0 +1,10 @@
+import { Arg, Search, Updater } from "./arg.js";
+import { Context } from "./types.js";
+export interface Transaction {
+    type: 'update' | 'updateOne' | 'updateOneOrAdd' | 'remove' | 'removeOne';
+    search: Search;
+    updater?: Updater;
+    addArg?: Arg;
+    idGen?: boolean;
+    context?: Context;
+}

package/dist/types/transactions.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@wxn0brp/db",
-	"version": "0.4.0",
+	"version": "0.4.2",
 	"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.",