@wxn0brp/db-core 0.0.1

package/dist/db/valthera.d.ts

@@ -0,0 +1,74 @@
+import { UniversalEventEmitter } from "../helpers/eventEmiter.js";
+import dbActionBase from "../base/actions.js";
+import CollectionManager from "../helpers/CollectionManager.js";
+import executorC from "../helpers/executor.js";
+import { Arg, Search, Updater } from "../types/arg.js";
+import Data from "../types/data.js";
+import { DbOpts, DbFindOpts, FindOpts } from "../types/options.js";
+import { VContext } from "../types/types.js";
+import { ValtheraCompatible } from "../types/valthera.js";
+/**
+ * Represents a database management class for performing CRUD operations.
+ * @class
+ */
+declare class ValtheraClass implements ValtheraCompatible {
+    dbAction: dbActionBase;
+    executor: executorC;
+    emiter: UniversalEventEmitter;
+    version: string;
+    constructor(options?: DbOpts);
+    private execute;
+    /**
+     * 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<boolean>;
+    /**
+     * 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?: VContext, dbFindOpts?: DbFindOpts, findOpts?: FindOpts): Promise<T[]>;
+    /**
+     * Find one data entry in a database.
+     */
+    findOne<T = Data>(collection: string, search: Search, context?: VContext, 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?: VContext): Promise<boolean>;
+    /**
+     * Remove data from a database.
+     */
+    remove(collection: string, search: Search, context?: VContext): Promise<boolean>;
+    /**
+     * Remove one data entry from a database.
+     */
+    removeOne(collection: string, search: Search, context?: VContext): 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?: VContext, id_gen?: boolean): Promise<boolean>;
+    /**
+     * Removes a database collection from the file system.
+     */
+    removeCollection(collection: string): Promise<boolean>;
+}
+export default ValtheraClass;

package/dist/db/valthera.js

@@ -0,0 +1,107 @@
+import { version } from "../version.js";
+import { UniversalEventEmitter } from "../helpers/eventEmiter.js";
+import dbActionBase from "../base/actions.js";
+import CollectionManager from "../helpers/CollectionManager.js";
+import executorC from "../helpers/executor.js";
+/**
+ * Represents a database management class for performing CRUD operations.
+ * @class
+ */
+class ValtheraClass {
+    dbAction;
+    executor;
+    emiter;
+    version = version;
+    constructor(options = {}) {
+        this.dbAction = options.dbAction || new dbActionBase();
+        this.executor = options.executor || new executorC();
+        this.emiter = new UniversalEventEmitter();
+    }
+    async execute(name, ...args) {
+        const result = await this.executor.addOp(this.dbAction[name].bind(this.dbAction), ...args);
+        if (this.emiter.listenerCount(name) !== 0)
+            this.emiter.emit(name, args, result);
+        if (this.emiter.listenerCount("*") !== 0)
+            this.emiter.emit("*", name, args, result);
+        return result;
+    }
+    /**
+     * 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 await this.execute("getCollections");
+    }
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    async checkCollection(collection) {
+        return await this.execute("checkCollection", { collection });
+    }
+    /**
+     * Check if a collection exists.
+     */
+    async 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 });
+    }
+    /**
+     * Find data in a database.
+     */
+    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 });
+    }
+    /**
+     * Update data in a database.
+     */
+    async 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 });
+    }
+    /**
+     * Remove data from a database.
+     */
+    async 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 });
+    }
+    /**
+     * 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) {
+        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 });
+    }
+}
+export default ValtheraClass;

package/dist/helpers/CollectionManager.d.ts

@@ -0,0 +1,43 @@
+import { Arg, Search, Updater } from "../types/arg.js";
+import { DbFindOpts, FindOpts } from "../types/options.js";
+import { VContext } from "../types/types.js";
+import Data from "../types/data.js";
+import { ValtheraCompatible } from "../types/valthera.js";
+declare class CollectionManager {
+    private db;
+    private collection;
+    constructor(db: ValtheraCompatible, collection: string);
+    /**
+     * Add data to a database.
+     */
+    add<T = Data>(data: Arg, id_gen?: boolean): Promise<T>;
+    /**
+     * Find data in a database.
+     */
+    find<T = Data>(search: Search, context?: VContext, options?: DbFindOpts, findOpts?: FindOpts): Promise<T[]>;
+    /**
+     * Find one data entry in a database.
+     */
+    findOne<T = Data>(search: Search, context?: VContext, findOpts?: FindOpts): Promise<T>;
+    /**
+     * Update data in a database.
+     */
+    update(search: Search, updater: Updater, context?: VContext): Promise<boolean>;
+    /**
+     * Update one data entry in a database.
+     */
+    updateOne(search: Search, updater: Updater, context?: VContext): Promise<boolean>;
+    /**
+     * Remove data from a database.
+     */
+    remove(search: Search, context?: VContext): Promise<boolean>;
+    /**
+     * Remove one data entry from a database.
+     */
+    removeOne(search: Search, context?: VContext): Promise<boolean>;
+    /**
+     * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
+     */
+    updateOneOrAdd(search: Search, updater: Updater, add_arg?: Arg, context?: VContext, id_gen?: boolean): Promise<boolean>;
+}
+export default CollectionManager;

