@wxn0brp/db-core 0.0.1

package/src/db/memory.ts

@@ -0,0 +1,177 @@
+
+import ValtheraClass from "./valthera";
+import CustomFileCpu from "../customFileCpu";
+import genId from "../helpers/gen";
+import dbActionBase from "../base/actions";
+import Data from "../types/data";
+import FileCpu from "../types/fileCpu";
+import { DbOpts } from "../types/options";
+import { VQuery } from "../types/query";
+import { compareSafe } from "../utils/sort";
+
+export class MemoryAction extends dbActionBase {
+    folder: string;
+    options: DbOpts;
+    fileCpu: FileCpu;
+    memory: Map<string, any[]>;
+
+    /**
+     * Creates a new instance of dbActionC.
+     * @constructor
+     * @param folder - The folder where database files are stored.
+     * @param options - The options object.
+     */
+    constructor() {
+        super();
+        this.memory = new Map();
+        this.fileCpu = new CustomFileCpu(this._readMemory.bind(this), this._writeMemory.bind(this));
+    }
+
+    _readMemory(key: string) {
+        if (!this.memory.has(key)) return [];
+        return this.memory.get(key);
+    }
+
+    _writeMemory(key: string, data: any[]) {
+        this.memory.set(key, data);
+    }
+
+    _getCollectionPath(collection: string) {
+        return this.folder + "/" + collection + "/";
+    }
+
+    /**
+     * Get a list of available databases in the specified folder.
+     */
+    async getCollections() {
+        const collections = Array.from(this.memory.keys());
+        return collections;
+    }
+
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    async checkCollection({ collection }: VQuery) {
+        if (this.issetCollection(collection)) return;
+        this.memory.set(collection, []);
+        return true;
+    }
+    /**
+     * Check if a collection exists.
+     */
+    async issetCollection({ collection }: VQuery) {
+        return this.memory.has(collection);
+    }
+
+    /**
+     * Add a new entry to the specified database.
+     */
+    async add({ collection, data, id_gen = true }: VQuery) {
+        await this.checkCollection(arguments[0]);
+
+        if (id_gen) 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, search, context = {}, dbFindOpts = {}, findOpts = {} }: VQuery) {
+        const {
+            reverse = false,
+            max = -1,
+            offset = 0,
+            sortBy,
+            sortAsc = true
+        } = dbFindOpts;
+
+        await this.checkCollection(arguments[0]);
+
+        let data = await this.fileCpu.find(collection, search, context, findOpts) as Data[];
+
+        if (reverse) data.reverse();
+
+        if (sortBy) {
+            const dir = sortAsc ? 1 : -1;
+            data.sort((a, b) => compareSafe(a[sortBy], b[sortBy]) * dir);
+        }
+
+        if (offset > 0) {
+            if (data.length <= offset) return [];
+            data = data.slice(offset);
+        }
+
+        if (max !== -1 && data.length > max) {
+            data = data.slice(0, max);
+        }
+
+        return data;
+    }
+
+    /**
+     * Find the first matching entry in the specified database based on search criteria.
+     */
+    async findOne({ collection, search, context = {}, findOpts = {} }: VQuery) {
+        await this.checkCollection(arguments[0]);
+        let data = await this.fileCpu.findOne(collection, search, context, findOpts) as Data;
+        return data || null;
+    }
+
+    /**
+     * Update entries in the specified database based on search criteria and an updater function or object.
+     */
+    async update({ collection, search, updater, context = {} }: VQuery) {
+        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, search, updater, context = {} }: VQuery) {
+        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, search, context = {} }: VQuery) {
+        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, search, context = {} }: VQuery) {
+        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 }: VQuery) {
+        this.memory.delete(collection);
+        return true;
+    }
+}
+
+export default class ValtheraMemory extends ValtheraClass {
+    constructor(...args: any[]) {
+        super({ dbAction: new MemoryAction() });
+    }
+}
+
+export function createMemoryValthera<T = { [key: string]: Data[] }>(data?: T) {
+    const db = new ValtheraMemory();
+    if (!data) return db;
+
+    for (const collection of Object.keys(data)) {
+        (db.dbAction as MemoryAction).memory.set(collection, data[collection]);
+    }
+
+    return db;
+}

package/src/db/valthera.ts

