@wxn0brp/db 0.0.7 → 0.1.0

package/dist/esm/relation.js

@@ -4,62 +4,59 @@ class Relation {
         this.databases = databases;
     }
     /**
-    * Resolves the relation path in format 'dbName.collectionName'
-    */
+     * Resolves the relation path in format 'dbName.collectionName'.
+     */
     _resolvePath(path) {
-        const sanitizedPath = path.replace(/\\\./g, '\uffff');
-        const separatorIndex = sanitizedPath.indexOf('.');
-        if (separatorIndex === -1)
+        if (!path.includes(".")) {
             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 };
+        }
+        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
-     * @param {Object} item - Item to process relations for
-     * @param {Object} relations - Relations configuration
-     * @returns {Promise<Object>} Processed item with resolved relations
+     * 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)) {
-            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;
+            if (!relationConfig.from || !relationConfig.localField || !relationConfig.foreignField) {
+                console.warn(`Skipping invalid relation configuration for field: "${field}"`);
+                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;
+            }
+            catch (error) {
+                console.error(`Error processing relation for field "${field}":`, error);
+            }
         }
         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
+     * 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);
-        const results = await Promise.all(items.map(item => this._processItemRelations(item, relations)));
-        return results;
+        return Promise.all(items.map(item => this._processItemRelations(item, relations)));
     }
     /**
-     * Finds one item with relations
-     * @param path - Path in format 'dbName.collectionName'
-     * @param search - Search query or function
-     * @param relations - Relations configuration
+     * Finds a single item with relations.
      */
     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);
+        return item ? this._processItemRelations(item, relations) : null;
     }
 }
 export default Relation;

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

@@ -1,12 +1,12 @@
-import Id from "./Id";
-import { SearchOptions } from "./searchOpts";
-import { Context } from "./types";
-import { UpdaterArg } from "./updater";
+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> = (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 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/esm/types/searchOpts.d.ts

@@ -4,23 +4,24 @@
  * This module defines the types and structures for search operators used
  * to validate and query data objects.
  */
+import { Arg } from "./arg.js";
 /** 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>;
+    $and?: Array<SearchOptions>;
     /**
      * 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>;
+    $or?: Array<SearchOptions>;
     /**
      * Negates a single condition.
      * Can include any other operator as its value.
      */
-    $not?: PredefinedSearchOperators;
+    $not?: SearchOptions;
 };
 /** Comparison Operators */
 export type ComparisonOperators = {
@@ -58,4 +59,4 @@ export type PredefinedSearchOperators = LogicalOperators & ComparisonOperators &
 /**
  * SearchOptions can be either a function or an object with predefined operators.
  */
-export type SearchOptions = PredefinedSearchOperators | ((doc: Record<string, any>) => boolean);
+export type SearchOptions = PredefinedSearchOperators & Arg;

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

@@ -1,4 +1,5 @@
 export interface Context {
+    [key: string]: any;
 }
 export interface SortedFiles {
     i: number;

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

@@ -1,8 +1,7 @@
 /**
  * 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.
+ * @param obj - The object to check.
+ * @param fields - Criteria to compare.
+ * @returns Whether the object matches the criteria.
  */
-export default function hasFields(obj: any, fields: any): any;
+export default function hasFields(obj: Object, fields: Object): boolean;

package/dist/esm/utils/hasFields.js

@@ -1,9 +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.
+ * @param obj - The object to check.
+ * @param fields - Criteria to compare.
+ * @returns Whether the object matches the criteria.
  */
 export default function hasFields(obj, fields) {
     const keys = Object.keys(fields);

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

@@ -1,4 +1,4 @@
-import { Arg } from "../types/arg";
+import { Arg } from "../types/arg.js";
 /**
  * Checks if an object meets the criteria specified in the fields with operators.
  */

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

@@ -1,11 +1,11 @@
+import { FindOpts } from "../types/options.js";
 /**
  * Updates an object with new values from a findOpts object.
- * @function
- * @param {Object} obj - The object to update.
- * @param {Object} findOpts - An object containing options to update the target object.
- * @param {function} [findOpts.transform] - A function to transform the object before applying the other options.
- * @param {string[]} [findOpts.select] - An array of fields to select from the target object.
- * @param {string[]} [findOpts.exclude] - An array of fields to exclude from the target object.
- * @returns {Object} The updated object.
+ * @param obj - The object to update.
+ * @param findOpts - An object containing options to update the target object.
+ * @param [findOpts.transform] - A function to transform the object before applying the other options.
+ * @param [findOpts.select] - An array of fields to select from the target object.
+ * @param [findOpts.exclude] - An array of fields to exclude from the target object.
+ * @returns The updated object.
  */
-export default function updateFindObject(obj: any, findOpts: any): any;
+export default function updateFindObject(obj: Object, findOpts: FindOpts): Object;

package/dist/esm/utils/updateFindObject.js

@@ -1,12 +1,11 @@
 /**
  * Updates an object with new values from a findOpts object.
- * @function
- * @param {Object} obj - The object to update.
- * @param {Object} findOpts - An object containing options to update the target object.
- * @param {function} [findOpts.transform] - A function to transform the object before applying the other options.
- * @param {string[]} [findOpts.select] - An array of fields to select from the target object.
- * @param {string[]} [findOpts.exclude] - An array of fields to exclude from the target object.
- * @returns {Object} The updated object.
+ * @param obj - The object to update.
+ * @param findOpts - An object containing options to update the target object.
+ * @param [findOpts.transform] - A function to transform the object before applying the other options.
+ * @param [findOpts.select] - An array of fields to select from the target object.
+ * @param [findOpts.exclude] - An array of fields to exclude from the target object.
+ * @returns The updated object.
  */
 export default function updateFindObject(obj, findOpts) {
     const { transform, select, exclude, } = findOpts;

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

@@ -4,4 +4,4 @@ import { UpdaterArg } from "../types/updater.js";
  * @param obj - The object to update.
  * @param fields - An object containing new values to update in the target object.
  */
-export default function updateObjectAdvanced(obj: any, fields: UpdaterArg | UpdaterArg[]): any;
+export default function updateObjectAdvanced(obj: Object, fields: UpdaterArg | UpdaterArg[]): Object;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@wxn0brp/db",
-	"version": "0.0.7",
+	"version": "0.1.0",
 	"main": "dist/esm/index.js",
 	"types": "dist/esm/index.d.ts",
 	"description": "A simple file-based database management system with support for CRUD operations, custom queries, and graph structures.",
@@ -20,18 +20,18 @@
 	"license": "MIT",
 	"type": "module",
 	"dependencies": {
-		"got": "^14.4.2",
 		"json5": "^2.2.3",
+		"ky": "^1.7.4",
 		"readline": "^1.3.0"
 	},
 	"devDependencies": {
-		"@types/got": "^9.6.12",
 		"@types/node": "^22.10.2",
+		"tsc-alias": "^1.8.10",
 		"typescript": "^5.7.2"
 	},
 	"scripts": {
-		"build:esm": "tsc",
-		"build:cjs": "tsc --module CommonJS --outDir ./dist/cjs --declarationDir ./dist/cjs",
+		"build:esm": "tsc && tsc-alias -p tsconfig.json",
+		"build:cjs": "tsc -p tsconfig.cjs.json && tsc-alias -p tsconfig.cjs.json",
 		"build": "npm run build:esm && npm run build:cjs",
 		"prepare": "npm run build",
 		"postversion": "git push && git push --tags"