@wxn0brp/db 0.4.2 → 0.5.1

package/dist/database.d.ts

@@ -7,7 +7,7 @@ import Data from "./types/data.js";
 import { Context } from "./types/types.js";
 import FileCpu from "./types/fileCpu.js";
 import { Transaction } from "./types/transactions.js";
-import EventEmitter from "events";
+import { EventEmitter } from "events";
 /**
  * Represents a database management class for performing CRUD operations.
  * @class

package/dist/database.js

@@ -2,7 +2,7 @@ import dbActionC from "./action.js";
 import executorC from "./executor.js";
 import CollectionManager from "./CollectionManager.js";
 import vFileCpu from "./file/index.js";
-import EventEmitter from "events";
+import { EventEmitter } from "events";
 /**
  * Represents a database management class for performing CRUD operations.
  * @class

package/dist/index.d.ts

@@ -5,11 +5,18 @@ import GraphRemote from "./client/graph.js";
 import genId from "./gen.js";
 import Relation from "./relation.js";
 import CustomFileCpu from "./file/customFileCpu.js";
-import ValtheraMemory from "./memory.js";
-export { DataBase, DataBase as Valthera, Graph, DataBaseRemote, DataBaseRemote as ValtheraRemote, GraphRemote, Relation, genId, CustomFileCpu, ValtheraMemory, };
-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, };
+import ValtheraMemory, { createMemoryValthera } from "./memory.js";
+export { DataBase as Valthera, Graph, DataBaseRemote as ValtheraRemote, GraphRemote, Relation, genId, CustomFileCpu, ValtheraMemory, createMemoryValthera };
+export type Id = import("./types/Id.js").Id;
+export declare namespace ValtheraTypes {
+    type Arg = import("./types/arg.js").Arg;
+    type Search = import("./types/arg.js").Search;
+    type Updater = import("./types/arg.js").Updater;
+    type DbFindOpts = import("./types/options.js").DbFindOpts;
+    type FindOpts = import("./types/options.js").FindOpts;
+    type DbOpts = import("./types/options.js").DbOpts;
+    type Data = import("./types/data.js").Data;
+    type SearchOptions = import("./types/searchOpts.js").SearchOptions;
+}
+import type { RelationTypes } from "./relation.js";
+export type { RelationTypes };

package/dist/index.js

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

package/dist/memory.d.ts

@@ -1,4 +1,8 @@
 import DataBase from "./database.js";
+import Data from "./types/data.js";
 export default class ValtheraMemory extends DataBase {
     constructor(...args: any[]);
 }
+export declare function createMemoryValthera(data?: {
+    [key: string]: Data[];
+}): ValtheraMemory;

package/dist/memory.js

@@ -127,3 +127,12 @@ export default class ValtheraMemory extends DataBase {
         super("", { dbAction: new MemoryAction() });
     }
 }
+export function createMemoryValthera(data) {
+    const db = new ValtheraMemory();
+    if (!data)
+        return db;
+    for (const collection of Object.keys(data)) {
+        db.dbAction.memory.set(collection, data[collection]);
+    }
+    return db;
+}

package/dist/relation.d.ts

@@ -1,34 +1,30 @@
 import DataBase from "./database.js";
 import { Search } from "./types/arg.js";
 import { DbFindOpts } from "./types/options.js";
-export interface Databases {
-    [key: string]: DataBase;
-}
-interface RelationConfig {
-    from: string;
-    localField: string;
-    foreignField: string;
-    as?: string;
-    multiple?: boolean;
+export declare namespace RelationTypes {
+    type Path = [string, string];
+    type FieldPath = string[];
+    interface DBS {
+        [key: string]: DataBase;
+    }
+    interface Relation {
+        [key: string]: RelationConfig;
+    }
+    interface RelationConfig {
+        path: Path;
+        pk?: string;
+        fk?: string;
+        as?: string;
+        select?: string[];
+        findOpts?: DbFindOpts;
+        type?: "1" | "1n" | "nm";
+        relations?: Relation;
+    }
 }
 declare class Relation {
-    private databases;
-    constructor(databases: Databases);
-    /**
-     * Resolves the relation path in format 'dbName.collectionName'.
-     */
-    private _resolvePath;
-    /**
-     * Processes relations for a single item.
-     */
-    private _processItemRelations;
-    /**
-     * Finds multiple items with relations.
-     */
-    find(path: string, search: Search, relations?: Record<string, RelationConfig>, options?: DbFindOpts): Promise<Record<string, any>[]>;
-    /**
-     * Finds a single item with relations.
-     */
-    findOne(path: string, search: Search, relations?: Record<string, RelationConfig>): Promise<Record<string, any> | null>;
+    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[]>;
 }
 export default Relation;

