@wxn0brp/db 0.0.5 → 0.0.6

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/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;

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,8 @@
+/**
+ * Updates an object with new values.
+ * @function
+ * @param {Object} obj - The object to update.
+ * @param {Object} newVal - An object containing new values to update in the target object.
+ * @returns {Object} The updated object.
+ */
+export default function updateObject(obj: any, newVal: any): any;

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

@@ -5,11 +5,11 @@
  * @param {Object} newVal - An object containing new values to update in the target object.
  * @returns {Object} The updated object.
  */
-export default function updateObject(obj, newVal){
-    for(let key in newVal){
-        if(newVal.hasOwnProperty(key)){
+export default 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,57 @@
 {
-  "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.6",
+	"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/body-parser": "^1.19.5",
+		"@types/got": "^9.6.12",
+		"@types/node": "^22.10.2",
+		"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",
+		"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",
+		"postbuild": "node scripts/postbuild.js",
+		"prepare": "npm run build",
+		"postversion": "git push && git push --tags"
+	},
+	"files": [
+		"dist"
+	],
+	"exports": {
+		".": {
+			"import": "./dist/esm/index.js",
+			"require": "./dist/cjs/index.js"
+		}
+	}
 }

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;