@wxn0brp/db 0.10.0 → 0.20.1

package/dist/file/utils.js

@@ -1,84 +0,0 @@
-import { createReadStream } from "fs";
-/**
- * Repairs a file path by replacing double slashes
- */
-export function pathRepair(path) {
-    return path.replaceAll("//", "/");
-}
-export function createRL(file) {
-    const stream = createReadStream(file, { highWaterMark: 64 * 1024 });
-    let buffer = "";
-    let done = false;
-    let error = null;
-    const lines = [];
-    let waiting = null;
-    stream.on("data", (chunk) => {
-        buffer += chunk.toString("utf8");
-        let index;
-        while ((index = buffer.search(/\r?\n/)) >= 0) {
-            const line = buffer.slice(0, index);
-            lines.push(line);
-            buffer = buffer.slice(index + (buffer[index] === "\r" && buffer[index + 1] === "\n" ? 2 : 1));
-        }
-        feed();
-    });
-    stream.on("end", () => {
-        if (buffer.length > 0) {
-            lines.push(buffer);
-            buffer = "";
-        }
-        done = true;
-        feed();
-    });
-    stream.on("error", (err) => {
-        error = err;
-        done = true;
-        feed();
-    });
-    const feed = () => {
-        if (waiting) {
-            if (error) {
-                waiting(Promise.reject(error));
-            }
-            else if (lines.length > 0) {
-                waiting({ value: lines.shift(), done: false });
-            }
-            else if (done) {
-                waiting({ value: undefined, done: true });
-            }
-            else {
-                return;
-            }
-            waiting = null;
-        }
-    };
-    const iterator = {
-        next() {
-            if (error)
-                return Promise.reject(error);
-            if (lines.length > 0)
-                return Promise.resolve({ value: lines.shift(), done: false });
-            if (done)
-                return Promise.resolve({ value: undefined, done: true });
-            return new Promise(res => {
-                waiting = res;
-            });
-        },
-        return() {
-            rl.close();
-            return Promise.resolve({ value: undefined, done: true });
-        }
-    };
-    const rl = {
-        [Symbol.asyncIterator]() {
-            return iterator;
-        },
-        close() {
-            if (!done) {
-                done = true;
-                stream.destroy();
-            }
-        }
-    };
-    return rl;
-}

package/dist/helpers/CollectionManager.d.ts

@@ -1,43 +0,0 @@
-import { Arg, Search, Updater } from "../types/arg.js";
-import { DbFindOpts, FindOpts } from "../types/options.js";
-import { Context } 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?: Context, options?: DbFindOpts, findOpts?: FindOpts): Promise<T[]>;
-    /**
-     * Find one data entry in a database.
-     */
-    findOne<T = Data>(search: Search, context?: Context, findOpts?: FindOpts): Promise<T>;
-    /**
-     * Update data in a database.
-     */
-    update(search: Search, updater: Updater, context?: Context): Promise<boolean>;
-    /**
-     * Update one data entry in a database.
-     */
-    updateOne(search: Search, updater: Updater, context?: Context): Promise<boolean>;
-    /**
-     * Remove data from a database.
-     */
-    remove(search: Search, context?: Context): Promise<boolean>;
-    /**
-     * Remove one data entry from a database.
-     */
-    removeOne(search: Search, context?: Context): 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?: Context, id_gen?: boolean): Promise<boolean>;
-}
-export default CollectionManager;

package/dist/helpers/CollectionManager.js

@@ -1,57 +0,0 @@
-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/executor.d.ts

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

@@ -1,45 +0,0 @@
-/**
- * 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/format.d.ts

@@ -1,12 +0,0 @@
-/**
- * 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.
- */
-export declare function parse(data: string): 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 {}.
- */
-export declare function stringify(data: any): any;

package/dist/helpers/format.js

@@ -1,23 +0,0 @@
-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.
- */
-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 {}.
- */
-export function stringify(data) {
-    data = json5.stringify(data);
-    if (data.startsWith("{")) {
-        data = data.slice(1, -1);
-    }
-    return data;
-}

package/dist/helpers/gen.d.ts

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

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

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

package/dist/helpers/relation.js

@@ -1,155 +0,0 @@
-function pickByPath(obj, paths) {
-    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, key) {
-    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, parentKeys = []) {
-    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, cfg, data, parentList = 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();
-            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;
-            }, {});
-            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 {
-    dbs;
-    constructor(dbs) {
-        this.dbs = dbs;
-    }
-    async findOne(path, search, relations, select) {
-        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) : data;
-    }
-    async find(path, search, relations, select, findOpts = {}) {
-        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)) : data;
-    }
-}
-export default Relation;

package/dist/helpers/updateOneOrAdd.d.ts

@@ -1,2 +0,0 @@
-import { VQuery } from "../types/query.js";
-export declare function setDataUsingUpdateOneOrAdd(query: VQuery): void;

package/dist/helpers/updateOneOrAdd.js

@@ -1,18 +0,0 @@
-function assignDataPush(data) {
-    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) {
-    query.data = Object.assign({}, assignDataPush(query.search), assignDataPush(query.updater), assignDataPush(query.add_arg));
-}

package/dist/types/Id.d.ts

@@ -1,3 +0,0 @@
-type Id = string;
-export default Id;
-export { Id };

package/dist/types/Id.js

@@ -1 +0,0 @@
-export {};

package/dist/types/arg.d.ts

@@ -1,12 +0,0 @@
-import Id from "./Id.js";
-import { SearchOptions } from "./searchOpts.js";
-import { Context } from "./types.js";
-import { UpdaterArg } from "./updater.js";
-export interface Arg {
-    _id?: Id;
-    [key: string]: any;
-}
-export type SearchFunc<T = any> = (data: T, context: Context) => boolean;
-export type UpdaterFunc<T = any> = (data: T, context: Context) => boolean;
-export type Search<T = any> = SearchOptions | SearchFunc<T>;
-export type Updater<T = any> = UpdaterArg | UpdaterArg[] | UpdaterFunc<T>;

package/dist/types/arg.js

@@ -1 +0,0 @@
-export {};

package/dist/types/data.d.ts

@@ -1,4 +0,0 @@
-export interface Data {
-    [key: string]: any;
-}
-export default Data;

package/dist/types/data.js

@@ -1 +0,0 @@
-export {};

package/dist/types/export.d.ts

@@ -1,11 +0,0 @@
-export declare namespace ValtheraTypes {
-    type Arg = import("./arg.js").Arg;
-    type Search = import("./arg.js").Search;
-    type Updater = import("./arg.js").Updater;
-    type DbFindOpts = import("./options.js").DbFindOpts;
-    type FindOpts = import("./options.js").FindOpts;
-    type DbOpts = import("./options.js").DbOpts;
-    type Data = import("./data.js").Data;
-    type SearchOptions = import("./searchOpts.js").SearchOptions;
-    type Id = import("./Id.js").Id;
-}

package/dist/types/export.js

@@ -1 +0,0 @@
-export {};