@wxn0brp/db 0.0.5 → 0.0.7

package/dist/esm/database.d.ts

@@ -0,0 +1,69 @@
+import dbActionC from "./action.js";
+import executorC from "./executor.js";
+import CollectionManager from "./CollectionManager.js";
+import { DbFindOpts, DbOpts, FindOpts } from "./types/options.js";
+import { Arg, Search, Updater } from "./types/arg.js";
+import Data from "./types/data.js";
+import { Context } from "./types/types.js";
+/**
+ * Represents a database management class for performing CRUD operations.
+ * @class
+ */
+declare class DataBase {
+    dbAction: dbActionC;
+    executor: executorC;
+    constructor(folder: string, options?: DbOpts);
+    /**
+     * Create a new instance of a CollectionManager class.
+     */
+    c(collection: string): CollectionManager;
+    /**
+     * Get the names of all available databases.
+     */
+    getCollections(): Promise<string[]>;
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    checkCollection(collection: string): Promise<void>;
+    /**
+     * Check if a collection exists.
+     */
+    issetCollection(collection: string): Promise<boolean>;
+    /**
+     * Add data to a database.
+     */
+    add<T = Data>(collection: string, data: Arg, id_gen?: boolean): Promise<T>;
+    /**
+     * Find data in a database.
+     */
+    find<T = Data>(collection: string, search: Search, context?: Context, options?: DbFindOpts, findOpts?: FindOpts): Promise<T[]>;
+    /**
+     * Find one data entry in a database.
+     */
+    findOne<T = Data>(collection: string, search: Search, context?: Context, findOpts?: FindOpts): Promise<T>;
+    /**
+     * Update data in a database.
+     */
+    update(collection: string, search: Search, updater: Updater, context?: {}): Promise<boolean>;
+    /**
+     * Update one data entry in a database.
+     */
+    updateOne(collection: string, search: Search, updater: Updater, context?: Context): Promise<boolean>;
+    /**
+     * Remove data from a database.
+     */
+    remove(collection: string, search: Search, context?: Context): Promise<boolean>;
+    /**
+     * Remove one data entry from a database.
+     */
+    removeOne(collection: string, search: Search, context?: Context): Promise<boolean>;
+    /**
+     * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
+     */
+    updateOneOrAdd(collection: string, search: Search, updater: Updater, add_arg?: Arg, context?: Context, id_gen?: boolean): Promise<boolean>;
+    /**
+     * Removes a database collection from the file system.
+     */
+    removeCollection(collection: string): Promise<void>;
+}
+export default DataBase;

package/dist/esm/database.js

@@ -0,0 +1,105 @@
+import dbActionC from "./action.js";
+import executorC from "./executor.js";
+import CollectionManager from "./CollectionManager.js";
+/**
+ * Represents a database management class for performing CRUD operations.
+ * @class
+ */
+class DataBase {
+    dbAction;
+    executor;
+    constructor(folder, options = {}) {
+        this.dbAction = new dbActionC(folder, options);
+        this.executor = new executorC();
+    }
+    /**
+     * Create a new instance of a CollectionManager class.
+     */
+    c(collection) {
+        return new CollectionManager(this, collection);
+    }
+    /**
+     * Get the names of all available databases.
+     */
+    async getCollections() {
+        return this.dbAction.getCollections();
+    }
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    async checkCollection(collection) {
+        this.dbAction.checkCollection(collection);
+    }
+    /**
+     * Check if a collection exists.
+     */
+    async issetCollection(collection) {
+        return this.dbAction.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);
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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);
+    }
+    /**
+     * Remove data from a database.
+     */
+    async remove(collection, search, context = {}) {
+        return await this.executor.addOp(this.dbAction.remove.bind(this.dbAction), 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);
+    }
+    /**
+     * 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 = [];
+            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);
+            await this.add(collection, Object.assign({}, ...assignData), id_gen);
+        }
+        return res;
+    }
+    /**
+     * Removes a database collection from the file system.
+     */
+    async removeCollection(collection) {
+        this.dbAction.removeCollection(collection);
+    }
+}
+export default DataBase;

package/dist/esm/executor.d.ts

