@wxn0brp/db 0.0.5 → 0.0.7

package/dist/esm/gen.js

@@ -0,0 +1,75 @@
+const usedIdsMap = new Map();
+/**
+ * Generates a unique identifier based on specified parts.
+ */
+export default 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/esm/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;

package/dist/esm/graph.js

@@ -0,0 +1,85 @@
+import DataBase from "./database.js";
+/**
+ * A class representing a graph database.
+ * @class
+ */
+class Graph {
+    db;
+    constructor(databaseFolder) {
+        this.db = new DataBase(databaseFolder);
+    }
+    /**
+     * Adds an edge between two nodes.
+     */
+    async add(collection, nodeA, nodeB) {
+        const sortedNodes = [nodeA, nodeB].sort();
+        return await this.db.add(collection, {
+            a: sortedNodes[0],
+            b: sortedNodes[1]
+        }, false);
+    }
+    /**
+     * Removes an edge between two nodes.
+     */
+    async remove(collection, nodeA, nodeB) {
+        const sortedNodes = [nodeA, nodeB].sort();
+        const query = { a: sortedNodes[0], b: sortedNodes[1] };
+        return await this.db.removeOne(collection, query);
+    }
+    /**
+     * Finds all edges with either node equal to `node`.
+     */
+    async find(collection, node) {
+        const edges = [];
+        const edgesByANode = await this.db.find(collection, { a: node });
+        const edgesByBNode = await this.db.find(collection, { b: node });
+        if (edgesByANode)
+            edges.push(...edgesByANode);
+        if (edgesByBNode)
+            edges.push(...edgesByBNode);
+        return edges;
+    }
+    /**
+     * Finds one edge with either node equal to `nodeA` and the other equal to `nodeB`.
+     */
+    async findOne(collection, nodeA, nodeB) {
+        const edgeAB = await this.db.findOne(collection, { a: nodeA, b: nodeB });
+        if (edgeAB)
+            return edgeAB;
+        const edgeBA = await this.db.findOne(collection, { a: nodeB, b: nodeA });
+        if (edgeBA)
+            return edgeBA;
+        return null;
+    }
+    /**
+     * Gets all edges in the database.
+     */
+    async getAll(collection) {
+        return await this.db.find(collection, {});
+    }
+    /**
+     * Get the names of all available databases.
+     */
+    async getCollections() {
+        return await this.db.getCollections();
+    }
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    async checkCollection(collection) {
+        await this.db.checkCollection(collection);
+    }
+    /**
+     * Check if a collection exists.
+     */
+    async issetCollection(collection) {
+        return await this.db.issetCollection(collection);
+    }
+    /**
+     * Removes a database collection from the file system.
+     */
+    removeCollection(collection) {
+        this.db.removeCollection(collection);
+    }
+}
+export default Graph;

package/dist/esm/index.d.ts

@@ -0,0 +1,13 @@
+import DataBase from "./database.js";
+import Graph from "./graph.js";
+import DataBaseRemote from "./client/database.js";
+import GraphRemote from "./client/graph.js";
+import genId from "./gen.js";
+import Relation from "./relation.js";
+export { DataBase, Graph, DataBaseRemote, GraphRemote, Relation, genId };
+import type Id from "./types/Id.js";
+import type { Arg, Search, Updater } from "./types/arg.js";
+import type { DbFindOpts, FindOpts, DbOpts } from "./types/options.js";
+import type Data from "./types/data.js";
+import type { SearchOptions } from "./types/searchOpts.js";
+export type { Id, Arg, Search, Updater, DbFindOpts, FindOpts, DbOpts, Data, SearchOptions };

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+import DataBase from "./database.js";
+import Graph from "./graph.js";
+import DataBaseRemote from "./client/database.js";
+import GraphRemote from "./client/graph.js";
+import genId from "./gen.js";
+import Relation from "./relation.js";
+export { DataBase, Graph, DataBaseRemote, GraphRemote, Relation, genId };

package/dist/esm/relation.d.ts

