inibase 1.0.0-rc.3 → 1.0.0-rc.5

package/README.md

@@ -1,8 +1,8 @@
-![Inibase banner](./.github/assets/banner.jpg)
+[![Inibase banner](./.github/assets/banner.jpg)](https://github.com/inicontent/inibase)
 
 # Inibase :pencil:
 
-[![npmjs](https://img.shields.io/npm/dm/inibase.svg?style=flat)](https://www.npmjs.org/package/inibase) [![Node.js Version](https://img.shields.io/badge/node-18.11.0-blue)](https://nodejs.org/) [![License](https://img.shields.io/github/license/inicontent/inibase.svg?style=flat&colorA=18181B&colorB=28CF8D)](./LICENSE) [![Activity](https://img.shields.io/github/commit-activity/m/inicontent/inibase)](https://github.com/inicontent/inibase/pulse) [![GitHub stars](https://img.shields.io/github/stars/inicontent/inibase?style=social)](https://github.com/inicontent/inibase)
+[![npmjs](https://img.shields.io/npm/dm/inibase.svg?style=flat)](https://www.npmjs.org/package/inibase) [![License](https://img.shields.io/github/license/inicontent/inibase.svg?style=flat&colorA=18181B&colorB=28CF8D)](./LICENSE) [![Activity](https://img.shields.io/github/commit-activity/m/inicontent/inibase)](https://github.com/inicontent/inibase/pulse) [![GitHub stars](https://img.shields.io/github/stars/inicontent/inibase?style=social)](https://github.com/inicontent/inibase)
 
 > File-based relational database, simple to use and can handle large data :fire:
 
@@ -21,7 +21,7 @@
 
 ```js
 import Inibase from "inibase";
-const db = new Inibase("/database_name");
+const db = new Inibase("database_name");
 
 // Get all items from "user" table
 const users = await db.get("user");
@@ -30,12 +30,12 @@ const users = await db.get("user");
 const users = await db.get("user", undefined, { page: 2, per_page: 15 });
 
 // Get only required columns to improve speed
-const users = await InibaseDB.get("user", undefined, {
+const users = await db.get("user", undefined, {
   columns: ["username", "address.street", "hobbies.*.name"],
 });
 
 // Get items from "user" table where "favoriteFoods" does not includes "Pizza"
-const users = await InibaseDB.get("user", { favoriteFoods: "![]Pizza" });
+const users = await db.get("user", { favoriteFoods: "![]Pizza" });
 ```
 
 If you like Inibase, please sponsor: [GitHub Sponsors](https://github.com/sponsors/inicontent) || [Paypal](https://paypal.me/KarimAmahtil).
@@ -342,6 +342,11 @@ const users = await db.get("user", { favoriteFoods: "[]Pizza" });
 //   },
 //   ...
 // ]
+
+// Get all "user" columns except "username" & "address.street"
+const users = await db.get("user", undefined, {
+  columns: ["!username", "!address.street"],
+});
 ```
 
 </details>
@@ -445,7 +450,7 @@ type Data = {
     - [x] Pagination
     - [x] Criteria
     - [x] Columns
-    - [ ] Order
+    - [ ] Order By
   - [x] POST
   - [x] PUT
   - [x] DELETE
@@ -461,6 +466,11 @@ type Data = {
   - [x] Array
   - [x] Password
   - [ ] IP
+  - [ ] HTML
+  - [ ] Markdown
+- [ ] TO-DO:
+  - [ ] Improve caching
+  - [ ] Commenting the code
 - [ ] Features:
   - [ ] Encryption
   - [ ] Compress data

package/file.ts

@@ -1,9 +1,22 @@
-import { createWriteStream, unlinkSync, renameSync, existsSync } from "fs";
+import {
+  createWriteStream,
+  unlinkSync,
+  renameSync,
+  existsSync,
+  createReadStream,
+  WriteStream,
+} from "fs";
 import { open } from "fs/promises";
+import { Interface, createInterface } from "readline";
 import { parse } from "path";
 import { ComparisonOperator, FieldType } from ".";
 import Utils from "./utils";
 
+const doesSupportReadLines = () => {
+  const [major, minor, patch] = process.versions.node.split(".").map(Number);
+  return major >= 18 && minor >= 11;
+};
+
 export const encodeFileName = (fileName: string, extension?: string) => {
   return (
     fileName.replaceAll("%", "%25").replaceAll("*", "%") +
@@ -15,12 +28,99 @@ export const decodeFileName = (fileName: string) => {
   return fileName.replaceAll("%", "*").replaceAll("*25", "%");
 };
 
+export const encode = (
+  input: string | number | boolean | null | (string | number | boolean | null)[]
+) => {
+  const secureString = (input: string | number | boolean | null) => {
+    if (["true", "false"].includes(String(input))) return input ? 1 : 0;
+    return typeof input === "string"
+      ? decodeURIComponent(input)
+          .replaceAll("<", "&lt;")
+          .replaceAll(">", "&gt;")
+          .replaceAll(",", "%2C")
+          .replaceAll("|", "%7C")
+          .replaceAll("\n", "\\n")
+          .replaceAll("\r", "\\r")
+      : input;
+  };
+  return Array.isArray(input)
+    ? Utils.isArrayOfArrays(input)
+      ? (input as any[])
+          .map((_input) => _input.map(secureString).join(","))
+          .join("|")
+      : input.map(secureString).join(",")
+    : secureString(input);
+};
+
+export const decode = (
+  input: string | null | number,
+  fieldType?: FieldType | FieldType[],
+  fieldChildrenType?: FieldType | FieldType[]
+): string | number | boolean | null | (string | number | null | boolean)[] => {
+  if (!fieldType) return null;
+  const unSecureString = (input: string) =>
+    decodeURIComponent(input)
+      .replaceAll("&lt;", "<")
+      .replaceAll("&gt;", ">")
+      .replaceAll("%2C", ",")
+      .replaceAll("%7C", "|")
+      .replaceAll("\\n", "\n")
+      .replaceAll("\\r", "\r") || null;
+  if (input === null || input === "") return null;
+  if (Array.isArray(fieldType))
+    fieldType = Utils.detectFieldType(String(input), fieldType);
+  const decodeHelper = (value: string | number | any[]) => {
+    if (Array.isArray(value) && fieldType !== "array")
+      return value.map(decodeHelper);
+    switch (fieldType as FieldType) {
+      case "table":
+      case "number":
+        return isNaN(Number(value)) ? null : Number(value);
+      case "boolean":
+        return typeof value === "string" ? value === "true" : Boolean(value);
+      case "array":
+        if (!Array.isArray(value)) return null;
+        if (fieldChildrenType)
+          return value.map(
+            (v) =>
+              decode(
+                v,
+                Array.isArray(fieldChildrenType)
+                  ? Utils.detectFieldType(v, fieldChildrenType)
+                  : fieldChildrenType
+              ) as string | number | boolean | null
+          );
+        else return value;
+      default:
+        return value;
+    }
+  };
+  return decodeHelper(
+    typeof input === "string"
+      ? input.includes(",")
+        ? input.includes("|")
+          ? input
+              .split("|")
+              .map((_input) => _input.split(",").map(unSecureString))
+          : input.split(",").map(unSecureString)
+        : unSecureString(input)
+      : input
+  );
+};
+
 export const get = async (
   filePath: string,
-  fieldType?: FieldType,
-  lineNumbers?: number | number[]
+  lineNumbers?: number | number[],
+  fieldType?: FieldType | FieldType[],
+  fieldChildrenType?: FieldType | FieldType[]
 ) => {
-  const file = await open(filePath);
+  let rl: Interface;
+  if (doesSupportReadLines()) rl = (await open(filePath)).readLines();
+  else
+    rl = createInterface({
+      input: createReadStream(filePath),
+      crlfDelay: Infinity,
+    });
   let lines: Record<
       number,
       | string
@@ -32,21 +132,23 @@ export const get = async (
     lineCount = 0;
 
   if (!lineNumbers) {
-    for await (const line of file.readLines())
-      lineCount++, (lines[lineCount] = Utils.decode(line, fieldType));
+    for await (const line of rl)
+      lineCount++,
+        (lines[lineCount] = decode(line, fieldType, fieldChildrenType));
   } else if (lineNumbers === -1) {
-    let lastLine;
-    for await (const line of file.readLines()) lineCount++, (lastLine = line);
-    if (lastLine) lines = { [lineCount]: Utils.decode(lastLine, fieldType) };
+    let lastLine: string;
+    for await (const line of rl) lineCount++, (lastLine = line);
+    if (lastLine)
+      lines = { [lineCount]: decode(lastLine, fieldType, fieldChildrenType) };
   } else {
     let lineNumbersArray = [
       ...(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]),
     ];
-    for await (const line of file.readLines()) {
+    for await (const line of rl) {
       lineCount++;
       if (!lineNumbersArray.includes(lineCount)) continue;
       const indexOfLineCount = lineNumbersArray.indexOf(lineCount);
-      lines[lineCount] = Utils.decode(line, fieldType);
+      lines[lineCount] = decode(line, fieldType, fieldChildrenType);
       lineNumbersArray[indexOfLineCount] = 0;
       if (!lineNumbersArray.filter((lineN) => lineN !== 0).length) break;
     }
@@ -69,33 +171,43 @@ export const replace = async (
       >
 ) => {
   if (existsSync(filePath)) {
-    const file = await open(filePath, "w+"),
+    let rl: Interface, writeStream: WriteStream;
+    if (doesSupportReadLines()) {
+      const file = await open(filePath, "w+");
+      rl = file.readLines();
       writeStream = file.createWriteStream();
+    } else {
+      rl = createInterface({
+        input: createReadStream(filePath),
+        crlfDelay: Infinity,
+      });
+      writeStream = createWriteStream(filePath);
+    }
     if (typeof replacements === "object" && !Array.isArray(replacements)) {
       let lineCount = 0;
-      for await (const line of file.readLines()) {
+      for await (const line of rl) {
         lineCount++;
         writeStream.write(
-          (lineCount in replacements
-            ? Utils.encode(replacements[lineCount])
-            : line) + "\n"
+          (lineCount in replacements ? encode(replacements[lineCount]) : line) +
+            "\n"
         );
       }
     } else
-      for await (const _line of file.readLines())
-        writeStream.write(Utils.encode(replacements) + "\n");
+      for await (const _line of rl)
+        writeStream.write(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;
+    let writeStream: WriteStream;
+    if (doesSupportReadLines())
+      writeStream = (await open(filePath, "w")).createWriteStream();
+    else writeStream = createWriteStream(filePath);
+    const 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"
+        (lineCount in replacements ? encode(replacements[lineCount]) : "") +
+          "\n"
       );
     }
     writeStream.end();
@@ -111,11 +223,21 @@ export const remove = async (
   const tempFilePath = `${filePath}.tmp`,
     linesToDeleteArray = [
       ...(Array.isArray(linesToDelete) ? linesToDelete : [linesToDelete]),
-    ],
-    writeStream = createWriteStream(tempFilePath),
-    file = await open(filePath);
+    ];
+
+  let rl: Interface, writeStream: WriteStream;
+  if (doesSupportReadLines()) {
+    rl = (await open(filePath)).readLines();
+    writeStream = (await open(tempFilePath, "w+")).createWriteStream();
+  } else {
+    rl = createInterface({
+      input: createReadStream(filePath),
+      crlfDelay: Infinity,
+    });
+    writeStream = createWriteStream(tempFilePath);
+  }
 
-  for await (const line of file.readLines()) {
+  for await (const line of rl) {
     lineCount++;
     if (!linesToDeleteArray.includes(lineCount)) {
       writeStream.write(`${line}\n`);
@@ -129,18 +251,22 @@ export const remove = async (
 };
 
 export const count = async (filePath: string): Promise<number> => {
-  let lineCount = 0;
-
-  const file = await open(filePath);
+  let lineCount = 0,
+    rl: Interface;
+  if (doesSupportReadLines()) rl = (await open(filePath)).readLines();
+  else
+    rl = createInterface({
+      input: createReadStream(filePath),
+      crlfDelay: Infinity,
+    });
 
-  for await (const line of file.readLines()) lineCount++;
+  for await (const line of rl) lineCount++;
 
   return lineCount;
 };
 
 export const search = async (
   filePath: string,
-  fieldType: FieldType,
   operator: ComparisonOperator | ComparisonOperator[],
   comparedAtValue:
     | string
@@ -149,6 +275,8 @@ export const search = async (
     | null
     | (string | number | boolean | null)[],
   logicalOperator?: "and" | "or",
+  fieldType?: FieldType | FieldType[],
+  fieldChildrenType?: FieldType | FieldType[],
   limit?: number,
   offset?: number,
   readWholeFile?: boolean
@@ -166,7 +294,7 @@ export const search = async (
 > => {
   const handleComparisonOperator = (
     operator: ComparisonOperator,
-    value:
+    originalValue:
       | string
       | number
       | boolean
@@ -178,71 +306,91 @@ export const search = async (
       | boolean
       | null
       | (string | number | boolean | null)[],
-    fieldType: FieldType
+    fieldType?: FieldType | FieldType[],
+    fieldChildrenType?: FieldType | FieldType[]
   ): boolean => {
-    // check if not array or object
+    if (Array.isArray(fieldType))
+      fieldType = Utils.detectFieldType(String(originalValue), fieldType);
+    // check if not array or object // it can't be array or object!
     switch (operator) {
       case "=":
-        return fieldType === "password" &&
-          typeof value === "string" &&
-          typeof comparedAtValue === "string"
-          ? Utils.comparePassword(value, comparedAtValue)
-          : value === comparedAtValue;
+        switch (fieldType) {
+          case "password":
+            return typeof originalValue === "string" &&
+              typeof comparedAtValue === "string"
+              ? Utils.comparePassword(originalValue, comparedAtValue)
+              : false;
+          case "boolean":
+            return Number(originalValue) - Number(comparedAtValue) === 0;
+          default:
+            return Array.isArray(comparedAtValue)
+              ? comparedAtValue.some((value) => originalValue === value)
+              : originalValue === comparedAtValue;
+        }
       case "!=":
         return !handleComparisonOperator(
           "=",
-          value,
+          originalValue,
           comparedAtValue,
           fieldType
         );
       case ">":
-        return (
-          value !== null && comparedAtValue !== null && value > comparedAtValue
-        );
+        return Array.isArray(comparedAtValue)
+          ? comparedAtValue.some((value) => originalValue > value)
+          : originalValue > comparedAtValue;
       case "<":
-        return (
-          value !== null && comparedAtValue !== null && value < comparedAtValue
-        );
+        return Array.isArray(comparedAtValue)
+          ? comparedAtValue.some((value) => originalValue < value)
+          : originalValue < comparedAtValue;
       case ">=":
-        return (
-          value !== null && comparedAtValue !== null && value >= comparedAtValue
-        );
+        return Array.isArray(comparedAtValue)
+          ? comparedAtValue.some((value) => originalValue >= value)
+          : originalValue >= comparedAtValue;
       case "<=":
-        return (
-          value !== null && comparedAtValue !== null && value <= comparedAtValue
-        );
+        return Array.isArray(comparedAtValue)
+          ? comparedAtValue.some((value) => originalValue <= value)
+          : originalValue <= comparedAtValue;
       case "[]":
         return (
-          (Array.isArray(value) &&
+          (Array.isArray(originalValue) &&
             Array.isArray(comparedAtValue) &&
-            value.some(comparedAtValue.includes)) ||
-          (Array.isArray(value) &&
+            originalValue.some(comparedAtValue.includes)) ||
+          (Array.isArray(originalValue) &&
             !Array.isArray(comparedAtValue) &&
-            value.includes(comparedAtValue)) ||
-          (!Array.isArray(value) &&
+            originalValue.includes(comparedAtValue)) ||
+          (!Array.isArray(originalValue) &&
             Array.isArray(comparedAtValue) &&
-            comparedAtValue.includes(value))
+            comparedAtValue.includes(originalValue))
         );
       case "![]":
         return !handleComparisonOperator(
           "[]",
-          value,
+          originalValue,
           comparedAtValue,
           fieldType
         );
       case "*":
-        return (
-          value !== null &&
-          comparedAtValue !== null &&
-          new RegExp(
-            `^${comparedAtValue.toString().replace(/%/g, ".*")}$`,
-            "i"
-          ).test(value.toString())
-        );
+        return Array.isArray(comparedAtValue)
+          ? comparedAtValue.some((value) =>
+              new RegExp(
+                `^${(String(value).includes("%")
+                  ? String(value)
+                  : "%" + String(value) + "%"
+                ).replace(/%/g, ".*")}$`,
+                "i"
+              ).test(String(originalValue))
+            )
+          : new RegExp(
+              `^${(String(comparedAtValue).includes("%")
+                ? String(comparedAtValue)
+                : "%" + String(comparedAtValue) + "%"
+              ).replace(/%/g, ".*")}$`,
+              "i"
+            ).test(String(originalValue));
       case "!*":
         return !handleComparisonOperator(
           "*",
-          value,
+          originalValue,
           comparedAtValue,
           fieldType
         );
@@ -260,16 +408,21 @@ export const search = async (
     > = {},
     lineCount = 0,
     foundItems = 0;
+  let rl: Interface;
+  if (doesSupportReadLines()) rl = (await open(filePath)).readLines();
+  else
+    rl = createInterface({
+      input: createReadStream(filePath),
+      crlfDelay: Infinity,
+    });
 
-  const file = await open(filePath),
-    columnName = decodeFileName(parse(filePath).name);
+  const columnName = decodeFileName(parse(filePath).name);
 
-  for await (const line of file.readLines()) {
+  for await (const line of rl) {
     lineCount++;
-    const decodedLine = Utils.decode(line, fieldType);
+    const decodedLine = decode(line, fieldType, fieldChildrenType);
     if (
-      decodedLine &&
-      ((Array.isArray(operator) &&
+      (Array.isArray(operator) &&
         Array.isArray(comparedAtValue) &&
         ((logicalOperator &&
           logicalOperator === "or" &&
@@ -289,13 +442,13 @@ export const search = async (
               fieldType
             )
           ))) ||
-        (!Array.isArray(operator) &&
-          handleComparisonOperator(
-            operator,
-            decodedLine,
-            comparedAtValue,
-            fieldType
-          )))
+      (!Array.isArray(operator) &&
+        handleComparisonOperator(
+          operator,
+          decodedLine,
+          comparedAtValue,
+          fieldType
+        ))
     ) {
       foundItems++;
       if (offset && foundItems < offset) continue;
@@ -313,10 +466,12 @@ export const search = async (
 
 export default class File {
   static get = get;
-  static count = count;
   static remove = remove;
   static search = search;
   static replace = replace;
+  static count = count;
+  static encode = encode;
+  static decode = decode;
   static encodeFileName = encodeFileName;
   static decodeFileName = decodeFileName;
 }