inibase 1.0.0-rc.4 → 1.0.0-rc.40

package/dist/utils.server.d.ts

@@ -0,0 +1,103 @@
+/// <reference types="node" resolution-mode="require"/>
+import { type Schema } from "./index.js";
+/**
+ * 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 declare const hashPassword: (password: string) => string;
+/**
+ * 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 declare const comparePassword: (hashedPassword: string, inputPassword: string) => boolean;
+/**
+ * Encodes an ID using AES-256-CBC encryption.
+ *
+ * @param id - The ID to encode, either a number or a string.
+ * @param secretKeyOrSalt - The secret key or salt for encryption, can be a string, number, or Buffer.
+ * @returns The encoded ID as a hexadecimal string.
+ */
+export declare const encodeID: (id: number | string, secretKeyOrSalt: string | number | Buffer) => string;
+/**
+ * Decodes an encrypted ID using AES-256-CBC decryption.
+ *
+ * @param input - The encrypted ID as a hexadecimal string.
+ * @param secretKeyOrSalt - The secret key or salt used for decryption, can be a string, number, or Buffer.
+ * @returns The decoded ID as a number.
+ */
+export declare const decodeID: (input: string, secretKeyOrSalt: string | number | Buffer) => number;
+/**
+ * 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 declare const findLastIdNumber: (schema: Schema, secretKeyOrSalt: string | number | Buffer) => number;
+/**
+ * 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 declare const addIdToSchema: (schema: Schema, oldIndex: number | undefined, secretKeyOrSalt: string | number | Buffer, encodeIDs?: boolean) => (({
+    id?: string | number | undefined;
+    key: string;
+    required?: boolean | undefined;
+} & {
+    type: "string" | "number" | "boolean" | "id" | "url" | "html" | "table" | "email" | "json" | "date" | "password" | "ip";
+    children?: undefined;
+}) | ({
+    id?: string | number | undefined;
+    key: string;
+    required?: boolean | undefined;
+} & {
+    type: "object";
+    children: Schema;
+}) | ({
+    id?: string | number | undefined;
+    key: string;
+    required?: boolean | undefined;
+} & {
+    type: "array";
+    children: "string" | "number" | "boolean" | "object" | "id" | "url" | "html" | "table" | "email" | "json" | "date" | "password" | "ip" | Schema | ("string" | "number" | "boolean" | "object" | "id" | "url" | "html" | "table" | "email" | "json" | "date" | "password" | "ip")[];
+}))[];
+export declare const hashString: (str: string) => string;
+export default class UtilsServer {
+    static encodeID: (id: string | number, secretKeyOrSalt: string | number | Buffer) => string;
+    static decodeID: (input: string, secretKeyOrSalt: string | number | Buffer) => number;
+    static hashPassword: (password: string) => string;
+    static comparePassword: (hashedPassword: string, inputPassword: string) => boolean;
+    static findLastIdNumber: (schema: Schema, secretKeyOrSalt: string | number | Buffer) => number;
+    static addIdToSchema: (schema: Schema, oldIndex: number | undefined, secretKeyOrSalt: string | number | Buffer, encodeIDs?: boolean | undefined) => (({
+        id?: string | number | undefined;
+        key: string;
+        required?: boolean | undefined;
+    } & {
+        type: "string" | "number" | "boolean" | "id" | "url" | "html" | "table" | "email" | "json" | "date" | "password" | "ip";
+        children?: undefined;
+    }) | ({
+        id?: string | number | undefined;
+        key: string;
+        required?: boolean | undefined;
+    } & {
+        type: "object";
+        children: Schema;
+    }) | ({
+        id?: string | number | undefined;
+        key: string;
+        required?: boolean | undefined;
+    } & {
+        type: "array";
+        children: "string" | "number" | "boolean" | "object" | "id" | "url" | "html" | "table" | "email" | "json" | "date" | "password" | "ip" | Schema | ("string" | "number" | "boolean" | "object" | "id" | "url" | "html" | "table" | "email" | "json" | "date" | "password" | "ip")[];
+    }))[];
+    static hashString: (str: string) => string;
+}

package/dist/utils.server.js

@@ -0,0 +1,122 @@
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync, createHash, } from "node:crypto";
+import { isArrayOfObjects, isNumber, isValidID } from "./utils.js";
+/**
+ * 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 = (hashedPassword, inputPassword) => {
+    const [salt, originalHash] = hashedPassword.split(":");
+    const inputHash = createHash("sha256")
+        .update(inputPassword + salt)
+        .digest("hex");
+    return inputHash === originalHash;
+};
+/**
+ * Encodes an ID using AES-256-CBC encryption.
+ *
+ * @param id - The ID to encode, either a number or a string.
+ * @param secretKeyOrSalt - The secret key or salt for encryption, can be a string, number, or Buffer.
+ * @returns The encoded ID as a hexadecimal string.
+ */
+export const encodeID = (id, secretKeyOrSalt) => {
+    let cipher;
+    if (Buffer.isBuffer(secretKeyOrSalt))
+        cipher = createCipheriv("aes-256-cbc", secretKeyOrSalt, secretKeyOrSalt.subarray(0, 16));
+    else {
+        const salt = scryptSync(secretKeyOrSalt.toString(), (process.env.INIBASE_SECRET ?? "inibase") + "_salt", 32);
+        cipher = createCipheriv("aes-256-cbc", salt, salt.subarray(0, 16));
+    }
+    return cipher.update(id.toString(), "utf8", "hex") + cipher.final("hex");
+};
+/**
+ * Decodes an encrypted ID using AES-256-CBC decryption.
+ *
+ * @param input - The encrypted ID as a hexadecimal string.
+ * @param secretKeyOrSalt - The secret key or salt used for decryption, can be a string, number, or Buffer.
+ * @returns The decoded ID as a number.
+ */
+export const decodeID = (input, secretKeyOrSalt) => {
+    let decipher;
+    if (Buffer.isBuffer(secretKeyOrSalt))
+        decipher = createDecipheriv("aes-256-cbc", secretKeyOrSalt, secretKeyOrSalt.subarray(0, 16));
+    else {
+        const salt = scryptSync(secretKeyOrSalt.toString(), (process.env.INIBASE_SECRET ?? "inibase") + "_salt", 32);
+        decipher = createDecipheriv("aes-256-cbc", salt, salt.subarray(0, 16));
+    }
+    return Number(decipher.update(input, "hex", "utf8") + decipher.final("utf8"));
+};
+/**
+ * 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) => {
+    const lastField = schema[schema.length - 1];
+    if (lastField) {
+        if ((lastField.type === "array" || lastField.type === "object") &&
+            isArrayOfObjects(lastField.children))
+            return findLastIdNumber(lastField.children, secretKeyOrSalt);
+        else if (lastField.id)
+            return isValidID(lastField.id)
+                ? decodeID(lastField.id, secretKeyOrSalt)
+                : lastField.id;
+    }
+    return 0;
+};
+/**
+ * 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, oldIndex = 0, secretKeyOrSalt, encodeIDs) => schema.map((field) => {
+    if (!field.id) {
+        oldIndex++;
+        field.id = encodeIDs ? encodeID(oldIndex, secretKeyOrSalt) : oldIndex;
+    }
+    else {
+        if (!isNumber(field.id))
+            oldIndex = decodeID(field.id, secretKeyOrSalt);
+        else {
+            oldIndex = field.id;
+            field.id = encodeIDs ? encodeID(field.id, secretKeyOrSalt) : field.id;
+        }
+    }
+    if ((field.type === "array" || field.type === "object") &&
+        isArrayOfObjects(field.children)) {
+        field.children = addIdToSchema(field.children, oldIndex, secretKeyOrSalt, encodeIDs);
+        oldIndex += field.children.length;
+    }
+    return field;
+});
+export const hashString = (str) => createHash("sha256").update(str).digest("hex");
+export default class UtilsServer {
+    static encodeID = encodeID;
+    static decodeID = decodeID;
+    static hashPassword = hashPassword;
+    static comparePassword = comparePassword;
+    static findLastIdNumber = findLastIdNumber;
+    static addIdToSchema = addIdToSchema;
+    static hashString = hashString;
+}

package/package.json

@@ -1,37 +1,88 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.4",
-  "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.40",
+  "author": {
+    "name": "Karim Amahtil",
+    "email": "karim.amahtil@gmail.com"
   },
+  "repository": "inicontent/inibase",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./thread": "./dist/index.thread.js",
+    "./file": "./dist/file.js",
+    "./file.thread": "./dist/file.thread.js",
+    "./config": "./dist/config.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",
+    "sqlite",
+    "sql",
+    "supabase",
+    "better-sqlite",
     "mongodb",
+    "firebase",
+    "postgresql",
+    "rdms",
     "database",
+    "db",
+    "mongoose",
     "relational",
     "local",
+    "file",
     "storage",
     "json",
-    "sql",
-    "sqlite",
-    "supabase",
-    "firebase"
+    "pocketbase"
   ],
-  "author": "Inicontent",
   "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/inicontent/inibase/issues"
+  "type": "module",
+  "types": "./dist",
+  "typesVersions": {
+    "*": {
+      "thread": [
+        "./dist/index.thread.d.ts"
+      ],
+      "file": [
+        "./dist/file.d.ts"
+      ],
+      "file.thread": [
+        "./dist/file.thread.d.ts"
+      ],
+      "utils": [
+        "./dist/utils.d.ts"
+      ],
+      "config": [
+        "./dist/config.d.ts"
+      ],
+      "utils.server": [
+        "./dist/utils.server.d.ts"
+      ]
+    }
   },
-  "homepage": "https://github.com/inicontent/inibase#readme",
   "devDependencies": {
-    "@types/node": "^20.6.0"
+    "@types/node": "^20.10.6",
+    "tinybench": "^2.6.0",
+    "typescript": "^5.3.3"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "npx tsc",
+    "test": "npx tsx watch --expose-gc --env-file=.env ./index.test",
+    "benchmark": "npx tsx watch --env-file=.env ./benchmark/index",
+    "benchmark:single": "npx tsx --expose-gc --env-file=.env ./benchmark/single",
+    "benchmark:bulk": "npx tsx --expose-gc --env-file=.env ./benchmark/bulk"
   }
 }

package/file.ts

@@ -1,327 +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 "=":
-        switch (fieldType) {
-          case "password":
-            return typeof value === "string" &&
-              typeof comparedAtValue === "string"
-              ? Utils.comparePassword(value, comparedAtValue)
-              : false;
-          case "boolean":
-            return Number(value) - Number(comparedAtValue) === 0;
-          default:
-            return 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 (
-      (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;
-}