@@ -0,0 +1,132 @@
+
+import { version } from "../version";
+import { UniversalEventEmitter } from "../helpers/eventEmiter";
+import dbActionBase from "../base/actions";
+import CollectionManager from "../helpers/CollectionManager";
+import executorC from "../helpers/executor";
+import { Arg, Search, Updater } from "../types/arg";
+import Data from "../types/data";
+import { DbOpts, DbFindOpts, FindOpts } from "../types/options";
+import { VContext } from "../types/types";
+import { ValtheraCompatible } from "../types/valthera";
+
+type DbActionsFns = keyof {
+    [K in keyof dbActionBase as dbActionBase[K] extends (...args: any[]) => any ? K : never]: any;
+}
+
+/**
+ * Represents a database management class for performing CRUD operations.
+ * @class
+ */
+class ValtheraClass implements ValtheraCompatible {
+    dbAction: dbActionBase;
+    executor: executorC;
+    emiter: UniversalEventEmitter;
+    version = version;
+
+    constructor(options: DbOpts = {}) {
+        this.dbAction = options.dbAction || new dbActionBase();
+        this.executor = options.executor || new executorC();
+        this.emiter = new UniversalEventEmitter();
+    }
+
+    private async execute<T>(name: DbActionsFns, ...args: any[]) {
+        const result = await this.executor.addOp(this.dbAction[name].bind(this.dbAction), ...args) as T;
+        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: string) {
+        return new CollectionManager(this, collection);
+    }
+
+    /**
+     * Get the names of all available databases.
+     */
+    async getCollections() {
+        return await this.execute<string[]>("getCollections");
+    }
+
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    async checkCollection(collection: string) {
+        return await this.execute<boolean>("checkCollection", { collection });
+    }
+
+    /**
+     * Check if a collection exists.
+     */
+    async issetCollection(collection: string) {
+        return await this.execute<boolean>("issetCollection", { collection });
+    }
+
+    /**
+     * Add data to a database.
+     */
+    async add<T = Data>(collection: string, data: Arg, id_gen: boolean = true) {
+        return await this.execute<T>("add", { collection, data, id_gen });
+    }
+
+    /**
+     * Find data in a database.
+     */
+    async find<T = Data>(collection: string, search: Search, context: VContext = {}, dbFindOpts: DbFindOpts = {}, findOpts: FindOpts = {}) {
+        return await this.execute<T[]>("find", { collection, search, context, dbFindOpts, findOpts });
+    }
+
+    /**
+     * Find one data entry in a database.
+     */
+    async findOne<T = Data>(collection: string, search: Search, context: VContext = {}, findOpts: FindOpts = {}) {
+        return await this.execute<T | null>("findOne", { collection, search, context, findOpts });
+    }
+
+    /**
+     * Update data in a database.
+     */
+    async update(collection: string, search: Search, updater: Updater, context = {}) {
+        return await this.execute<boolean>("update", { collection, search, updater, context });
+    }
+
+    /**
+     * Update one data entry in a database.
+     */
+    async updateOne(collection: string, search: Search, updater: Updater, context: VContext = {}) {
+        return await this.execute<boolean>("updateOne", { collection, search, updater, context });
+    }
+
+    /**
+     * Remove data from a database.
+     */
+    async remove(collection: string, search: Search, context: VContext = {}) {
+        return await this.execute<boolean>("remove", { collection, search, context });
+    }
+
+    /**
+     * Remove one data entry from a database.
+     */
+    async removeOne(collection: string, search: Search, context: VContext = {}) {
+        return await this.execute<boolean>("removeOne", { collection, search, context });
+    }
+
+    /**
+     * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
+     */
+    async updateOneOrAdd(collection: string, search: Search, updater: Updater, add_arg: Arg = {}, context: VContext = {}, id_gen: boolean = true) {
+        return await this.execute<boolean>("updateOneOrAdd", { collection, search, updater, add_arg, context, id_gen });
+    }
+
+    /**
+     * Removes a database collection from the file system.
+     */
+    async removeCollection(collection: string) {
+        return await this.execute<boolean>("removeCollection", { collection });
+    }
+}
+
+export default ValtheraClass;

package/src/helpers/CollectionManager.ts

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

package/src/helpers/eventEmiter.ts

@@ -0,0 +1,73 @@
+export class UniversalEventEmitter {
+    private _events: { [event: string]: Function[] } = {};
+
+    /**
+     * Registers an event listener
+     * @param {string} event - event name
+     * @param {Function} listener - function to be called when event occurs
+     */
+    public on(event: string, listener: Function): void {
+        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
+     */
+    public once(event: string, listener: Function): void {
+        const onceListener = (...args: any[]) => {
+            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
+     */
+    public off(event?: string, listener?: Function): void {
+        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
+     */
+    public emit(event: string, ...args: any[]): void {
+        const listeners = this._events[event];
+        if (listeners && listeners.length > 0) {
+            listeners.forEach(listener => {
+                listener(...args);
+            });
+        }
+    }
+
+    /**
+     * Returns the number of listeners for the given event
+     */
+    public listenerCount(event: string): number {
+        return this._events[event]?.length || 0;
+    }
+}
+

package/src/helpers/executor.ts

@@ -0,0 +1,55 @@
+interface Task {
+    func: Function;
+    param: any[];
+    resolve: Function;
+    reject: Function;
+}
+
+/**
+ * A simple executor for queuing and executing asynchronous operations sequentially.
+ * @class
+ */
+class executorC {
+    quote: Task[];
+    isExecuting: boolean;
+
+    /**
+     * Create a new executor instance.
+     * @constructor
+     */
+    constructor() {
+        this.quote = [];
+        this.isExecuting = false;
+    }
+
+    /**
+     * Add an asynchronous operation to the execution queue.
+     */
+    async addOp(func: Function, ...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/src/helpers/gen.ts

@@ -0,0 +1,154 @@
+import Id from "../types/Id";
+
+const usedIdsMap = new Map();
+let lastId: Id;
+const recentIdsTimestamps: number[] = [];
+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: number[] = null): Id {
+    if (parts === null) parts = [1, 1];
+
+    const time = getTime();
+    const id = getUniqueRandom({
+        time,
+        partsSchema: parts,
+        s: 0,
+    });
+    return id;
+}
+
+interface GetUniqueRandomOpts {
+    time: string,
+    partsSchema: number[],
+    s: number
+}
+
+/**
+ * Generates a unique random identifier based on time and parts.
+ */
+function getUniqueRandom(opts: GetUniqueRandomOpts): string {
+    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: number, length: number): string {
+    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: number, max: number): number {
+    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: number[], str: string) {
+    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);
+}