inibase 1.0.0-rc.9 → 1.0.0-rc.90

package/dist/utils.server.js

@@ -0,0 +1,248 @@
+import { exec as execSync, execFile as execFileSync } from "node:child_process";
+import { createCipheriv, createDecipheriv, createHash, randomBytes, scryptSync, } from "node:crypto";
+import { gunzip as gunzipSync, gzip as gzipSync } from "node:zlib";
+import { promisify } from "node:util";
+import { detectFieldType, isArrayOfObjects, isNumber, isPassword, isValidID, } from "./utils.js";
+export const exec = promisify(execSync);
+export const execFile = promisify(execFileSync);
+export const gzip = promisify(gzipSync);
+export const gunzip = promisify(gunzipSync);
+/**
+ * Generates a hashed password using SHA-256.
+ *
+ * @param password - The plain text password to hash.
+ * @returns A string containing the salt and the hashed password, separated by a colon.
+ */
+export const hashPassword = (password) => {
+    const salt = randomBytes(16).toString("hex");
+    const hash = createHash("sha256")
+        .update(password + salt)
+        .digest("hex");
+    return `${salt}:${hash}`;
+};
+/**
+ * Compares a hashed password with an input password to verify a match.
+ *
+ * @param hashedPassword - The hashed password, containing both the salt and the hash, separated by a colon.
+ * @param inputPassword - The plain text input password to compare against the hashed password.
+ * @returns A boolean indicating whether the input password matches the hashed password.
+ */
+export const comparePassword = (hash, password) => {
+    const [salt, originalHash] = hash.split(":");
+    const inputHash = createHash("sha256")
+        .update(password + salt)
+        .digest("hex");
+    return inputHash === originalHash;
+};
+// Cache for derived keys if using scrypt
+const derivedKeyCache = new Map();
+// Helper function to create cipher or decipher
+const getKeyAndIv = (secretKeyOrSalt) => {
+    if (Buffer.isBuffer(secretKeyOrSalt)) {
+        return { key: secretKeyOrSalt, iv: secretKeyOrSalt.subarray(0, 16) };
+    }
+    const cacheKey = secretKeyOrSalt.toString();
+    let key = derivedKeyCache.get(cacheKey);
+    if (!key) {
+        key = scryptSync(cacheKey, `${INIBASE_SECRET}`, 32);
+        derivedKeyCache.set(cacheKey, key); // Cache the derived key
+    }
+    return { key, iv: key.subarray(0, 16) };
+};
+// Ensure the environment variable is read once
+const INIBASE_SECRET = process.env.INIBASE_SECRET ?? "inibase";
+// Optimized encodeID
+export const encodeID = (id, secretKeyOrSalt) => {
+    const { key, iv } = getKeyAndIv(secretKeyOrSalt);
+    const cipher = createCipheriv("aes-256-cbc", key, iv);
+    return cipher.update(id.toString(), "utf8", "hex") + cipher.final("hex");
+};
+// Optimized decodeID
+export const decodeID = (input, secretKeyOrSalt) => {
+    const { key, iv } = getKeyAndIv(secretKeyOrSalt);
+    const decipher = createDecipheriv("aes-256-cbc", key, iv);
+    return Number(decipher.update(input, "hex", "utf8") + decipher.final("utf8"));
+};
+// Function to recursively flatten an array of objects and their nested children
+export const extractIdsFromSchema = (schema, secretKeyOrSalt) => {
+    const result = [];
+    for (const field of schema) {
+        if (field.id)
+            result.push(typeof field.id === "number"
+                ? field.id
+                : decodeID(field.id, secretKeyOrSalt));
+        if (field.children && isArrayOfObjects(field.children))
+            result.push(...extractIdsFromSchema(field.children, secretKeyOrSalt));
+    }
+    return result;
+};
+/**
+ * Finds the last ID number in a schema, potentially decoding it if encrypted.
+ *
+ * @param schema - The schema to search, defined as an array of schema objects.
+ * @param secretKeyOrSalt - The secret key or salt for decoding an encrypted ID, can be a string, number, or Buffer.
+ * @returns The last ID number in the schema, decoded if necessary.
+ */
+export const findLastIdNumber = (schema, secretKeyOrSalt) => Math.max(...extractIdsFromSchema(schema, secretKeyOrSalt));
+/**
+ * Adds or updates IDs in a schema, encoding them using a provided secret key or salt.
+ *
+ * @param schema - The schema to update, defined as an array of schema objects.
+ * @param oldIndex - The starting index for generating new IDs, defaults to 0.
+ * @param secretKeyOrSalt - The secret key or salt for encoding IDs, can be a string, number, or Buffer.
+ * @param encodeIDs - If true, IDs will be encoded, else they will remain as numbers.
+ * @returns The updated schema with encoded IDs.
+ */
+export const addIdToSchema = (schema, startWithID, secretKeyOrSalt, encodeIDs) => {
+    function _addIdToField(field) {
+        if (!field.id) {
+            startWithID++;
+            field.id = encodeIDs
+                ? encodeID(startWithID, secretKeyOrSalt)
+                : startWithID;
+        }
+        else {
+            if (isValidID(field.id)) {
+                if (!encodeIDs)
+                    field.id = decodeID(field.id, secretKeyOrSalt);
+            }
+            else if (encodeIDs)
+                field.id = encodeID(field.id, secretKeyOrSalt);
+        }
+        if ((field.type === "array" || field.type === "object") &&
+            isArrayOfObjects(field.children))
+            field.children = _addIdToSchema(field.children);
+        return field;
+    }
+    const _addIdToSchema = (schema) => schema.map(_addIdToField);
+    return _addIdToSchema(schema);
+};
+export const encodeSchemaID = (schema, secretKeyOrSalt) => schema.map((field) => ({
+    ...field,
+    id: isNumber(field.id) ? encodeID(field.id, secretKeyOrSalt) : field.id,
+    ...(field.children
+        ? isArrayOfObjects(field.children)
+            ? {
+                children: encodeSchemaID(field.children, secretKeyOrSalt),
+            }
+            : { children: field.children }
+        : {}),
+}));
+export const hashString = (str) => createHash("sha256").update(str).digest("hex");
+/**
+ * Evaluates a comparison between two values based on a specified operator and field types.
+ *
+ * @param operator - The comparison operator (e.g., '=', '!=', '>', '<', '>=', '<=', '[]', '![]', '*', '!*').
+ * @param originalValue - The value to compare, can be a single value or an array of values.
+ * @param comparedValue - The value or values to compare against.
+ * @param fieldType - Optional type of the field to guide comparison (e.g., 'password', 'boolean').
+ * @param fieldChildrenType - Optional type for child elements in array inputs.
+ * @returns boolean - Result of the comparison operation.
+ *
+ * Note: Handles various data types and comparison logic, including special handling for passwords and regex patterns.
+ */
+export const compare = (operator, originalValue, comparedValue, fieldType) => {
+    // Determine the field type if it's an array of potential types.
+    if (Array.isArray(fieldType))
+        fieldType = detectFieldType(String(originalValue), fieldType);
+    // Handle comparisons involving arrays.
+    if (Array.isArray(comparedValue) && !["[]", "![]"].includes(operator))
+        return comparedValue.some((value) => compare(operator, originalValue, value, fieldType));
+    // Switch statement for different comparison operators.
+    switch (operator) {
+        // Equal (Case Insensitive for strings, specific handling for passwords and booleans).
+        case "=":
+            return isEqual(originalValue, comparedValue, fieldType);
+        // Not Equal.
+        case "!=":
+            return !isEqual(originalValue, comparedValue, fieldType);
+        // Greater Than.
+        case ">":
+            return compareNonNullValues(originalValue, comparedValue, (a, b) => a > b);
+        // Less Than.
+        case "<":
+            return compareNonNullValues(originalValue, comparedValue, (a, b) => a < b);
+        // Greater Than or Equal.
+        case ">=":
+            return compareNonNullValues(originalValue, comparedValue, (a, b) => a >= b);
+        // Less Than or Equal.
+        case "<=":
+            return compareNonNullValues(originalValue, comparedValue, (a, b) => a <= b);
+        // Array Contains (equality check for arrays).
+        case "[]":
+            return isArrayEqual(originalValue, comparedValue);
+        // Array Does Not Contain.
+        case "![]":
+            return !isArrayEqual(originalValue, comparedValue);
+        // Wildcard Match (using regex pattern).
+        case "*":
+            return isWildcardMatch(originalValue, comparedValue);
+        // Not Wildcard Match.
+        case "!*":
+            return !isWildcardMatch(originalValue, comparedValue);
+        // Unsupported operator.
+        default:
+            throw new Error(`Unsupported operator: ${operator}`);
+    }
+};
+/**
+ * Helper function to handle non-null comparisons.
+ */
+const compareNonNullValues = (originalValue, comparedValue, comparator) => {
+    return (originalValue !== null &&
+        comparedValue !== null &&
+        comparator(originalValue, comparedValue));
+};
+/**
+ * Helper function to check equality based on the field type.
+ *
+ * @param originalValue - The original value.
+ * @param comparedValue - The value to compare against.
+ * @param fieldType - Type of the field.
+ * @returns boolean - Result of the equality check.
+ */
+export const isEqual = (originalValue, comparedValue, fieldType) => {
+    switch (fieldType) {
+        case "password":
+            return isPassword(originalValue) && typeof comparedValue === "string"
+                ? comparePassword(originalValue, comparedValue)
+                : false;
+        case "boolean":
+            return Number(originalValue) === Number(comparedValue);
+        default:
+            return originalValue == comparedValue;
+    }
+};
+/**
+ * Helper function to check array equality.
+ *
+ * @param originalValue - The original value.
+ * @param comparedValue - The value to compare against.
+ * @returns boolean - Result of the array equality check.
+ */
+export const isArrayEqual = (originalValue, comparedValue) => {
+    if (Array.isArray(originalValue) && Array.isArray(comparedValue))
+        return originalValue.some((v) => comparedValue.includes(v));
+    if (Array.isArray(originalValue))
+        return originalValue.includes(comparedValue);
+    if (Array.isArray(comparedValue))
+        return comparedValue.includes(originalValue);
+    return originalValue == comparedValue;
+};
+/**
+ * Helper function to check wildcard pattern matching using regex.
+ *
+ * @param originalValue - The original value.
+ * @param comparedValue - The value with wildcard pattern.
+ * @returns boolean - Result of the wildcard pattern matching.
+ */
+export const isWildcardMatch = (originalValue, comparedValue) => {
+    const comparedValueStr = String(comparedValue);
+    const originalValueStr = String(originalValue);
+    if (!comparedValueStr.includes("%") &&
+        (comparedValueStr === originalValueStr ||
+            comparedValueStr.toLowerCase() === originalValueStr.toLowerCase()))
+        return true;
+    const wildcardPattern = `^${(comparedValueStr.includes("%") ? comparedValueStr : `%${comparedValueStr}%`).replace(/%/g, ".*")}$`;
+    return new RegExp(wildcardPattern, "i").test(originalValueStr);
+};

