@wxn0brp/db 0.0.5 → 0.0.7

package/dist/esm/utils/hasFieldsAdvanced.js

@@ -0,0 +1,176 @@
+import hasFields from "./hasFields.js";
+/**
+ * Checks if an object meets the criteria specified in the fields with operators.
+ */
+export default function hasFieldsAdvanced(obj, fields) {
+    if (typeof fields !== "object" || fields === null) {
+        throw new Error("Fields must be an object");
+    }
+    if ("$and" in fields) {
+        return fields["$and"].every(subFields => hasFieldsAdvanced(obj, subFields));
+    }
+    if ("$or" in fields) {
+        return fields["$or"].some(subFields => hasFieldsAdvanced(obj, subFields));
+    }
+    // Check various conditions
+    if (!checkConditions(obj, fields))
+        return false;
+    const fieldsSubset = removeAdvancedOperators({ ...fields });
+    return hasFields(obj, fieldsSubset);
+}
+function removeAdvancedOperators(fields) {
+    const advancedOperators = [
+        "and", "or",
+        "gt", "lt", "gte", "lte", "in", "nin",
+        "exists",
+        "type",
+        "regex",
+        "arrinc", "arrincall", "size",
+        "startsWith", "endsWith",
+        "between",
+        "not",
+        "subset"
+    ].map(operator => "$" + operator);
+    advancedOperators.forEach(operator => delete fields[operator]);
+    return fields;
+}
+function checkConditions(obj, fields) {
+    return (checkComparison(obj, fields) &&
+        checkExistence(obj, fields) &&
+        checkType(obj, fields) &&
+        checkRegex(obj, fields) &&
+        checkArrayConditions(obj, fields) &&
+        checkStringConditions(obj, fields) &&
+        checkBetween(obj, fields) &&
+        checkNot(obj, fields) &&
+        checkSubset(obj, fields));
+}
+function checkComparison(obj, fields) {
+    const comparisonOperators = ["$gt", "$lt", "$gte", "$lte", "$in", "$nin"];
+    for (const operator of comparisonOperators) {
+        if (operator in fields) {
+            for (const entries of Object.entries(fields[operator])) {
+                const [key, value] = entries;
+                switch (operator) {
+                    case "$gt":
+                        if (!(obj[key] > value))
+                            return false;
+                        break;
+                    case "$lt":
+                        if (!(obj[key] < value))
+                            return false;
+                        break;
+                    case "$gte":
+                        if (!(obj[key] >= value))
+                            return false;
+                        break;
+                    case "$lte":
+                        if (!(obj[key] <= value))
+                            return false;
+                        break;
+                    case "$in":
+                        if (!value.includes(obj[key]))
+                            return false;
+                        break;
+                    case "$nin":
+                        if (value.includes(obj[key]))
+                            return false;
+                        break;
+                }
+            }
+        }
+    }
+    return true;
+}
+function checkExistence(obj, fields) {
+    if ("$exists" in fields) {
+        for (const [key, shouldExist] of Object.entries(fields["$exists"])) {
+            if (shouldExist && !(key in obj))
+                return false;
+            if (!shouldExist && (key in obj))
+                return false;
+        }
+    }
+    return true;
+}
+function checkType(obj, fields) {
+    if ("$type" in fields) {
+        for (const [key, type] of Object.entries(fields["$type"])) {
+            if (typeof obj[key] !== type)
+                return false;
+        }
+    }
+    return true;
+}
+function checkRegex(obj, fields) {
+    if ("$regex" in fields) {
+        for (const [key, regex] of Object.entries(fields["$regex"])) {
+            if (!regex.test(obj[key]))
+                return false;
+        }
+    }
+    return true;
+}
+function checkArrayConditions(obj, fields) {
+    if ("$arrinc" in fields) {
+        for (const [key, values] of Object.entries(fields["$arrinc"])) {
+            if (!Array.isArray(obj[key]) || !values.some(val => obj[key].includes(val)))
+                return false;
+        }
+    }
+    if ("$arrincall" in fields) {
+        for (const [key, values] of Object.entries(fields["$arrincall"])) {
+            if (!Array.isArray(obj[key]) || !values.every(val => obj[key].includes(val)))
+                return false;
+        }
+    }
+    if ("$size" in fields) {
+        for (const [key, size] of Object.entries(fields["$size"])) {
+            if (Array.isArray(obj[key]) || typeof obj[key] === "string") {
+                if (obj[key].length !== size)
+                    return false;
+            }
+            else {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function checkStringConditions(obj, fields) {
+    if ("$startsWith" in fields) {
+        for (const [key, value] of Object.entries(fields["$startsWith"])) {
+            if (typeof obj[key] !== "string" || !obj[key].startsWith(value))
+                return false;
+        }
+    }
+    if ("$endsWith" in fields) {
+        for (const [key, value] of Object.entries(fields["$endsWith"])) {
+            if (typeof obj[key] !== "string" || !obj[key].endsWith(value))
+                return false;
+        }
+    }
+    return true;
+}
+function checkBetween(obj, fields) {
+    if ("$between" in fields) {
+        for (const [key, [min, max]] of Object.entries(fields["$between"])) {
+            if (typeof obj[key] !== "number" || obj[key] < min || obj[key] > max)
+                return false;
+        }
+    }
+    return true;
+}
+function checkNot(obj, fields) {
+    if ("$not" in fields) {
+        return !hasFieldsAdvanced(obj, fields["$not"]);
+    }
+    return true;
+}
+function checkSubset(obj, fields) {
+    if ("$subset" in fields) {
+        const setFields = fields["$subset"];
+        return hasFields(obj, setFields);
+    }
+    return true;
+}

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

@@ -0,0 +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.
+ */
+export default function updateFindObject(obj: any, findOpts: any): any;

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

@@ -8,27 +8,22 @@
  * @param {string[]} [findOpts.exclude] - An array of fields to exclude from the target object.
  * @returns {Object} The updated object.
  */
-export default function updateFindObject(obj, findOpts){
-    const {
-        transform,
-        select,
-        exclude,
-    } = findOpts;
-
-    if(typeof transform === "function") obj = transform(obj);
-    
-    if(Array.isArray(exclude)){
+export default function updateFindObject(obj, findOpts) {
+    const { transform, select, exclude, } = findOpts;
+    if (typeof transform === "function")
+        obj = transform(obj);
+    if (Array.isArray(exclude)) {
         exclude.forEach(field => {
-            if(obj.hasOwnProperty(field)) delete obj[field];
+            if (obj.hasOwnProperty(field))
+                delete obj[field];
         });
     }
-
-    if(Array.isArray(select)){
+    if (Array.isArray(select)) {
         obj = select.reduce((acc, field) => {
-            if(obj.hasOwnProperty(field)) acc[field] = obj[field];
+            if (obj.hasOwnProperty(field))
+                acc[field] = obj[field];
             return acc;
         }, {});
     }
-
     return obj;
-}
+}

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

@@ -0,0 +1,7 @@
+import { UpdaterArg } from "../types/updater.js";
+/**
+ * Updates an object with new values.
+ * @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;

package/dist/esm/utils/updateObject.js

@@ -0,0 +1,145 @@
+/**
+ * Updates an object with new values.
+ * @param obj - The object to update.
+ * @param fields - An object containing new values to update in the target object.
+ */
+export default function updateObjectAdvanced(obj, fields) {
+    if (typeof fields !== "object" || fields === null) {
+        throw new Error("Fields must be an object or object array");
+    }
+    const fieldsArray = Array.isArray(fields) ? fields : [fields];
+    for (const field of fieldsArray) {
+        if (typeof field !== "object" || field === null) {
+            throw new Error("Fields must be an object or object array");
+        }
+        updateAdvanced(obj, field);
+        const fieldsSubset = removeAdvancedOperators({ ...field });
+        updateObject(obj, fieldsSubset);
+    }
+    return obj;
+}
+function updateAdvanced(obj, fields) {
+    updateArray(obj, fields);
+    updateNested(obj, fields);
+    updateIncrement(obj, fields);
+    updateUnset(obj, fields);
+    updateRename(obj, fields);
+}
+function removeAdvancedOperators(fields) {
+    const advancedOperators = [
+        "push", "pushset", "pull", "pullall",
+        "inc", "dec",
+        "unset",
+        "merge",
+        "rename"
+    ].map(operator => "$" + operator);
+    advancedOperators.forEach(operator => delete fields[operator]);
+    return fields;
+}
+function updateArray(obj, fields) {
+    if ("$push" in fields) {
+        for (const [key, value] of Object.entries(fields["$push"])) {
+            if (Array.isArray(obj[key])) {
+                obj[key].push(value);
+            }
+            else {
+                obj[key] = [value];
+            }
+        }
+    }
+    if ("$pushset" in fields) {
+        for (const [key, value] of Object.entries(fields["$pushset"])) {
+            if (Array.isArray(obj[key])) {
+                obj[key].push(value);
+            }
+            else {
+                obj[key] = [value];
+            }
+            obj[key] = [...new Set(obj[key])];
+        }
+    }
+    if ("$pull" in fields) {
+        for (const [key, value] of Object.entries(fields["$pull"])) {
+            if (Array.isArray(obj[key])) {
+                obj[key] = obj[key].filter(item => item !== value);
+            }
+        }
+    }
+    if ("$pullall" in fields) {
+        for (const [key, values] of Object.entries(fields["$pullall"])) {
+            if (Array.isArray(obj[key])) {
+                obj[key] = obj[key].filter(item => !values.includes(item));
+            }
+        }
+    }
+}
+function updateNested(obj, fields) {
+    if ("$merge" in fields) {
+        for (const [key, value] of Object.entries(fields["$merge"])) {
+            if (typeof obj[key] === "object" && typeof value === "object") {
+                obj[key] = { ...obj[key], ...value };
+            }
+            else {
+                obj[key] = value;
+            }
+        }
+    }
+}
+function updateIncrement(obj, fields) {
+    if ("$inc" in fields) {
+        for (const [key, value] of Object.entries(fields["$inc"])) {
+            if (typeof obj[key] === "number" && typeof value === "number") {
+                obj[key] += value;
+            }
+            else if (!(key in obj)) {
+                obj[key] = value;
+            }
+            else {
+                throw new Error(`Cannot increment non-numeric value at key: ${key}`);
+            }
+        }
+    }
+    if ("$dec" in fields) {
+        for (const [key, value] of Object.entries(fields["$dec"])) {
+            if (typeof obj[key] === "number" && typeof value === "number") {
+                obj[key] -= value;
+            }
+            else if (!(key in obj)) {
+                obj[key] = value;
+            }
+            else {
+                throw new Error(`Cannot decrement non-numeric value at key: ${key}`);
+            }
+        }
+    }
+}
+function updateUnset(obj, fields) {
+    if ("$unset" in fields) {
+        for (const key of Object.keys(fields["$unset"])) {
+            delete obj[key];
+        }
+    }
+}
+function updateRename(obj, fields) {
+    if ("$rename" in fields) {
+        for (const [oldKey, newKey] of Object.entries(fields["$rename"])) {
+            if (oldKey in obj) {
+                obj[newKey] = obj[oldKey];
+                delete obj[oldKey];
+            }
+        }
+    }
+}
+/**
+ * Updates an object with new values.
+ * @param obj - The object to update.
+ * @param newVal - An object containing new values to update in the target object.
+ */
+function updateObject(obj, newVal) {
+    for (let key in newVal) {
+        if (newVal.hasOwnProperty(key)) {
+            obj[key] = newVal[key];
+        }
+    }
+    return obj;
+}

package/package.json

@@ -1,38 +1,54 @@
 {
-  "name": "@wxn0brp/db",
-  "version": "0.0.5",
-  "main": "index.js",
-  "description": "A simple file-based database management system with support for CRUD operations, custom queries, and graph structures.",
-  "homepage": "https://github.com/wxn0brP/database",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/wxn0brP/database.git"
-  },
-  "keywords": [
-    "database",
-    "file-based",
-    "CRUD",
-    "graph",
-    "query"
-  ],
-  "author": "wxn0brP",
-  "license": "MIT",
-  "type": "module",
-  "dependencies": {
-    "got": "^14.4.2",
-    "json5": "^2.2.3",
-    "readline": "^1.3.0"
-  },
-  "devDependencies": {
-    "ava": "^6.2.0",
-    "body-parser": "^1.20.3",
-    "cors": "^2.8.5",
-    "dotenv": "^16.4.5",
-    "express": "^4.21.1",
-    "jwt-simple": "^0.5.6",
-    "node-cache": "^5.1.2"
-  },
-  "scripts": {
-    "postversion": "git push && git push --tags"
-  }
+	"name": "@wxn0brp/db",
+	"version": "0.0.7",
+	"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.",
+	"homepage": "https://github.com/wxn0brP/database",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/wxn0brP/database.git"
+	},
+	"keywords": [
+		"database",
+		"file-based",
+		"CRUD",
+		"graph",
+		"query"
+	],
+	"author": "wxn0brP",
+	"license": "MIT",
+	"type": "module",
+	"dependencies": {
+		"got": "^14.4.2",
+		"json5": "^2.2.3",
+		"readline": "^1.3.0"
+	},
+	"devDependencies": {
+		"@types/got": "^9.6.12",
+		"@types/node": "^22.10.2",
+		"typescript": "^5.7.2"
+	},
+	"scripts": {
+		"build:esm": "tsc",
+		"build:cjs": "tsc --module CommonJS --outDir ./dist/cjs --declarationDir ./dist/cjs",
+		"build": "npm run build:esm && npm run build:cjs",
+		"prepare": "npm run build",
+		"postversion": "git push && git push --tags"
+	},
+	"files": [
+		"dist"
+	],
+	"exports": {
+		".": {
+			"import": "./dist/esm/index.js",
+			"require": "./dist/cjs/index.js",
+			"types": "./dist/esm/index.d.ts"
+		},
+		"./*": {
+			"import": "./dist/esm/*",
+			"require": "./dist/cjs/*",
+			"types": "./dist/esm/*"
+		}
+	}
 }

package/CollectionManager.js

@@ -1,119 +0,0 @@
-class CollectionManager{
-    constructor(db, collection){
-        this.db = db;
-        this.collection = collection;
-    }
-
-    /**
-     * Add data to a database.
-     *
-     * @async
-     * @function
-     * @param {Object} data - The data to add.
-     * @param {boolean} id_gen - Whether to generate an ID for the entry. Default is true.
-     * @returns {Promise<Object>} A Promise that resolves with the added data.
-     */
-    async add(data, id_gen=true){
-        return await this.db.add(this.collection, data, id_gen);
-    }
-
-    /**
-     * Find data in a database.
-     *
-     * @async
-     * @function
-     * @param {function|Object} search - The query. It can be an object or a function.
-     * @param {Object} context - The context object (for functions).
-     * @param {Object} options - The options for the search.
-     * @param {number} options.max - The maximum number of entries to return. Default is -1, meaning no limit.
-     * @param {boolean} options.reverse - Whether to reverse the order of returned entries. Default is false.
-     * @returns {Promise<Array<Object>>} A Promise that resolves with the matching data.
-     */
-    async find(search, context={}, options={}){
-        return await this.db.find(this.collection, search, context, options);
-    }
-
-    /**
-     * Find one data entry in a database.
-     *
-     * @async
-     * @function
-     * @param {function|Object} search - The query. It can be an object or a function.
-     * @param {Object} context - The context object (for functions).
-     * @returns {Promise<Object|null>} A Promise that resolves with the first matching data entry.
-     */
-    async findOne(search, context={}){
-        return await this.db.findOne(this.collection, search, context);
-    }
-
-    /**
-     * Update data in a database.
-     *
-     * @async
-     * @function
-     * @param {function|Object} search - The query. It can be an object or a function.
-     * @param {function|Object} arg - Update arguments.
-     * @param {Object} context - The context object (for functions).
-     * @returns {Promise<boolean>} A Promise that resolves when the data is updated.
-     */
-    async update(search, arg, context={}){
-        return await this.db.update(this.collection, search, arg, context);
-    }
-
-    /**
-     * Update one data entry in a database.
-     *
-     * @async
-     * @function
-     * @param {function|Object} search - The query. It can be an object or a function.
-     * @param {function|Object} arg - The query.
-     * @param {Object} context - The context object (for functions).
-     * @returns {Promise<boolean>} A Promise that resolves when the data entry is updated.
-     */
-    async updateOne(search, arg, context={}){
-        return await this.db.updateOne(this.collection, search, arg, context);
-    }
-
-    /**
-     * Remove data from a database.
-     *
-     * @async
-     * @function
-     * @param {function|Object} search - The query. It can be an object or a function.
-     * @param {Object} context - The context object (for functions).
-     * @returns {Promise<boolean>} A Promise that resolves when the data is removed.
-     */
-
-    async remove(search, context={}){
-        return await this.db.remove(this.collection, search, context);
-    }
-
-    /**
-     * Remove one data entry from a database.
-     *
-     * @async
-     * @function
-     * @param {function|Object} search - The query. It can be an object or a function.
-     * @param {Object} context - The context object (for functions).
-     * @returns {Promise<boolean>} A Promise that resolves when the data entry is removed.
-     */
-    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.
-     *
-     * @param {function|Object} search - The query. It can be an object or a function.
-     * @param {function|Object} arg - The search criteria for the update.
-     * @param {function|Object} add_arg - The arguments to be added to the new entry.
-     * @param {Object} context - The context object (for functions).
-     * @param {boolean} id_gen - Whether to generate an ID for the entry. Default is true.
-     * @return {Promise<boolean>} A Promise that resolves to `true` if the entry was updated, or `false` if it was added.
-     */
-    async updateOneOrAdd(search, arg, add_arg={}, context={}, id_gen=true){
-        return await this.db.updateOneOrAdd(this.collection, search, arg, add_arg, context, id_gen);
-    }
-}
-
-export default CollectionManager;