@@ -0,0 +1,28 @@
+interface Task {
+    func: Function;
+    param: any[];
+    resolve: Function;
+    reject: Function;
+}
+/**
+ * A simple executor for queuing and executing asynchronous operations sequentially.
+ * @class
+ */
+declare class executorC {
+    quote: Task[];
+    isExecuting: boolean;
+    /**
+     * Create a new executor instance.
+     * @constructor
+     */
+    constructor();
+    /**
+     * Add an asynchronous operation to the execution queue.
+     */
+    addOp(func: Function, ...param: any[]): Promise<unknown>;
+    /**
+     * Execute the queued asynchronous operations sequentially.
+     */
+    execute(): Promise<void>;
+}
+export default executorC;

package/dist/esm/executor.js

@@ -0,0 +1,45 @@
+/**
+ * A simple executor for queuing and executing asynchronous operations sequentially.
+ * @class
+ */
+class executorC {
+    quote;
+    isExecuting;
+    /**
+     * Create a new executor instance.
+     * @constructor
+     */
+    constructor() {
+        this.quote = [];
+        this.isExecuting = false;
+    }
+    /**
+     * Add an asynchronous operation to the execution queue.
+     */
+    async addOp(func, ...param) {
+        return await new Promise((resolve, reject) => {
+            this.quote.push({
+                func,
+                param,
+                resolve,
+                reject
+            });
+            this.execute();
+        });
+    }
+    /**
+     * Execute the queued asynchronous operations sequentially.
+     */
+    async execute() {
+        if (this.isExecuting)
+            return;
+        this.isExecuting = true;
+        while (this.quote.length > 0) {
+            let q = this.quote.shift();
+            let res = await q.func(...q.param);
+            q.resolve(res);
+        }
+        this.isExecuting = false;
+    }
+}
+export default executorC;

package/dist/esm/file/find.d.ts

@@ -0,0 +1,11 @@
+import { Search } from "../types/arg.js";
+import { Context } from "../types/types.js";
+import { FindOpts } from "../types/options.js";
+/**
+ * Asynchronously finds entries in a file based on search criteria.
+ */
+export declare function find(file: string, arg: Search, context?: Context, findOpts?: FindOpts): Promise<unknown>;
+/**
+ * Asynchronously finds one entry in a file based on search criteria.
+ */
+export declare function findOne(file: string, arg: Search, context?: Context, findOpts?: FindOpts): Promise<unknown>;

package/dist/esm/file/find.js

@@ -0,0 +1,73 @@
+import { existsSync, promises } from "fs";
+import { pathRepair, createRL } from "./utils.js";
+import { parse } from "../format.js";
+import hasFieldsAdvanced from "../utils/hasFieldsAdvanced.js";
+import updateFindObject from "../utils/updateFindObject.js";
+/**
+ * Processes a line of text from a file and checks if it matches the search criteria.
+ */
+async function findProcesLine(arg, line, context = {}, findOpts = {}) {
+    const ob = parse(line);
+    let res = false;
+    if (typeof arg === "function") {
+        if (arg(ob, context))
+            res = true;
+    }
+    else if (typeof arg === "object" && !Array.isArray(arg)) {
+        if (hasFieldsAdvanced(ob, arg))
+            res = true;
+    }
+    if (res)
+        return updateFindObject(ob, findOpts);
+    return null;
+}
+/**
+ * Asynchronously finds entries in a file based on search criteria.
+ */
+export async function find(file, arg, context = {}, findOpts = {}) {
+    file = pathRepair(file);
+    return await new Promise(async (resolve) => {
+        if (!existsSync(file)) {
+            await promises.writeFile(file, "");
+            resolve(false);
+            return;
+        }
+        const rl = createRL(file);
+        const resF = [];
+        for await (const line of rl) {
+            if (line == "" || !line)
+                continue;
+            const res = await findProcesLine(arg, line, context, findOpts);
+            if (res)
+                resF.push(res);
+        }
+        ;
+        resolve(resF);
+        rl.close();
+    });
+}
+/**
+ * Asynchronously finds one entry in a file based on search criteria.
+ */
+export async function findOne(file, arg, context = {}, findOpts = {}) {
+    file = pathRepair(file);
+    return await new Promise(async (resolve) => {
+        if (!existsSync(file)) {
+            await promises.writeFile(file, "");
+            resolve(false);
+            return;
+        }
+        const rl = createRL(file);
+        for await (const line of rl) {
+            if (line == "" || !line)
+                continue;
+            const res = await findProcesLine(arg, line, context, findOpts);
+            if (res) {
+                resolve(res);
+                rl.close();
+            }
+        }
+        ;
+        resolve(false);
+    });
+}

package/dist/esm/file/index.d.ts

