@wxn0brp/db-core 0.0.1 → 0.0.2

package/src/db/valthera.ts

@@ -1,132 +0,0 @@
-
-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

@@ -1,67 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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);
-}

package/src/helpers/relation.ts

@@ -1,192 +0,0 @@
-import { Search } from "../types/arg";
-import { DbFindOpts } from "../types/options";
-import { RelationTypes } from "../types/relation";
-
-function pickByPath(obj: any, paths: string[][]): any {
-    const result = {};
-    for (const path of paths) {
-        let src = obj;
-        let dst = result;
-        for (let i = 0; i < path.length; i++) {
-            const k = path[i];
-            if (src == null) break;
-            if (i === path.length - 1) {
-                dst[k] = src[k];
-            } else {
-                dst[k] ||= {};
-                dst = dst[k];
-                src = src[k];
-            }
-        }
-    }
-    return result;
-}
-
-function autoSelect(rel: RelationTypes.RelationConfig, key: string): [string[] | undefined, boolean] {
-    const select = Array.isArray(rel.select) ? [...rel.select] : undefined;
-    const shouldDelete = select && !select.includes(key);
-    if (shouldDelete) select.push(key);
-    return [select, shouldDelete];
-}
-
-function convertSearchObjToSearchArray(obj: Record<string, any>, parentKeys: string[] = []): string[][] {
-    return Object.entries(obj).reduce((acc, [key, value]) => {
-        const currentPath = [...parentKeys, key];
-
-        if (!value) {
-            return acc;
-        } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-            return [...acc, ...convertSearchObjToSearchArray(value, currentPath)];
-        } else {
-            return [...acc, currentPath];
-        }
-    }, []);
-}
-
-async function processRelations(
-    dbs: RelationTypes.DBS,
-    cfg: RelationTypes.Relation,
-    data: any,
-    parentList: any[] | null = null
-) {
-    if (!data && !parentList) return;
-
-    const batchMode = Array.isArray(parentList);
-    const targets = batchMode ? parentList : [data];
-
-    for (const key in cfg) {
-        if (!cfg.hasOwnProperty(key)) continue;
-        const rel = cfg[key];
-        const {
-            pk = "_id",
-            fk = "_id",
-            type = "1",
-            path,
-            as = key,
-            select,
-            findOpts = {},
-            through
-        } = rel;
-
-        const [dbKey, coll] = path;
-        const db = dbs[dbKey];
-
-        if (type === "1") {
-            const keys = [...new Set(targets.map(i => i[pk]))];
-            const [selectSafe, deleteSelect] = autoSelect(rel, fk);
-            const results = await db.find(coll, { $in: { [fk]: keys } }, {}, {}, { select: selectSafe });
-
-            const map = new Map(results.map(row => [row[fk], row]));
-
-            for (const item of targets) {
-                const result = map.get(item[pk]) || null;
-                if (result && rel.relations) {
-                    await processRelations(dbs, rel.relations, result);
-                }
-                if (deleteSelect && result) delete result[fk];
-                item[as] = result;
-            }
-
-        } else if (type === "11") {
-            const cache = new Map<string, any>();
-            const [selectSafe, deleteSelect] = autoSelect(rel, fk);
-
-            for (const item of targets) {
-                const id = item[pk];
-                if (!cache.has(id)) {
-                    cache.set(id, await db.findOne(coll, { [fk]: id }, {}, { select: selectSafe }));
-                }
-                const result = cache.get(id) || null;
-                if (result && rel.relations) {
-                    await processRelations(dbs, rel.relations, result);
-                }
-                if (deleteSelect && result) delete result[fk]; 
-                item[as] = result;
-            }
-
-        } else if (type === "1n") {
-            const ids = targets.map(i => i[pk]);
-            const [selectSafe, deleteSelect] = autoSelect(rel, fk);
-            const results = await db.find(coll, { $in: { [fk]: ids } }, {}, findOpts || {}, { select: selectSafe });
-
-            const grouped = results.reduce((acc, row) => {
-                const id = row[fk];
-                (acc[id] ||= []).push(row);
-                return acc;
-            }, {} as Record<string, any[]>);
-
-            for (const item of targets) {
-                item[as] = grouped[item[pk]] || [];
-            }
-
-            if (rel.relations) {
-                await Promise.all(results.map(row => processRelations(dbs, rel.relations!, row)));
-            }
-            if (deleteSelect) for (const r of results) delete r[fk];
-
-        } else if (type === "nm") {
-            if (!through || !through.table || !through.pk || !through.fk) {
-                throw new Error(`Relation type "nm" requires a defined 'through' in '${key}'`);
-            }
-
-            for (const item of targets) {
-                const pivotDb = dbs[through.db || dbKey];
-                const pivots = await pivotDb.find(through.table, { [through.pk]: item[pk] });
-                const ids = pivots.map(p => p[through.fk]);
-                const related = await db.find(coll, { $in: { [fk]: ids } }, {}, {}, { select });
-                item[as] = related;
-
-                if (rel.relations) {
-                    await Promise.all(related.map(row => processRelations(dbs, rel.relations!, row)));
-                }
-            }
-
-        } else {
-            throw new Error(`Unknown relation type: ${type}`);
-        }
-    }
-}
-
-class Relation {
-    constructor(public dbs: RelationTypes.DBS) { }
-
-    async findOne(
-        path: RelationTypes.Path,
-        search: Search,
-        relations: RelationTypes.Relation,
-        select?: string[][] | Record<string, any>
-    ) {
-        const [dbKey, coll] = path;
-        const db = this.dbs[dbKey];
-        const data = await db.findOne(coll, search);
-        if (!data) return null;
-
-        if (typeof select === "object" && !Array.isArray(select)) {
-            select = convertSearchObjToSearchArray(select);
-        }
-
-        await processRelations(this.dbs, relations, data);
-        return select ? pickByPath(data, select as string[][]) : data;
-    }
-
-    async find(
-        path: RelationTypes.Path,
-        search: Search,
-        relations: RelationTypes.Relation,
-        select?: string[][] | Record<string, any>,
-        findOpts: DbFindOpts = {}
-    ) {
-        const [dbKey, coll] = path;
-        const db = this.dbs[dbKey];
-        const data = await db.find(coll, search, {}, findOpts);
-        if (relations) await processRelations(this.dbs, relations, null, data);
-
-        if (typeof select === "object" && !Array.isArray(select)) {
-            select = convertSearchObjToSearchArray(select);
-        }
-
-        return select ? data.map(d => pickByPath(d, select as string[][])) : data;
-    }
-}
-
-export default Relation;

package/src/helpers/updateOneOrAdd.ts

@@ -1,24 +0,0 @@
-import { VQuery } from "../types/query";
-
-function assignDataPush(data: any) {
-    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];
-    }
-    return obj;
-}
-
-export function setDataUsingUpdateOneOrAdd(query: VQuery) {
-    query.data = Object.assign(
-        {},
-        assignDataPush(query.search),
-        assignDataPush(query.updater),
-        assignDataPush(query.add_arg)
-    );
-}