@wxn0brp/db 0.5.7 → 0.7.0

package/README.md

@@ -1,7 +1,11 @@
-# <img src="./logo.svg" alt="ValtheraDB Logo" style="width: 36px; height: 36px"> ValtheraDB (@wxn0brp/db)
+# <img src="./logo.svg" alt="ValtheraDB Logo" width="36" height="36"> ValtheraDB (@wxn0brp/db)
 
 A lightweight file-based database management system that supports CRUD operations, custom queries, and graph structures.
 
+[![npm version](https://img.shields.io/npm/v/@wxn0brp/db)](https://www.npmjs.com/package/@wxn0brp/db)
+[![License](https://img.shields.io/npm/l/@wxn0brp/db)](./LICENSE)
+[![Downloads](https://img.shields.io/npm/dm/@wxn0brp/db)](https://www.npmjs.com/package/@wxn0brp/db)
+
 ## Installation
 
 To install the package, run:
@@ -15,7 +19,35 @@ npm install @wxn0brp/db
 You can import the necessary classes from the package as follows:
 
 ```javascript
-import { DataBase, Graph, DataBaseRemote, GraphRemote, Relation, genId } from "@wxn0brp/db";
+import { Valthera, Graph, ValtheraRemote, GraphRemote, Relation, genId, ValtheraMemory, ValtheraAutoCreate } from "@wxn0brp/db";
+```
+
+### Examples
+```javascript
+import { Valthera } from '@wxn0brp/db';
+
+// Create a new Valthera database instance
+const db = new Valthera('./database');
+
+// Add a new document to the database
+const result = await db.add('users', { name: 'John Doe', age: 30 });
+console.log(result); // { _id: 'xxx', name: 'John Doe', age: 30 }
+
+// Find all documents in the collection
+const results = await db.find('users', {});
+console.log(results); // [{ _id: 'xxx', name: 'John Doe', age: 30 }]
+
+// Find a single document in the collection.
+const user = await db.findOne('users', { $gt: { age: 25 } });
+console.log(user); // { _id: 'xxx', name: 'John Doe', age: 30 }
+
+// Update a document in the collection
+const updateResult = await db.updateOne('users', { name: 'John Doe' }, { age: 31 });
+console.log(updateResult); // true
+
+// Remove a document from the collection
+const removeResult = await db.removeOne('users', { name: 'John Doe' });
+console.log(removeResult); // true
 ```
 
 ## Documentation
@@ -24,10 +56,18 @@ Website: [https://wxn0brp.github.io/ValtheraDB/](https://wxn0brp.github.io/Valth
 
 For detailed information, refer to the following resources:
 
-- [DataBase Documentation](./docs/database.md)
+- [Valthera Documentation](./docs/valthera.md)
 - [Graph Documentation](./docs/graph.md)
-- [Remote Database and Graph Client Documentation](./docs/remote.md)
+- [Remote Valthera and Graph Client Documentation](./docs/remote.md)
 - [Search Options Documentation](./docs/search_opts.md)
 - [Find Options Documentation](./docs/find_opts.md)
 - [Updater Options Documentation](./docs/updater.md)
-- [Relation Documentation](./docs/relation.md)
+- [Relation Documentation](./docs/relation.md)
+
+## License
+
+This project is released under the [MIT License](./LICENSE).
+
+## Contributing
+
+Contributions are welcome! Please submit a pull request or open an issue on our GitHub repository.

package/dist/CollectionManager.d.ts

@@ -1,13 +1,12 @@
-import DataBase from "./database.js";
-import DataBaseRemote from "./client/database.js";
 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 {
-    db: DataBase | DataBaseRemote;
-    collection: string;
-    constructor(db: DataBase | DataBaseRemote, collection: string);
+    private db;
+    private collection;
+    constructor(db: ValtheraCompatible, collection: string);
     /**
      * Add data to a database.
      */

package/dist/autoCreate.d.ts

@@ -1,4 +1,12 @@
-import DataBaseRemote from "./client/database.js";
 import { Remote } from "./client/remote.js";
-import DataBase from "./database.js";
-export declare function autoCreate(cfg: string | Remote): DataBase | DataBaseRemote;
+import { ValtheraCompatible } from "./types/valthera.js";
+/**
+ * Creates a database instance based on the provided configuration.
+ * If the configuration is an object, it creates a DataBaseRemote instance.
+ * If the configuration is a string starting with "http", it also creates a DataBaseRemote instance.
+ * Otherwise, it creates a DataBase instance.
+ *
+ * @param cfg - The configuration object or string for the database.
+ * @returns A new instance of DataBaseRemote or DataBase.
+ */
+export declare function ValtheraAutoCreate(cfg: string | Remote): ValtheraCompatible;

package/dist/autoCreate.js

@@ -1,9 +1,18 @@
-import DataBaseRemote from "./client/database.js";
-import DataBase from "./database.js";
-export function autoCreate(cfg) {
+import ValtheraRemote from "./client/valthera.js";
+import Valthera from "./valthera.js";
+/**
+ * Creates a database instance based on the provided configuration.
+ * If the configuration is an object, it creates a DataBaseRemote instance.
+ * If the configuration is a string starting with "http", it also creates a DataBaseRemote instance.
+ * Otherwise, it creates a DataBase instance.
+ *
+ * @param cfg - The configuration object or string for the database.
+ * @returns A new instance of DataBaseRemote or DataBase.
+ */
+export function ValtheraAutoCreate(cfg) {
     if (typeof cfg === "object")
-        return new DataBaseRemote(cfg);
+        return new ValtheraRemote(cfg);
     if (cfg.startsWith("http"))
-        return new DataBaseRemote(cfg);
-    return new DataBase(cfg);
+        return new ValtheraRemote(cfg);
+    return new Valthera(cfg);
 }

package/dist/client/{database.d.ts → valthera.d.ts}

@@ -5,12 +5,13 @@ import { DbFindOpts, FindOpts } from "../types/options.js";
 import { Context } from "../types/types.js";
 import Data from "../types/data.js";
 import { Transaction } from "../types/transactions.js";
+import { ValtheraCompatible } from "../types/valthera.js";
 /**
  * Represents a database management class for performing CRUD operations.
  * Uses a remote database.
  * @class
  */
-declare class DataBaseRemote {
+declare class ValtheraRemote implements ValtheraCompatible {
     remote: Remote;
     constructor(remote: Remote | string);
     /**
@@ -48,7 +49,7 @@ declare class DataBaseRemote {
     /**
      * Find data in a database as a stream.
      */
-    findStream<T = Data>(collection: string, search: Search, context?: Context, dbFindOpts?: DbFindOpts, findOpts?: FindOpts): Promise<void>;
+    findStream<T = Data>(collection: string, search: Search, context?: Context, findOpts?: FindOpts, limit?: number): Promise<AsyncGenerator<T, any, any>>;
     /**
      * Update data in a database.
      */
@@ -78,4 +79,4 @@ declare class DataBaseRemote {
      */
     transaction(collection: string, transaction: Transaction[]): Promise<boolean>;
 }
-export default DataBaseRemote;
+export default ValtheraRemote;

package/dist/client/{database.js → valthera.js}

@@ -6,7 +6,7 @@ import serializeFunctions from "./function.js";
  * Uses a remote database.
  * @class
  */
-class DataBaseRemote {
+class ValtheraRemote {
     remote;
     constructor(remote) {
         if (typeof remote === "string") {
@@ -96,8 +96,9 @@ class DataBaseRemote {
     /**
      * Find data in a database as a stream.
      */
-    async findStream(collection, search, context = {}, dbFindOpts = {}, findOpts = {}) {
+    async findStream(collection, search, context = {}, findOpts = {}, limit = -1) {
         throw new Error("Method not implemented.");
+        return await this._request("findStream", [collection, search, context, findOpts, limit]);
     }
     /**
      * Update data in a database.
@@ -142,4 +143,4 @@ class DataBaseRemote {
         return await this._request("transaction", [collection, transaction]);
     }
 }
-export default DataBaseRemote;
+export default ValtheraRemote;

package/dist/graph.d.ts

@@ -1,11 +1,11 @@
-import DataBase from "./database.js";
+import Valthera from "./valthera.js";
 import Data from "./types/data.js";
 /**
  * A class representing a graph database.
  * @class
  */
 declare class Graph {
-    db: DataBase;
+    db: Valthera;
     constructor(databaseFolder: string);
     /**
      * Adds an edge between two nodes.

package/dist/graph.js

@@ -1,4 +1,4 @@
-import DataBase from "./database.js";
+import Valthera from "./valthera.js";
 /**
  * A class representing a graph database.
  * @class
@@ -6,7 +6,7 @@ import DataBase from "./database.js";
 class Graph {
     db;
     constructor(databaseFolder) {
-        this.db = new DataBase(databaseFolder);
+        this.db = new Valthera(databaseFolder);
     }
     /**
      * Adds an edge between two nodes.

package/dist/index.d.ts

@@ -1,13 +1,17 @@
-import DataBase from "./database.js";
+import Valthera from "./valthera.js";
 import Graph from "./graph.js";
-import DataBaseRemote from "./client/database.js";
+import ValtheraRemote from "./client/valthera.js";
 import GraphRemote from "./client/graph.js";
 import genId from "./gen.js";
 import Relation from "./relation.js";
 import CustomFileCpu from "./file/customFileCpu.js";
 import ValtheraMemory, { createMemoryValthera } from "./memory.js";
-import { autoCreate } from "./autoCreate.js";
-export { DataBase as Valthera, Graph, DataBaseRemote as ValtheraRemote, GraphRemote, Relation, genId, CustomFileCpu, ValtheraMemory, createMemoryValthera, autoCreate, };
+import { ValtheraAutoCreate } from "./autoCreate.js";
+import { RelationTypes } from "./types/relation.js";
+import { ValtheraCompatible } from "./types/valthera.js";
+export { Valthera, Graph, ValtheraRemote, GraphRemote, Relation, genId, CustomFileCpu, ValtheraMemory, createMemoryValthera, ValtheraAutoCreate, };
+type GraphCompatible = Graph | GraphRemote;
+export type { ValtheraCompatible, RelationTypes, GraphCompatible, };
 export type Id = import("./types/Id.js").Id;
 export declare namespace ValtheraTypes {
     type Arg = import("./types/arg.js").Arg;
@@ -19,5 +23,3 @@ export declare namespace ValtheraTypes {
     type Data = import("./types/data.js").Data;
     type SearchOptions = import("./types/searchOpts.js").SearchOptions;
 }
-import type { RelationTypes } from "./types/relation.js";
-export type { RelationTypes };

package/dist/index.js

@@ -1,10 +1,10 @@
-import DataBase from "./database.js";
+import Valthera from "./valthera.js";
 import Graph from "./graph.js";
-import DataBaseRemote from "./client/database.js";
+import ValtheraRemote from "./client/valthera.js";
 import GraphRemote from "./client/graph.js";
 import genId from "./gen.js";
 import Relation from "./relation.js";
 import CustomFileCpu from "./file/customFileCpu.js";
 import ValtheraMemory, { createMemoryValthera } from "./memory.js";
-import { autoCreate } from "./autoCreate.js";
-export { DataBase as Valthera, Graph, DataBaseRemote as ValtheraRemote, GraphRemote, Relation, genId, CustomFileCpu, ValtheraMemory, createMemoryValthera, autoCreate, };
+import { ValtheraAutoCreate } from "./autoCreate.js";
+export { Valthera, Graph, ValtheraRemote, GraphRemote, Relation, genId, CustomFileCpu, ValtheraMemory, createMemoryValthera, ValtheraAutoCreate, };

package/dist/memory.d.ts

@@ -1,5 +1,5 @@
 import dbActionC from "./action.js";
-import DataBase from "./database.js";
+import Valthera from "./valthera.js";
 import { Arg, Search, Updater } from "./types/arg.js";
 import Data from "./types/data.js";
 import FileCpu from "./types/fileCpu.js";
@@ -76,7 +76,7 @@ export declare class MemoryAction implements dbActionC {
      */
     transaction(collection: string, transactions: Transaction[]): Promise<void>;
 }
-export default class ValtheraMemory extends DataBase {
+export default class ValtheraMemory extends Valthera {
     constructor(...args: any[]);
 }
 export declare function createMemoryValthera<T = {

package/dist/memory.js

@@ -1,4 +1,4 @@
-import DataBase from "./database.js";
+import Valthera from "./valthera.js";
 import CustomFileCpu from "./file/customFileCpu.js";
 import genId from "./gen.js";
 export class MemoryAction {
@@ -128,7 +128,7 @@ export class MemoryAction {
         throw new Error("Method not supported in memory.");
     }
 }
-export default class ValtheraMemory extends DataBase {
+export default class ValtheraMemory extends Valthera {
     constructor(...args) {
         super("", { dbAction: new MemoryAction() });
     }

package/dist/relation.d.ts

@@ -4,7 +4,7 @@ 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?: RelationTypes.FieldPath[]): Promise<any>;
-    find(path: RelationTypes.Path, search: Search, relations: RelationTypes.Relation, select?: RelationTypes.FieldPath[], findOpts?: DbFindOpts): Promise<any[]>;
+    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/relation.js

@@ -1,85 +1,118 @@
-async function processRelations(dbs, cfg, data) {
-    if (!data)
+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 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;
-    for (const [key, relation] of Object.entries(cfg)) {
-        const { pk = "_id", fk = "_id", type = "1" } = relation;
+    const batchMode = Array.isArray(parentList);
+    const targets = batchMode ? parentList : [data];
+    for (const [key, rel] of Object.entries(cfg)) {
+        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 db = dbs[relation.path[0]];
-            const collection = relation.path[1];
-            const item = await db.findOne(collection, { [fk]: data[pk] }, {}, { select: relation.select || null });
-            const field = relation.as || key;
-            if (!item) {
-                data[field] = null;
-                continue;
-            }
-            if (relation.relations) {
-                await processRelations(dbs, relation.relations, item);
+            for (const item of targets) {
+                const result = await db.findOne(coll, { [fk]: item[pk] }, { projection: select });
+                if (result && rel.relations) {
+                    await processRelations(dbs, rel.relations, result);
+                }
+                item[as] = result || null;
             }
-            data[field] = item;
         }
         else if (type === "1n") {
-            const db = dbs[relation.path[0]];
-            const collection = relation.path[1];
-            const items = await db.find(collection, { [fk]: data[pk] }, {}, relation.findOpts || {}, { select: relation.select || null });
-            const field = relation.as || key;
-            if (relation.relations) {
-                await Promise.all(items.map(item => processRelations(dbs, relation.relations, item)));
+            const ids = targets.map(i => i[pk]);
+            const results = await db.find(coll, { [fk]: { $in: ids } }, { ...findOpts, projection: select });
+            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)));
             }
-            data[field] = items;
         }
         else if (type === "nm") {
-            const db = dbs[relation.path[0]];
-            const collection = relation.path[1];
-            const items = await db.find(collection, {}, {}, {}, { select: relation.select || null });
-            const field = relation.as || key;
-            if (relation.relations) {
-                await Promise.all(items.map(item => processRelations(dbs, relation.relations, item)));
+            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, { [fk]: { $in: ids } }, { projection: select });
+                item[as] = related;
+                if (rel.relations) {
+                    await Promise.all(related.map(row => processRelations(dbs, rel.relations, row)));
+                }
             }
-            data[field] = items;
         }
         else {
-            throw new Error(`Unknown relation type: ${relation.type}`);
+            throw new Error(`Unknown relation type: ${type}`);
         }
     }
 }
-function selectDataSelf(data, select) {
-    if (!data)
-        return null;
-    if (!select || select.length === 0)
-        return data;
-    if (Array.isArray(data))
-        return data.map(item => selectDataSelf(item, select));
-    return selectDataSelf(data[select[0]], select.slice(1));
-}
-function selectData(data, select) {
-    if (!select)
-        return data;
-    if (!data && select.length === 0)
-        return null;
-    const newData = {};
-    for (const field of select) {
-        const key = field.map(f => f.replaceAll(".", "\\.")).join(".");
-        newData[key] = selectDataSelf(data, field);
-    }
-    return newData;
-}
 class Relation {
     dbs;
     constructor(dbs) {
         this.dbs = dbs;
     }
     async findOne(path, search, relations, select) {
-        const db = this.dbs[path[0]];
-        const data = await db.findOne(path[1], search);
+        const [dbKey, coll] = path;
+        const db = this.dbs[dbKey];
+        const data = await db.findOne(coll, search);
+        if (!data)
+            return null;
+        if (typeof select === "object") {
+            select = convertSearchObjToSearchArray(select);
+        }
         await processRelations(this.dbs, relations, data);
-        const result = selectData(data, select);
-        return Object.keys(result).length === 0 ? null : result;
+        return select ? pickByPath(data, select) : data;
     }
     async find(path, search, relations, select, findOpts = {}) {
-        const db = this.dbs[path[0]];
-        const data = await db.find(path[1], search, {}, findOpts);
-        await Promise.all(data.map(item => processRelations(this.dbs, relations, item)));
-        return data.map(item => selectData(item, select));
+        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") {
+            select = convertSearchObjToSearchArray(select);
+        }
+        return select ? data.map(d => pickByPath(d, select)) : data;
     }
 }
 export default Relation;

package/dist/types/relation.d.ts

@@ -1,11 +1,10 @@
-import DataBaseRemote from "../client/database.js";
-import DataBase from "../database.js";
 import { DbFindOpts } from "./options.js";
+import { ValtheraCompatible } from "./valthera.js";
 export declare namespace RelationTypes {
     type Path = [string, string];
     type FieldPath = string[];
     interface DBS {
-        [key: string]: DataBase | DataBaseRemote;
+        [key: string]: ValtheraCompatible;
     }
     interface Relation {
         [key: string]: RelationConfig;
@@ -19,5 +18,11 @@ export declare namespace RelationTypes {
         findOpts?: DbFindOpts;
         type?: "1" | "1n" | "nm";
         relations?: Relation;
+        through?: {
+            table: string;
+            db?: string;
+            pk: string;
+            fk: string;
+        };
     }
 }

package/dist/types/valthera.d.ts

@@ -0,0 +1,23 @@
+import CollectionManager from "../CollectionManager.js";
+import { Arg, Search, Updater } from "./arg.js";
+import Data from "./data.js";
+import { DbFindOpts, FindOpts } from "./options.js";
+import { Transaction } from "./transactions.js";
+import { Context } from "./types.js";
+export interface ValtheraCompatible {
+    c(collection: string): CollectionManager;
+    getCollections(): Promise<string[]>;
+    checkCollection(collection: string): Promise<boolean>;
+    issetCollection(collection: string): Promise<boolean>;
+    add<T = Data>(collection: string, data: Arg, id_gen?: boolean): Promise<T>;
+    find<T = Data>(collection: string, search: Search, context?: Context, options?: DbFindOpts, findOpts?: FindOpts): Promise<T[]>;
+    findOne<T = Data>(collection: string, search: Search, context?: Context, findOpts?: FindOpts): Promise<T | null>;
+    findStream<T = Data>(collection: string, search: Search, context?: Context, findOpts?: FindOpts, limit?: number): Promise<AsyncGenerator<T>>;
+    update(collection: string, search: Search, updater: Updater, context?: Context): Promise<boolean>;
+    updateOne(collection: string, search: Search, updater: Updater, context?: Context): Promise<boolean>;
+    remove(collection: string, search: Search, context?: Context): Promise<boolean>;
+    removeOne(collection: string, search: Search, context?: Context): Promise<boolean>;
+    removeCollection(collection: string): Promise<boolean>;
+    transaction(collection: string, transaction: Transaction[]): Promise<boolean>;
+    updateOneOrAdd(collection: string, search: Search, updater: Updater, add_arg?: Arg, context?: Context, id_gen?: boolean): Promise<boolean>;
+}

package/dist/types/valthera.js

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

package/dist/{database.d.ts → valthera.d.ts}

@@ -8,11 +8,12 @@ import { Context } from "./types/types.js";
 import FileCpu from "./types/fileCpu.js";
 import { Transaction } from "./types/transactions.js";
 import { EventEmitter } from "events";
+import { ValtheraCompatible } from "./types/valthera.js";
 /**
  * Represents a database management class for performing CRUD operations.
  * @class
  */
-declare class DataBase {
+declare class Valthera implements ValtheraCompatible {
     dbAction: dbActionC;
     executor: executorC;
     emiter: EventEmitter;
@@ -79,4 +80,4 @@ declare class DataBase {
      */
     transaction(collection: string, transaction: Transaction[]): Promise<boolean>;
 }
-export default DataBase;
+export default Valthera;

package/dist/{database.js → valthera.js}

@@ -7,7 +7,7 @@ import { EventEmitter } from "events";
  * Represents a database management class for performing CRUD operations.
  * @class
  */
-class DataBase {
+class Valthera {
     dbAction;
     executor;
     emiter;
@@ -140,4 +140,4 @@ class DataBase {
         return await this.execute("transaction", collection, transaction);
     }
 }
-export default DataBase;
+export default Valthera;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/db",
-  "version": "0.5.7",
+  "version": "0.7.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "description": "A simple file-based database management system with support for CRUD operations, custom queries, and graph structures.",