@@ -0,0 +1,3 @@
+export { default as update } from "./update.js";
+export { default as remove } from "./remove.js";
+export * from "./find.js";

package/{file → dist/esm/file}/index.js

@@ -1,3 +1,3 @@
 export { default as update } from "./update.js";
 export { default as remove } from "./remove.js";
-export * from "./find.js";
+export * from "./find.js";

package/dist/esm/file/remove.d.ts

@@ -0,0 +1,7 @@
+import { Search } from "../types/arg.js";
+import { Context } from "../types/types.js";
+/**
+ * Asynchronously removes entries from a file based on search criteria.
+ */
+declare function remove(cpath: string, arg: Search, context?: Context, one?: boolean): Promise<boolean>;
+export default remove;

package/dist/esm/file/remove.js

@@ -0,0 +1,56 @@
+import { existsSync, promises, appendFileSync, readdirSync } from "fs";
+import { pathRepair, createRL } from "./utils.js";
+import { parse } from "../format.js";
+import hasFieldsAdvanced from "../utils/hasFieldsAdvanced.js";
+/**
+ * Removes entries from a file based on search criteria.
+ */
+async function removeWorker(file, search, context = {}, one = false) {
+    file = pathRepair(file);
+    if (!existsSync(file)) {
+        await promises.writeFile(file, "");
+        return false;
+    }
+    await promises.copyFile(file, file + ".tmp");
+    await promises.writeFile(file, "");
+    const rl = createRL(file + ".tmp");
+    let removed = false;
+    for await (let line of rl) {
+        if (one && removed) {
+            appendFileSync(file, line + "\n");
+            continue;
+        }
+        const data = parse(line);
+        if (typeof search === "function") {
+            if (search(data, context)) {
+                removed = true;
+                continue;
+            }
+        }
+        else if (typeof search === "object" && !Array.isArray(search)) {
+            if (hasFieldsAdvanced(data, search)) {
+                removed = true;
+                continue;
+            }
+        }
+        appendFileSync(file, line + "\n");
+    }
+    await promises.writeFile(file + ".tmp", "");
+    return removed;
+}
+/**
+ * Asynchronously removes entries from a file based on search criteria.
+ */
+async function remove(cpath, arg, context = {}, one = false) {
+    let files = readdirSync(cpath).filter(file => !/\.tmp$/.test(file));
+    files.reverse();
+    let remove = false;
+    for (const file of files) {
+        const removed = await removeWorker(cpath + file, arg, context, one);
+        if (one && removed)
+            break;
+        remove = remove || removed;
+    }
+    return remove;
+}
+export default remove;

package/dist/esm/file/update.d.ts

@@ -0,0 +1,7 @@
+import { Context } from "../types/types.js";
+import { Search, Updater } from "../types/arg.js";
+/**
+ * Asynchronously updates entries in a file based on search criteria and an updater function or object.
+ */
+declare function update(cpath: string, arg: Search, updater: Updater, context?: Context, one?: boolean): Promise<boolean>;
+export default update;

package/dist/esm/file/update.js

@@ -0,0 +1,65 @@
+import { existsSync, promises, readdirSync } from "fs";
+import { pathRepair, createRL } from "./utils.js";
+import { parse, stringify } from "../format.js";
+import hasFieldsAdvanced from "../utils/hasFieldsAdvanced.js";
+import updateObjectAdvanced from "../utils/updateObject.js";
+/**
+ * Updates a file based on search criteria and an updater function or object.
+ */
+async function updateWorker(file, search, updater, context = {}, one = false) {
+    file = pathRepair(file);
+    if (!existsSync(file)) {
+        await promises.writeFile(file, "");
+        return false;
+    }
+    await promises.copyFile(file, file + ".tmp");
+    await promises.writeFile(file, "");
+    const rl = createRL(file + ".tmp");
+    let updated = false;
+    for await (let line of rl) {
+        if (one && updated) {
+            await promises.appendFile(file, line + "\n");
+            continue;
+        }
+        const data = parse(line);
+        let ob = false;
+        if (typeof search === "function") {
+            ob = search(data, context) || false;
+        }
+        else if (typeof search === "object" && !Array.isArray(search)) {
+            ob = hasFieldsAdvanced(data, search);
+        }
+        if (ob) {
+            let updateObj = data;
+            if (typeof updater === "function") {
+                const updateObjValue = updater(data, context);
+                if (updateObjValue)
+                    updateObj = updateObjValue;
+            }
+            else if (typeof updater === "object" && !Array.isArray(updater)) {
+                updateObj = updateObjectAdvanced(data, updater);
+            }
+            line = await stringify(updateObj);
+            updated = true;
+        }
+        await promises.appendFile(file, line + "\n");
+    }
+    await promises.writeFile(file + ".tmp", "");
+    return updated;
+}
+/**
+ * Asynchronously updates entries in a file based on search criteria and an updater function or object.
+ */
+async function update(cpath, arg, updater, context = {}, one = false) {
+    let files = readdirSync(cpath).filter(file => !/\.tmp$/.test(file));
+    files.reverse();
+    let update = false;
+    for (const file of files) {
+        const updated = await updateWorker(cpath + file, arg, updater, context, one);
+        if (one && updated)
+            return true;
+        update = update || updated;
+    }
+    return update;
+}
+export default update;