package/dist/helpers/CollectionManager.js

@@ -0,0 +1,57 @@
+class CollectionManager {
+    db;
+    collection;
+    constructor(db, collection) {
+        this.db = db;
+        this.collection = collection;
+    }
+    /**
+     * Add data to a database.
+     */
+    async add(data, id_gen = true) {
+        return await this.db.add(this.collection, data, id_gen);
+    }
+    /**
+     * Find data in a database.
+     */
+    async find(search, context = {}, options = {}, findOpts = {}) {
+        return await this.db.find(this.collection, search, context, options, findOpts);
+    }
+    /**
+     * Find one data entry in a database.
+     */
+    async findOne(search, context = {}, findOpts = {}) {
+        return await this.db.findOne(this.collection, search, context, findOpts);
+    }
+    /**
+     * Update data in a database.
+     */
+    async update(search, updater, context = {}) {
+        return await this.db.update(this.collection, search, updater, context);
+    }
+    /**
+     * Update one data entry in a database.
+     */
+    async updateOne(search, updater, context = {}) {
+        return await this.db.updateOne(this.collection, search, updater, context);
+    }
+    /**
+     * Remove data from a database.
+     */
+    async remove(search, context = {}) {
+        return await this.db.remove(this.collection, search, context);
+    }
+    /**
+     * Remove one data entry from a database.
+     */
+    async removeOne(search, context = {}) {
+        return await this.db.removeOne(this.collection, search, context);
+    }
+    /**
+     * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
+     */
+    async updateOneOrAdd(search, updater, add_arg = {}, context = {}, id_gen = true) {
+        return await this.db.updateOneOrAdd(this.collection, search, updater, add_arg, context, id_gen);
+    }
+}
+export default CollectionManager;

package/dist/helpers/eventEmiter.d.ts

@@ -0,0 +1,31 @@
+export declare class UniversalEventEmitter {
+    private _events;
+    /**
+     * Registers an event listener
+     * @param {string} event - event name
+     * @param {Function} listener - function to be called when event occurs
+     */
+    on(event: string, listener: Function): void;
+    /**
+     * Registers a one-time event listener
+     * @param {string} event - event name
+     * @param {Function} listener - function to be called once
+     */
+    once(event: string, listener: Function): void;
+    /**
+     * Removes an event listener
+     * @param {string} event - event name
+     * @param {Function} [listener] - optional: specific listener to remove
+     */
+    off(event?: string, listener?: Function): void;
+    /**
+     * Emits an event
+     * @param {string} event - event name
+     * @param {...any} args - arguments to be passed to listeners
+     */
+    emit(event: string, ...args: any[]): void;
+    /**
+     * Returns the number of listeners for the given event
+     */
+    listenerCount(event: string): number;
+}