package/package.json

@@ -1,38 +1,85 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.9",
-  "description": "File-based Relational Database for large data",
-  "main": "index.ts",
+  "version": "1.0.0-rc.90",
   "type": "module",
-  "scripts": {
-    "test": "npx tsx watch ./index.test.ts"
+  "author": {
+    "name": "Karim Amahtil",
+    "email": "karim.amahtil@gmail.com"
+  },
+  "repository": "inicontent/inibase",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./file": "./dist/file.js",
+    "./utils": "./dist/utils.js",
+    "./utils.server": "./dist/utils.server.js"
+  },
+  "bugs": {
+    "url": "https://github.com/inicontent/inibase/issues"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/inicontent/inibase.git"
+  "description": "A file-based & memory-efficient, serverless, ACID compliant, relational database management system",
+  "engines": {
+    "node": ">=16"
   },
+  "files": [
+    "/dist"
+  ],
+  "funding": "https://github.com/sponsors/inicontent",
+  "homepage": "https://github.com/inicontent/inibase#readme",
   "keywords": [
-    "db",
     "nosql",
-    "mongoose",
-    "mongodb",
+    "rdms",
     "database",
+    "db",
+    "mongoose",
     "relational",
     "local",
+    "file",
     "storage",
     "json",
-    "sql",
     "sqlite",
+    "sql",
     "supabase",
-    "firebase"
+    "better-sqlite",
+    "mongodb",
+    "firebase",
+    "postgresql",
+    "pocketbase"
   ],
-  "author": "Inicontent",
   "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/inicontent/inibase/issues"
+  "bin": {
+    "inibase": "./dist/cli.js"
+  },
+  "types": "./dist",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ],
+      "file": [
+        "./dist/file.d.ts"
+      ],
+      "utils": [
+        "./dist/utils.d.ts"
+      ],
+      "utils.server": [
+        "./dist/utils.server.d.ts"
+      ]
+    }
   },
-  "homepage": "https://github.com/inicontent/inibase#readme",
   "devDependencies": {
-    "@types/node": "^20.8.6"
+    "@types/bun": "^1.1.10",
+    "@types/node": "^22.7.4",
+    "tinybench": "^2.6.0",
+    "typescript": "^5.6.2"
+  },
+  "dependencies": {
+    "dotenv": "^16.4.5",
+    "inison": "1.0.0-rc.4"
+  },
+  "scripts": {
+    "prepublish": "npx tsc",
+    "build": "npx tsc",
+    "benchmark": "./benchmark/run.js"
   }
-}
+}