@wxn0brp/db 0.0.5 → 0.0.6

package/{executor.js → dist/cjs/executor.js}

@@ -1,54 +1,47 @@
-/**
- * A simple executor for queuing and executing asynchronous operations sequentially.
- * @class
- */
-class executorC{
-    /**
-     * Create a new executor instance.
-     * @constructor
-     */
-    constructor(){
-        this.quote = [];
-        this.isExecuting = false;
-    }
-
-    /**
-     * Add an asynchronous operation to the execution queue.
-     *
-     * @async
-     * @function
-     * @param {Function} func - The asynchronous function to execute.
-     * @param {...*} param - Parameters to pass to the function.
-     * @returns {Promise} A Promise that resolves when the operation is executed.
-     */
-    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
-     * @function
-     */
-    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;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 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;
+    }
+}
+exports.default = executorC;

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

@@ -0,0 +1,11 @@
+import { ArgOrFunc } 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: ArgOrFunc, context?: Context, findOpts?: FindOpts): Promise<unknown>;
+/**
+ * Asynchronously finds one entry in a file based on search criteria.
+ */
+export declare function findOne(file: string, arg: ArgOrFunc, context?: Context, findOpts?: FindOpts): Promise<unknown>;

package/dist/cjs/file/find.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.find = find;
+exports.findOne = findOne;
+const fs_1 = require("fs");
+const utils_js_1 = require("./utils.js");
+const format_js_1 = require("../format.js");
+const hasFieldsAdvanced_js_1 = __importDefault(require("../utils/hasFieldsAdvanced.js"));
+const updateFindObject_js_1 = __importDefault(require("../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 = (0, format_js_1.parse)(line);
+    let res = false;
+    if (typeof arg === "function") {
+        if (arg(ob, context))
+            res = true;
+    }
+    else if (typeof arg === "object" && !Array.isArray(arg)) {
+        if ((0, hasFieldsAdvanced_js_1.default)(ob, arg))
+            res = true;
+    }
+    if (res)
+        return (0, updateFindObject_js_1.default)(ob, findOpts);
+    return null;
+}
+/**
+ * Asynchronously finds entries in a file based on search criteria.
+ */
+async function find(file, arg, context = {}, findOpts = {}) {
+    file = (0, utils_js_1.pathRepair)(file);
+    return await new Promise(async (resolve) => {
+        if (!(0, fs_1.existsSync)(file)) {
+            await fs_1.promises.writeFile(file, "");
+            resolve(false);
+            return;
+        }
+        const rl = (0, utils_js_1.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.
+ */
+async function findOne(file, arg, context = {}, findOpts = {}) {
+    file = (0, utils_js_1.pathRepair)(file);
+    return await new Promise(async (resolve) => {
+        if (!(0, fs_1.existsSync)(file)) {
+            await fs_1.promises.writeFile(file, "");
+            resolve(false);
+            return;
+        }
+        const rl = (0, utils_js_1.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/cjs/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/dist/cjs/file/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remove = exports.update = void 0;
+var update_js_1 = require("./update.js");
+Object.defineProperty(exports, "update", { enumerable: true, get: function () { return __importDefault(update_js_1).default; } });
+var remove_js_1 = require("./remove.js");
+Object.defineProperty(exports, "remove", { enumerable: true, get: function () { return __importDefault(remove_js_1).default; } });
+__exportStar(require("./find.js"), exports);

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

@@ -0,0 +1,7 @@
+import { ArgOrFunc } 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: ArgOrFunc, context?: Context, one?: boolean): Promise<boolean>;
+export default remove;

package/dist/cjs/file/remove.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const utils_js_1 = require("./utils.js");
+const format_js_1 = require("../format.js");
+const hasFieldsAdvanced_js_1 = __importDefault(require("../utils/hasFieldsAdvanced.js"));
+/**
+ * Removes entries from a file based on search criteria.
+ */
+async function removeWorker(file, search, context = {}, one = false) {
+    file = (0, utils_js_1.pathRepair)(file);
+    if (!(0, fs_1.existsSync)(file)) {
+        await fs_1.promises.writeFile(file, "");
+        return false;
+    }
+    await fs_1.promises.copyFile(file, file + ".tmp");
+    await fs_1.promises.writeFile(file, "");
+    const rl = (0, utils_js_1.createRL)(file + ".tmp");
+    let removed = false;
+    for await (let line of rl) {
+        if (one && removed) {
+            (0, fs_1.appendFileSync)(file, line + "\n");
+            continue;
+        }
+        const data = (0, format_js_1.parse)(line);
+        if (typeof search === "function") {
+            if (search(data, context)) {
+                removed = true;
+                continue;
+            }
+        }
+        else if (typeof search === "object" && !Array.isArray(search)) {
+            if ((0, hasFieldsAdvanced_js_1.default)(data, search)) {
+                removed = true;
+                continue;
+            }
+        }
+        (0, fs_1.appendFileSync)(file, line + "\n");
+    }
+    await fs_1.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 = (0, fs_1.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;
+}
+exports.default = remove;

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

@@ -0,0 +1,7 @@
+import { Context } from "../types/types.js";
+import { ArgOrFunc } 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: ArgOrFunc, obj: ArgOrFunc, context?: Context, one?: boolean): Promise<boolean>;
+export default update;

package/dist/cjs/file/update.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const utils_js_1 = require("./utils.js");
+const format_js_1 = require("../format.js");
+const hasFieldsAdvanced_js_1 = __importDefault(require("../utils/hasFieldsAdvanced.js"));
+const updateObject_js_1 = __importDefault(require("../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 = (0, utils_js_1.pathRepair)(file);
+    if (!(0, fs_1.existsSync)(file)) {
+        await fs_1.promises.writeFile(file, "");
+        return false;
+    }
+    await fs_1.promises.copyFile(file, file + ".tmp");
+    await fs_1.promises.writeFile(file, "");
+    const rl = (0, utils_js_1.createRL)(file + ".tmp");
+    let updated = false;
+    for await (let line of rl) {
+        if (one && updated) {
+            (0, fs_1.appendFileSync)(file, line + "\n");
+            continue;
+        }
+        const data = (0, format_js_1.parse)(line);
+        let ob = false;
+        if (typeof search === "function") {
+            ob = search(data, context) || false;
+        }
+        else if (typeof search === "object" && !Array.isArray(search)) {
+            ob = (0, hasFieldsAdvanced_js_1.default)(data, search);
+        }
+        if (ob) {
+            let updateObj;
+            if (typeof updater === "function") {
+                updateObj = updater(data, context);
+            }
+            else if (typeof updater === "object" && !Array.isArray(updater)) {
+                updateObj = (0, updateObject_js_1.default)(data, updater);
+            }
+            line = await (0, format_js_1.stringify)(updateObj);
+            updated = true;
+        }
+        (0, fs_1.appendFileSync)(file, line + "\n");
+    }
+    await fs_1.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, obj, context = {}, one = false) {
+    let files = (0, fs_1.readdirSync)(cpath).filter(file => !/\.tmp$/.test(file));
+    files.reverse();
+    let update = false;
+    for (const file of files) {
+        const updated = await updateWorker(cpath + file, arg, obj, context, one);
+        if (one && updated)
+            return true;
+        update = update || updated;
+    }
+    return update;
+}
+exports.default = update;

package/dist/cjs/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/dist/cjs/file/utils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathRepair = pathRepair;
+exports.createRL = createRL;
+const fs_1 = require("fs");
+const readline_1 = require("readline");
+/**
+ * Repairs a file path by replacing double slashes
+ */
+function pathRepair(path) {
+    return path.replaceAll("//", "/");
+}
+/**
+ * Creates a Readline interface for reading large files with a specified high water mark.
+ */
+function createRL(file) {
+    const read_stream = (0, fs_1.createReadStream)(file, { highWaterMark: 10 * 1024 * 1024 }); //10MB
+    const rl = (0, readline_1.createInterface)({
+        input: read_stream,
+        crlfDelay: Infinity
+    });
+    return rl;
+}

package/dist/cjs/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/dist/cjs/format.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = parse;
+exports.stringify = stringify;
+const json5_1 = __importDefault(require("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}
+ */
+function parse(data) {
+    if (!data.startsWith("{"))
+        data = "{" + data + "}";
+    return json5_1.default.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}
+ */
+function stringify(data) {
+    data = json5_1.default.stringify(data);
+    if (data.startsWith("{")) {
+        data = data.slice(1, -1);
+    }
+    return data;
+}

package/dist/cjs/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;

package/dist/cjs/gen.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = genId;
+const usedIdsMap = new Map();
+/**
+ * Generates a unique identifier based on specified parts.
+ */
+function genId(parts = null, fill = 1) {
+    parts = changeInputToPartsArray(parts, fill);
+    const time = getTime();
+    const id = getUniqueRandom(time, parts);
+    return id;
+}
+/**
+ * Generates a unique random identifier based on time and parts.
+ * @param time - The current time in a base36 string format.
+ * @param parts - An array of parts to be used for generating the identifier.
+ * @param s - Recursion counter for handling collision (default: 0).
+ * @returns {string} The unique random identifier.
+ */
+function getUniqueRandom(time, partsA, s = 0) {
+    const parts = partsA.map(l => getRandom(l));
+    const id = [time, ...parts].join("-");
+    if (usedIdsMap.has(id)) {
+        s++;
+        if (s < 25)
+            return getUniqueRandom(time, partsA, s);
+        partsA = addOneToPods(partsA);
+        time = getTime();
+        return getUniqueRandom(time, partsA);
+    }
+    usedIdsMap.set(id, Date.now() + 2000);
+    usedIdsMap.forEach((value, key) => {
+        if (value < Date.now())
+            usedIdsMap.delete(key);
+    });
+    return id;
+}
+/**
+ * Generates a random string of base36 characters.
+ */
+function getRandom(unix) {
+    return (Math.floor(Math.random() * Math.pow(36, unix))).toString(36);
+}
+/**
+ * Gets the current time in a base36 string format.
+ */
+function getTime() {
+    return Math.floor(new Date().getTime() / 1000).toString(36);
+}
+/**
+ * Adds one to each part of the input array.
+ */
+function addOneToPods(array) {
+    const sum = array.reduce((acc, current) => acc + current, 0);
+    const num = sum + 1;
+    const len = array.length;
+    const result = [];
+    const quotient = Math.floor(num / len);
+    const remainder = num % len;
+    for (let i = 0; i < len; i++) {
+        if (i < remainder)
+            result.push(quotient + 1);
+        else
+            result.push(quotient);
+    }
+    return result;
+}
+/**
+ * Converts input to an array of parts.
+ */
+function changeInputToPartsArray(parts = null, fill = 1) {
+    if (Array.isArray(parts))
+        return parts;
+    if (typeof parts == "number")
+        return Array(parts).fill(fill);
+    return [1, 1];
+}

package/dist/cjs/graph.d.ts

@@ -0,0 +1,47 @@
+import DataBase from "./database.js";
+import Data from "./types/data.js";
+/**
+ * A class representing a graph database.
+ * @class
+ */
+declare class Graph {
+    db: DataBase;
+    constructor(databaseFolder: string);
+    /**
+     * Adds an edge between two nodes.
+     */
+    add(collection: string, nodeA: string, nodeB: string): Promise<Data>;
+    /**
+     * Removes an edge between two nodes.
+     */
+    remove(collection: string, nodeA: string, nodeB: string): Promise<boolean>;
+    /**
+     * Finds all edges with either node equal to `node`.
+     */
+    find(collection: string, node: string): Promise<Data[]>;
+    /**
+     * Finds one edge with either node equal to `nodeA` and the other equal to `nodeB`.
+     */
+    findOne(collection: any, nodeA: any, nodeB: any): Promise<Data>;
+    /**
+     * Gets all edges in the database.
+     */
+    getAll(collection: any): Promise<Data[]>;
+    /**
+     * Get the names of all available databases.
+     */
+    getCollections(): Promise<string[]>;
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    checkCollection(collection: any): Promise<void>;
+    /**
+     * Check if a collection exists.
+     */
+    issetCollection(collection: any): Promise<boolean>;
+    /**
+     * Removes a database collection from the file system.
+     */
+    removeCollection(collection: any): void;
+}
+export default Graph;