inibase 1.0.0-rc.0 → 1.0.0-rc.100

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,37 +1,85 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.0",
-  "description": "File-based Relational Database for large data",
-  "main": "index.ts",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/inicontent/inibase.git"
+  "version": "1.0.0-rc.100",
+  "type": "module",
+  "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"
+  },
+  "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.6.0"
+    "@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": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "prepublish": "npx tsc",
+    "build": "npx tsc",
+    "benchmark": "./benchmark/run.js"
   }
 }

package/file.ts

@@ -1,322 +0,0 @@
-import { createWriteStream, unlinkSync, renameSync, existsSync } from "fs";
-import { open } from "fs/promises";
-import { parse } from "path";
-import { ComparisonOperator, FieldType } from ".";
-import Utils from "./utils";
-
-export const encodeFileName = (fileName: string, extension?: string) => {
-  return (
-    fileName.replaceAll("%", "%25").replaceAll("*", "%") +
-    (extension ? `.${extension}` : "")
-  );
-};
-
-export const decodeFileName = (fileName: string) => {
-  return fileName.replaceAll("%", "*").replaceAll("*25", "%");
-};
-
-export const get = async (
-  filePath: string,
-  fieldType?: FieldType,
-  lineNumbers?: number | number[]
-) => {
-  const file = await open(filePath);
-  let lines: Record<
-      number,
-      | string
-      | number
-      | boolean
-      | (string | number | boolean | (string | number | boolean)[] | null)[]
-      | null
-    > = {},
-    lineCount = 0;
-
-  if (!lineNumbers) {
-    for await (const line of file.readLines())
-      lineCount++, (lines[lineCount] = Utils.decode(line, fieldType));
-  } else if (lineNumbers === -1) {
-    let lastLine;
-    for await (const line of file.readLines()) lineCount++, (lastLine = line);
-    if (lastLine) lines = { [lineCount]: Utils.decode(lastLine, fieldType) };
-  } else {
-    let lineNumbersArray = [
-      ...(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]),
-    ];
-    for await (const line of file.readLines()) {
-      lineCount++;
-      if (!lineNumbersArray.includes(lineCount)) continue;
-      const indexOfLineCount = lineNumbersArray.indexOf(lineCount);
-      lines[lineCount] = Utils.decode(line, fieldType);
-      lineNumbersArray[indexOfLineCount] = 0;
-      if (!lineNumbersArray.filter((lineN) => lineN !== 0).length) break;
-    }
-  }
-
-  return lines ?? null;
-};
-
-export const replace = async (
-  filePath: string,
-  replacements:
-    | string
-    | number
-    | boolean
-    | null
-    | (string | number | boolean | null)[]
-    | Record<
-        number,
-        string | boolean | number | null | (string | boolean | number | null)[]
-      >
-) => {
-  if (existsSync(filePath)) {
-    const file = await open(filePath, "w+"),
-      writeStream = file.createWriteStream();
-    if (typeof replacements === "object" && !Array.isArray(replacements)) {
-      let lineCount = 0;
-      for await (const line of file.readLines()) {
-        lineCount++;
-        writeStream.write(
-          (lineCount in replacements
-            ? Utils.encode(replacements[lineCount])
-            : line) + "\n"
-        );
-      }
-    } else
-      for await (const _line of file.readLines())
-        writeStream.write(Utils.encode(replacements) + "\n");
-
-    writeStream.end();
-  } else if (typeof replacements === "object" && !Array.isArray(replacements)) {
-    const file = await open(filePath, "w"),
-      writeStream = file.createWriteStream(),
-      largestLinesNumbers =
-        Math.max(...Object.keys(replacements).map(Number)) + 1;
-    for (let lineCount = 1; lineCount < largestLinesNumbers; lineCount++) {
-      writeStream.write(
-        (lineCount in replacements
-          ? Utils.encode(replacements[lineCount])
-          : "") + "\n"
-      );
-    }
-    writeStream.end();
-  }
-};
-
-export const remove = async (
-  filePath: string,
-  linesToDelete: number | number[]
-): Promise<void> => {
-  let lineCount = 0;
-
-  const tempFilePath = `${filePath}.tmp`,
-    linesToDeleteArray = [
-      ...(Array.isArray(linesToDelete) ? linesToDelete : [linesToDelete]),
-    ],
-    writeStream = createWriteStream(tempFilePath),
-    file = await open(filePath);
-
-  for await (const line of file.readLines()) {
-    lineCount++;
-    if (!linesToDeleteArray.includes(lineCount)) {
-      writeStream.write(`${line}\n`);
-    }
-  }
-  writeStream.end();
-  writeStream.on("finish", () => {
-    unlinkSync(filePath); // Remove the original file
-    renameSync(tempFilePath, filePath); // Rename the temp file to the original file name
-  });
-};
-
-export const count = async (filePath: string): Promise<number> => {
-  let lineCount = 0;
-
-  const file = await open(filePath);
-
-  for await (const line of file.readLines()) lineCount++;
-
-  return lineCount;
-};
-
-export const search = async (
-  filePath: string,
-  fieldType: FieldType,
-  operator: ComparisonOperator | ComparisonOperator[],
-  comparedAtValue:
-    | string
-    | number
-    | boolean
-    | null
-    | (string | number | boolean | null)[],
-  logicalOperator?: "and" | "or",
-  limit?: number,
-  offset?: number,
-  readWholeFile?: boolean
-): Promise<
-  [
-    Record<
-      number,
-      Record<
-        string,
-        string | number | boolean | (string | number | boolean | null)[] | null
-      >
-    > | null,
-    number
-  ]
-> => {
-  const handleComparisonOperator = (
-    operator: ComparisonOperator,
-    value:
-      | string
-      | number
-      | boolean
-      | null
-      | (string | number | boolean | null)[],
-    comparedAtValue:
-      | string
-      | number
-      | boolean
-      | null
-      | (string | number | boolean | null)[],
-    fieldType: FieldType
-  ): boolean => {
-    // check if not array or object
-    switch (operator) {
-      case "=":
-        return fieldType === "password" &&
-          typeof value === "string" &&
-          typeof comparedAtValue === "string"
-          ? Utils.comparePassword(value, comparedAtValue)
-          : value === comparedAtValue;
-      case "!=":
-        return !handleComparisonOperator(
-          "=",
-          value,
-          comparedAtValue,
-          fieldType
-        );
-      case ">":
-        return (
-          value !== null && comparedAtValue !== null && value > comparedAtValue
-        );
-      case "<":
-        return (
-          value !== null && comparedAtValue !== null && value < comparedAtValue
-        );
-      case ">=":
-        return (
-          value !== null && comparedAtValue !== null && value >= comparedAtValue
-        );
-      case "<=":
-        return (
-          value !== null && comparedAtValue !== null && value <= comparedAtValue
-        );
-      case "[]":
-        return (
-          (Array.isArray(value) &&
-            Array.isArray(comparedAtValue) &&
-            value.some(comparedAtValue.includes)) ||
-          (Array.isArray(value) &&
-            !Array.isArray(comparedAtValue) &&
-            value.includes(comparedAtValue)) ||
-          (!Array.isArray(value) &&
-            Array.isArray(comparedAtValue) &&
-            comparedAtValue.includes(value))
-        );
-      case "![]":
-        return !handleComparisonOperator(
-          "[]",
-          value,
-          comparedAtValue,
-          fieldType
-        );
-      case "*":
-        return (
-          value !== null &&
-          comparedAtValue !== null &&
-          new RegExp(
-            `^${comparedAtValue.toString().replace(/%/g, ".*")}$`,
-            "i"
-          ).test(value.toString())
-        );
-      case "!*":
-        return !handleComparisonOperator(
-          "*",
-          value,
-          comparedAtValue,
-          fieldType
-        );
-      default:
-        throw new Error(operator);
-    }
-  };
-
-  let RETURN: Record<
-      number,
-      Record<
-        string,
-        string | number | boolean | null | (string | number | boolean | null)[]
-      >
-    > = {},
-    lineCount = 0,
-    foundItems = 0;
-
-  const file = await open(filePath),
-    columnName = decodeFileName(parse(filePath).name);
-
-  for await (const line of file.readLines()) {
-    lineCount++;
-    const decodedLine = Utils.decode(line, fieldType);
-    if (
-      decodedLine &&
-      ((Array.isArray(operator) &&
-        Array.isArray(comparedAtValue) &&
-        ((logicalOperator &&
-          logicalOperator === "or" &&
-          operator.some((single_operator, index) =>
-            handleComparisonOperator(
-              single_operator,
-              decodedLine,
-              comparedAtValue[index],
-              fieldType
-            )
-          )) ||
-          operator.every((single_operator, index) =>
-            handleComparisonOperator(
-              single_operator,
-              decodedLine,
-              comparedAtValue[index],
-              fieldType
-            )
-          ))) ||
-        (!Array.isArray(operator) &&
-          handleComparisonOperator(
-            operator,
-            decodedLine,
-            comparedAtValue,
-            fieldType
-          )))
-    ) {
-      foundItems++;
-      if (offset && foundItems < offset) continue;
-      if (limit && foundItems > limit)
-        if (readWholeFile) continue;
-        else break;
-      if (!RETURN[lineCount]) RETURN[lineCount] = {};
-      RETURN[lineCount][columnName] = decodedLine;
-    }
-  }
-  if (foundItems) {
-    return [RETURN, readWholeFile ? foundItems : foundItems - 1];
-  } else return [null, 0];
-};
-
-export default class File {
-  static get = get;
-  static count = count;
-  static remove = remove;
-  static search = search;
-  static replace = replace;
-  static encodeFileName = encodeFileName;
-  static decodeFileName = decodeFileName;
-}