package/dist/esm/file/utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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;

package/{file → dist/esm/file}/utils.js

@@ -1,27 +1,19 @@
 import { createReadStream } from "fs";
 import { createInterface } from "readline";
-
 /**
  * Repairs a file path by replacing double slashes
- * @private
- * @param {string} path - The file path to repair.
- * @returns {string} The repaired file path.
  */
-export function pathRepair(path){
+export function pathRepair(path) {
     return path.replaceAll("//", "/");
 }
-
 /**
  * Creates a Readline interface for reading large files with a specified high water mark.
- * @private
- * @param {string} file - The file path to create a Readline interface for.
- * @returns {readline.Interface} The Readline interface.
  */
-export function createRL(file){
+export function createRL(file) {
     const read_stream = createReadStream(file, { highWaterMark: 10 * 1024 * 1024 }); //10MB
     const rl = createInterface({
         input: read_stream,
         crlfDelay: Infinity
     });
     return rl;
-}
+}

package/dist/esm/format.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Parses given string into a JSON object. If the string does not start with
+ * a {, it is wrapped in one. This allows for a shorthand when
+ * storing/reading data from a file.
+ *
+ * @param {string} data
+ * @returns {Object}
+ */
+export declare function parse(data: any): any;
+/**
+ * Converts given object to a string. If the string is a valid json5, it is
+ * returned as is. If it is a valid json5 wrapped in {}, the curly brackets
+ * are removed. Otherwise the string is wrapped in {}.
+ *
+ * @param {Object} data
+ * @return {String}
+ */
+export declare function stringify(data: any): any;

package/{format.js → dist/esm/format.js}

@@ -1,29 +1,29 @@
-import json5 from "json5";
-
-/**
- * Parses given string into a JSON object. If the string does not start with
- * a {, it is wrapped in one. This allows for a shorthand when
- * storing/reading data from a file.
- *
- * @param {string} data
- * @returns {Object}
- */
-export function parse(data){
-    if(!data.startsWith("{")) data = "{" + data + "}";
-    return json5.parse(data);
-}
-/**
- * Converts given object to a string. If the string is a valid json5, it is
- * returned as is. If it is a valid json5 wrapped in {}, the curly brackets
- * are removed. Otherwise the string is wrapped in {}.
- *
- * @param {Object} data
- * @return {String}
- */
-export function stringify(data){
-    data = json5.stringify(data);
-    if(data.startsWith("{")){
-        data = data.slice(1, -1);
-    }
-    return data;
-}
+import json5 from "json5";
+/**
+ * Parses given string into a JSON object. If the string does not start with
+ * a {, it is wrapped in one. This allows for a shorthand when
+ * storing/reading data from a file.
+ *
+ * @param {string} data
+ * @returns {Object}
+ */
+export function parse(data) {
+    if (!data.startsWith("{"))
+        data = "{" + data + "}";
+    return json5.parse(data);
+}
+/**
+ * Converts given object to a string. If the string is a valid json5, it is
+ * returned as is. If it is a valid json5 wrapped in {}, the curly brackets
+ * are removed. Otherwise the string is wrapped in {}.
+ *
+ * @param {Object} data
+ * @return {String}
+ */
+export function stringify(data) {
+    data = json5.stringify(data);
+    if (data.startsWith("{")) {
+        data = data.slice(1, -1);
+    }
+    return data;
+}

package/dist/esm/gen.d.ts

@@ -0,0 +1,5 @@
+import Id from "./types/Id";
+/**
+ * Generates a unique identifier based on specified parts.
+ */
+export default function genId(parts?: number | number[], fill?: number): Id;