@@ -0,0 +1,64 @@
+import DataBase from "./database.js";
+import { Search } from "./types/arg.js";
+import { DbFindOpts } from "./types/options.js";
+export interface Databases {
+    [key: string]: DataBase;
+}
+declare class Relation {
+    databases: Databases;
+    constructor(databases: Databases);
+    /**
+    * Resolves the relation path in format 'dbName.collectionName'
+    */
+    _resolvePath(path: string): {
+        db: DataBase;
+        collection: string;
+    };
+    /**
+     * Processes relations for a single item
+     * @param {Object} item - Item to process relations for
+     * @param {Object} relations - Relations configuration
+     * @returns {Promise<Object>} Processed item with resolved relations
+     */
+    _processItemRelations(item: Object, relations: Object): Promise<{
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+    }>;
+    /**
+     * Finds items with relations
+     * @param path - Path in format 'dbName.collectionName'
+     * @param search - Search query or function
+     * @param relations - Relations configuration
+     * @param options - Search options
+     */
+    find(path: string, search: Search, relations?: {}, options?: DbFindOpts): Promise<{
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+    }[]>;
+    /**
+     * Finds one item with relations
+     * @param path - Path in format 'dbName.collectionName'
+     * @param search - Search query or function
+     * @param relations - Relations configuration
+     */
+    findOne(path: string, search: Search, relations?: Object): Promise<{
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+    }>;
+}
+export default Relation;

package/dist/esm/relation.js

@@ -0,0 +1,65 @@
+class Relation {
+    databases;
+    constructor(databases) {
+        this.databases = databases;
+    }
+    /**
+    * Resolves the relation path in format 'dbName.collectionName'
+    */
+    _resolvePath(path) {
+        const sanitizedPath = path.replace(/\\\./g, '\uffff');
+        const separatorIndex = sanitizedPath.indexOf('.');
+        if (separatorIndex === -1)
+            throw new Error(`Invalid path format "${path}". Expected format 'dbName.collectionName'.`);
+        const dbName = sanitizedPath.slice(0, separatorIndex).replace(/\uffff/g, '.');
+        const collectionName = sanitizedPath.slice(separatorIndex + 1).replace(/\uffff/g, '.');
+        if (!this.databases[dbName])
+            throw new Error(`Database "${dbName}" not found`);
+        return { db: this.databases[dbName], collection: collectionName };
+    }
+    /**
+     * Processes relations for a single item
+     * @param {Object} item - Item to process relations for
+     * @param {Object} relations - Relations configuration
+     * @returns {Promise<Object>} Processed item with resolved relations
+     */
+    async _processItemRelations(item, relations) {
+        const result = { ...item };
+        for (const [field, relationConfig] of Object.entries(relations)) {
+            const { from, localField, foreignField, as, multiple = false } = relationConfig;
+            const { db, collection } = this._resolvePath(from);
+            const searchQuery = { [foreignField]: item[localField] };
+            const fn = multiple ? db.find : db.findOne;
+            const relatedItem = await fn(collection, searchQuery);
+            result[as || field] = relatedItem;
+        }
+        return result;
+    }
+    /**
+     * Finds items with relations
+     * @param path - Path in format 'dbName.collectionName'
+     * @param search - Search query or function
+     * @param relations - Relations configuration
+     * @param options - Search options
+     */
+    async find(path, search, relations = {}, options = {}) {
+        const { db, collection } = this._resolvePath(path);
+        const items = await db.find(collection, search, {}, options);
+        const results = await Promise.all(items.map(item => this._processItemRelations(item, relations)));
+        return results;
+    }
+    /**
+     * Finds one item with relations
+     * @param path - Path in format 'dbName.collectionName'
+     * @param search - Search query or function
+     * @param relations - Relations configuration
+     */
+    async findOne(path, search, relations = {}) {
+        const { db, collection } = this._resolvePath(path);
+        const item = await db.findOne(collection, search);
+        if (!item)
+            return null;
+        return await this._processItemRelations(item, relations);
+    }
+}
+export default Relation;

package/dist/esm/types/Id.d.ts

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

package/dist/esm/types/Id.js

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

package/dist/esm/types/arg.d.ts

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

package/dist/esm/types/arg.js

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

package/dist/esm/types/data.d.ts

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

package/dist/esm/types/data.js

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

package/dist/esm/types/options.d.ts

@@ -0,0 +1,12 @@
+export interface DbOpts {
+    maxFileSize?: number;
+}
+export interface DbFindOpts {
+    reverse?: boolean;
+    max?: number;
+}
+export interface FindOpts {
+    select?: string[];
+    exclude?: string[];
+    transform?: Function;
+}

package/dist/esm/types/options.js

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