package/dist/relation.js

@@ -1,62 +1,80 @@
-class Relation {
-    databases;
-    constructor(databases) {
-        this.databases = databases;
-    }
-    /**
-     * Resolves the relation path in format 'dbName.collectionName'.
-     */
-    _resolvePath(path) {
-        if (!path.includes(".")) {
-            throw new Error(`Invalid path format "${path}". Expected format 'dbName.collectionName'.`);
-        }
-        const sanitizedPath = path.replace(/\\\./g, "\uffff");
-        const [dbName, collectionName] = sanitizedPath.split(".", 2).map(part => part.replace(/\uffff/g, "."));
-        const db = this.databases[dbName];
-        if (!db) {
-            throw new Error(`Database "${dbName}" not found.`);
-        }
-        return { db, collection: collectionName };
-    }
-    /**
-     * Processes relations for a single item.
-     */
-    async _processItemRelations(item, relations) {
-        if (!item || typeof item !== "object")
-            return item;
-        const result = { ...item };
-        for (const [field, relationConfig] of Object.entries(relations)) {
-            if (!relationConfig.from || !relationConfig.localField || !relationConfig.foreignField) {
-                console.warn(`Skipping invalid relation configuration for field: "${field}"`);
+async function processRelations(dbs, cfg, data) {
+    for (const [key, relation] of Object.entries(cfg)) {
+        const { pk = "_id", fk = "_id", type = "1" } = relation;
+        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;
             }
-            try {
-                const { db, collection } = this._resolvePath(relationConfig.from);
-                const searchQuery = { [relationConfig.foreignField]: item[relationConfig.localField] };
-                const fetchFn = relationConfig.multiple ? db.find.bind(db) : db.findOne.bind(db);
-                result[relationConfig.as || field] = await fetchFn(collection, searchQuery) || null;
+            if (relation.relations) {
+                await processRelations(dbs, relation.relations, item);
+            }
+            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)));
             }
-            catch (error) {
-                console.error(`Error processing relation for field "${field}":`, error);
+            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)));
             }
+            data[field] = items;
         }
-        return result;
+        else {
+            throw new Error(`Unknown relation type: ${relation.type}`);
+        }
+    }
+}
+function selectDataSelf(data, select) {
+    if (!data)
+        return null;
+    if (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.length === 0)
+        return data;
+    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;
     }
-    /**
-     * Finds multiple items with relations.
-     */
-    async find(path, search, relations = {}, options = {}) {
-        const { db, collection } = this._resolvePath(path);
-        const items = await db.find(collection, search, {}, options);
-        return Promise.all(items.map(item => this._processItemRelations(item, relations)));
+    async findOne(path, search, relations, select) {
+        const db = this.dbs[path[0]];
+        const data = await db.findOne(path[1], search);
+        await processRelations(this.dbs, relations, data);
+        return selectData(data, select);
     }
-    /**
-     * Finds a single item with relations.
-     */
-    async findOne(path, search, relations = {}) {
-        const { db, collection } = this._resolvePath(path);
-        const item = await db.findOne(collection, search);
-        return item ? this._processItemRelations(item, relations) : null;
+    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));
     }
 }
 export default Relation;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@wxn0brp/db",
-	"version": "0.4.2",
+	"version": "0.5.1",
 	"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.",