package/dist/helpers/eventEmiter.js

@@ -0,0 +1,65 @@
+export class UniversalEventEmitter {
+    _events = {};
+    /**
+     * Registers an event listener
+     * @param {string} event - event name
+     * @param {Function} listener - function to be called when event occurs
+     */
+    on(event, listener) {
+        if (!this._events[event])
+            this._events[event] = [];
+        this._events[event].push(listener);
+    }
+    /**
+     * Registers a one-time event listener
+     * @param {string} event - event name
+     * @param {Function} listener - function to be called once
+     */
+    once(event, listener) {
+        const onceListener = (...args) => {
+            this.off(event, onceListener);
+            listener(...args);
+        };
+        this.on(event, onceListener);
+    }
+    /**
+     * Removes an event listener
+     * @param {string} event - event name
+     * @param {Function} [listener] - optional: specific listener to remove
+     */
+    off(event, listener) {
+        if (!event) {
+            // Remove all events
+            this._events = {};
+            return;
+        }
+        if (!listener) {
+            // Remove all listeners for the given event
+            delete this._events[event];
+            return;
+        }
+        // Remove specific listener
+        if (this._events[event]) {
+            this._events[event] = this._events[event].filter(l => l !== listener);
+        }
+    }
+    /**
+     * Emits an event
+     * @param {string} event - event name
+     * @param {...any} args - arguments to be passed to listeners
+     */
+    emit(event, ...args) {
+        const listeners = this._events[event];
+        if (listeners && listeners.length > 0) {
+            listeners.forEach(listener => {
+                listener(...args);
+            });
+        }
+    }
+    /**
+     * Returns the number of listeners for the given event
+     */
+    listenerCount(event) {
+        return this._events[event]?.length || 0;
+    }
+}

package/dist/helpers/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/helpers/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/helpers/gen.d.ts

@@ -0,0 +1,8 @@
+import Id from "../types/Id.js";
+/**
+ * Generates a unique random identifier based on time and parts.
+ *
+ * @param {number[]} [parts] - an array of lengths of parts of the identifier
+ * @returns {Id} - a new unique identifier
+ */
+export default function genId(parts?: number[]): Id;

package/dist/helpers/gen.js