package/dist/esm/types/searchOpts.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Predefined Search Options Quick Reference
+ *
+ * This module defines the types and structures for search operators used
+ * to validate and query data objects.
+ */
+/** Logical Operators */
+export type LogicalOperators = {
+    /**
+     * Recursively applies multiple conditions, all of which must evaluate to true.
+     * Can include other operators such as $gt, $exists, or nested $and/$or conditions.
+     */
+    $and?: Array<PredefinedSearchOperators>;
+    /**
+     * Recursively applies multiple conditions, at least one of which must evaluate to true.
+     * Can include other operators such as $lt, $type, or nested $and/$or conditions.
+     */
+    $or?: Array<PredefinedSearchOperators>;
+    /**
+     * Negates a single condition.
+     * Can include any other operator as its value.
+     */
+    $not?: PredefinedSearchOperators;
+};
+/** Comparison Operators */
+export type ComparisonOperators = {
+    $gt?: Record<string, number>;
+    $lt?: Record<string, number>;
+    $gte?: Record<string, number>;
+    $lte?: Record<string, number>;
+    $in?: Record<string, any[]>;
+    $nin?: Record<string, any[]>;
+    $between?: Record<string, [number, number]>;
+};
+/** Type and Existence Operators */
+export type TypeAndExistenceOperators = {
+    $exists?: Record<string, boolean>;
+    $type?: Record<string, string>;
+};
+/** Array Operators */
+export type ArrayOperators = {
+    $arrinc?: Record<string, any[]>;
+    $arrincall?: Record<string, any[]>;
+    $size?: Record<string, number>;
+};
+/** String Operators */
+export type StringOperators = {
+    $regex?: Record<string, RegExp>;
+    $startsWith?: Record<string, string>;
+    $endsWith?: Record<string, string>;
+};
+/** Other Operators */
+export type OtherOperators = {
+    $subset?: Record<string, any>;
+};
+/** Predefined Search Operators */
+export type PredefinedSearchOperators = LogicalOperators & ComparisonOperators & TypeAndExistenceOperators & ArrayOperators & StringOperators & OtherOperators;
+/**
+ * SearchOptions can be either a function or an object with predefined operators.
+ */
+export type SearchOptions = PredefinedSearchOperators | ((doc: Record<string, any>) => boolean);

package/dist/esm/types/searchOpts.js

@@ -0,0 +1,7 @@
+/**
+ * Predefined Search Options Quick Reference
+ *
+ * This module defines the types and structures for search operators used
+ * to validate and query data objects.
+ */
+export {};

package/dist/esm/types/types.d.ts

@@ -0,0 +1,6 @@
+export interface Context {
+}
+export interface SortedFiles {
+    i: number;
+    f: string;
+}

package/dist/esm/types/types.js

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

package/dist/esm/types/updater.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Predefined type for updating data.
+ */
+/** Arrays */
+export type ArrayUpdater = {
+    $push?: any;
+    /** Pushes items into an array and removes duplicates */
+    $pushset?: any;
+    $pull?: any;
+    $pullall?: any;
+};
+/** Objects */
+export type ObjectUpdater = {
+    $merge?: any;
+};
+/** Values */
+export type ValueUpdater = {
+    $set?: any;
+    $inc?: any;
+    $dec?: any;
+    $unset?: any;
+    $rename?: any;
+};
+export type UpdaterArg = ArrayUpdater & ObjectUpdater & ValueUpdater & {
+    [key: string]: any;
+};

package/dist/esm/types/updater.js

@@ -0,0 +1,4 @@
+/**
+ * Predefined type for updating data.
+ */
+export {};

package/dist/esm/utils/hasFields.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Checks if an object matches the standard field comparison.
+ * @function
+ * @param {Object} obj - The object to check.
+ * @param {Object} fields - Criteria to compare.
+ * @returns {boolean} - Whether the object matches the criteria.
+ */
+export default function hasFields(obj: any, fields: any): any;

package/{utils → dist/esm/utils}/hasFields.js

@@ -5,15 +5,15 @@
  * @param {Object} fields - Criteria to compare.
  * @returns {boolean} - Whether the object matches the criteria.
  */
-export default function hasFields(obj, fields){
+export default function hasFields(obj, fields) {
     const keys = Object.keys(fields);
     return keys.every(key => {
-        if(obj[key] !== undefined){
-            if(typeof fields[key] === "object" && fields[key] !== null){
+        if (obj[key] !== undefined) {
+            if (typeof fields[key] === "object" && fields[key] !== null) {
                 return hasFields(obj[key], fields[key]);
             }
             return obj[key] === fields[key];
         }
         return false;
     });
-}
+}

package/dist/esm/utils/hasFieldsAdvanced.d.ts

@@ -0,0 +1,5 @@
+import { Arg } from "../types/arg";
+/**
+ * Checks if an object meets the criteria specified in the fields with operators.
+ */
+export default function hasFieldsAdvanced(obj: Object, fields: Arg): any;