@@ -0,0 +1,134 @@
+const usedIdsMap = new Map();
+let lastId;
+const recentIdsTimestamps = [];
+let startIndex = 0;
+let lastGeneratedMs = 0;
+let lastRandomValue = 0;
+/**
+ * Generates a unique random identifier based on time and parts.
+ *
+ * @param {number[]} [parts] - an array of lengths of parts of the identifier
+ * @returns {Id} - a new unique identifier
+ */
+export default function genId(parts = null) {
+    if (parts === null)
+        parts = [1, 1];
+    const time = getTime();
+    const id = getUniqueRandom({
+        time,
+        partsSchema: parts,
+        s: 0,
+    });
+    return id;
+}
+/**
+ * Generates a unique random identifier based on time and parts.
+ */
+function getUniqueRandom(opts) {
+    while (true) {
+        let minValue = 0;
+        if (lastId) {
+            const parts = lastId.split("-");
+            const lastTime = parts.shift();
+            if (lastTime === opts.time) {
+                const int36 = parts.join("");
+                minValue = parseInt(int36, 36) + 1;
+            }
+        }
+        const partsLengthSum = opts.partsSchema.reduce((acc, num) => acc + num, 0);
+        const partsData = generateBase36InRange(minValue, partsLengthSum);
+        const parts = splitStringByArray(opts.partsSchema, partsData);
+        const id = [opts.time, ...parts].join("-");
+        if (!usedIdsMap.has(id)) {
+            usedIdsMap.set(id, true);
+            setTimeout(() => usedIdsMap.delete(id), 1000);
+            lastId = id;
+            return id;
+        }
+        opts.s++;
+        if (opts.s >= partsLengthSum) {
+            opts.time = getTime();
+            opts.s = 0;
+        }
+    }
+}
+/**
+ * Tracks the current load of the application by counting the number of ids that have been generated in the last second.
+ * @returns The number of ids that have been generated in the last second.
+ */
+function trackLoad() {
+    const now = Date.now();
+    recentIdsTimestamps.push(now);
+    while (startIndex < recentIdsTimestamps.length && recentIdsTimestamps[startIndex] < now - 1) {
+        startIndex++;
+    }
+    return recentIdsTimestamps.length - startIndex;
+}
+/**
+ * Generates a base-36 encoded string with a specified length based on a random value within a range.
+ *
+ * The function calculates a random value within the base-36 range determined by the provided
+ * `minValue` and `length`. It uses a bias mechanism to adjust the randomness based on the
+ * current load, ensuring unique generation over short periods. If the system load is low or
+ * the current millisecond has changed, a new random value is generated. Otherwise, the random
+ * value is incremented by a small amount with certain probabilities.
+ *
+ * @param minValue - The minimum value for the base-36 encoded number.
+ * @param length - The length of the resulting base-36 string.
+ * @returns A base-36 encoded string representation of the random value, padded to the specified length.
+ */
+function generateBase36InRange(minValue, length) {
+    const maxValue = Math.pow(36, length) - 1;
+    const load = trackLoad();
+    const currentMs = Date.now();
+    if (load < 3 || currentMs !== lastGeneratedMs) {
+        lastRandomValue = biasedRandomInRange(minValue, maxValue);
+        lastGeneratedMs = currentMs;
+    }
+    else {
+        const rand = Math.random();
+        if (rand < 0.6) {
+            lastRandomValue += 1;
+        }
+        else if (rand < 0.9) {
+            lastRandomValue += 2;
+        }
+        else {
+            lastRandomValue = biasedRandomInRange(lastRandomValue, maxValue);
+        }
+    }
+    return lastRandomValue.toString(36).padStart(length, "0");
+}
+/**
+ * Generates a random number between the specified range, but with a bias towards the lower
+ * end of the range. The bias is calculated as the cube root of the random value, which
+ * will make the random value more likely to be closer to the minimum value.
+ * @param min - The minimum value of the range.
+ * @param max - The maximum value of the range.
+ * @returns A random number between the specified range, with a bias towards the lower end.
+ */
+function biasedRandomInRange(min, max) {
+    let randomValue = min;
+    const bias = Math.pow(Math.random(), 3);
+    randomValue = Math.floor(min + (max - min) * bias);
+    return Math.min(randomValue, max);
+}
+/**
+ * Splits a string into an array of substrings, where each substring is determined by
+ * the values in the provided array.
+ *
+ * @param arr - An array of numbers, where each number represents the length of a substring.
+ * @param str - The string to split.
+ * @returns An array of substrings, where each element is a substring of the original string,
+ *          determined by the corresponding element in the provided array.
+ */
+function splitStringByArray(arr, str) {
+    let start = 0;
+    return arr.map(length => str.slice(start, start += length));
+}
+/**
+ * Gets the current time in a base36 string format.
+ */
+function getTime() {
+    return new Date().getTime().toString(36);
+}

package/dist/helpers/relation.d.ts

@@ -0,0 +1,10 @@
+import { Search } from "../types/arg.js";
+import { DbFindOpts } from "../types/options.js";
+import { RelationTypes } from "../types/relation.js";
+declare class Relation {
+    dbs: RelationTypes.DBS;
+    constructor(dbs: RelationTypes.DBS);
+    findOne(path: RelationTypes.Path, search: Search, relations: RelationTypes.Relation, select?: string[][] | Record<string, any>): Promise<any>;
+    find(path: RelationTypes.Path, search: Search, relations: RelationTypes.Relation, select?: string[][] | Record<string, any>, findOpts?: DbFindOpts): Promise<any[]>;
+}
+export default Relation;