inibase 1.0.0-rc.0 → 1.0.0-rc.11

package/file.ts

@@ -1,26 +1,195 @@
-import { createWriteStream, unlinkSync, renameSync, existsSync } from "fs";
-import { open } from "fs/promises";
-import { parse } from "path";
+import { createWriteStream, createReadStream, WriteStream } from "node:fs";
+import { open, unlink, rename, stat } from "node:fs/promises";
+import { Interface, createInterface } from "node:readline";
+import { parse } from "node:path";
 import { ComparisonOperator, FieldType } from ".";
-import Utils from "./utils";
+import { detectFieldType, isArrayOfArrays, isNumber } from "./utils";
+import { encodeID, comparePassword } from "./utils.server";
 
-export const encodeFileName = (fileName: string, extension?: string) => {
-  return (
-    fileName.replaceAll("%", "%25").replaceAll("*", "%") +
-    (extension ? `.${extension}` : "")
-  );
+const doesSupportReadLines = () => {
+  const [major, minor, patch] = process.versions.node.split(".").map(Number);
+  return major >= 18 && minor >= 11;
 };
 
-export const decodeFileName = (fileName: string) => {
-  return fileName.replaceAll("%", "*").replaceAll("*25", "%");
+export const isExists = async (path: string) => {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const delimiters = [",", "|", "&", "$", "#", "@", "^", "%", ":", "!", ";"];
+
+export const encode = (
+  input:
+    | string
+    | number
+    | boolean
+    | null
+    | (string | number | boolean | null)[],
+  secretKey?: string | Buffer
+) => {
+  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("&", "%26")
+            .replaceAll("$", "%24")
+            .replaceAll("#", "%23")
+            .replaceAll("@", "%40")
+            .replaceAll("^", "%5E")
+            .replaceAll("%", "%25")
+            .replaceAll(":", "%3A")
+            .replaceAll("!", "%21")
+            .replaceAll(";", "%3B")
+            .replaceAll("\n", "\\n")
+            .replaceAll("\r", "\\r")
+        : input;
+    },
+    secureArray = (arr_str: any[] | any): any[] | any =>
+      Array.isArray(arr_str) ? arr_str.map(secureArray) : secureString(arr_str),
+    joinMultidimensionalArray = (
+      arr: any[] | any[][],
+      delimiter_index = 0
+    ): string => {
+      delimiter_index++;
+      if (isArrayOfArrays(arr))
+        arr = arr.map((ar: any[]) =>
+          joinMultidimensionalArray(ar, delimiter_index)
+        );
+      delimiter_index--;
+      return arr.join(delimiters[delimiter_index]);
+    };
+  return Array.isArray(input)
+    ? joinMultidimensionalArray(secureArray(input))
+    : secureString(input);
+};
+
+export const decode = (
+  input: string | null | number,
+  fieldType?: FieldType | FieldType[],
+  fieldChildrenType?: FieldType | FieldType[],
+  secretKey?: string | Buffer
+): 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("%26", "&")
+        .replaceAll("%24", "$")
+        .replaceAll("%23", "#")
+        .replaceAll("%40", "@")
+        .replaceAll("%5E", "^")
+        .replaceAll("%25", "%")
+        .replaceAll("%3A", ":")
+        .replaceAll("%21", "!")
+        .replaceAll("%3B", ";")
+        .replaceAll("\\n", "\n")
+        .replaceAll("\\r", "\r") || null,
+    unSecureArray = (arr_str: any[] | any): any[] | any =>
+      Array.isArray(arr_str)
+        ? arr_str.map(unSecureArray)
+        : unSecureString(arr_str),
+    reverseJoinMultidimensionalArray = (
+      joinedString: string | any[] | any[][]
+    ): any | any[] | any[][] => {
+      const reverseJoinMultidimensionalArrayHelper = (
+        arr: any | any[] | any[][],
+        delimiter: string
+      ) =>
+        Array.isArray(arr)
+          ? arr.map((ar: any) =>
+              reverseJoinMultidimensionalArrayHelper(ar, delimiter)
+            )
+          : arr.split(delimiter);
+
+      const availableDelimiters = delimiters.filter((delimiter) =>
+        joinedString.includes(delimiter)
+      );
+      for (const delimiter of availableDelimiters) {
+        joinedString = Array.isArray(joinedString)
+          ? reverseJoinMultidimensionalArrayHelper(joinedString, delimiter)
+          : joinedString.split(delimiter);
+      }
+      return joinedString;
+    },
+    decodeHelper = (value: string | number | any[]) => {
+      if (Array.isArray(value) && fieldType !== "array")
+        return value.map(decodeHelper);
+      switch (fieldType as FieldType) {
+        case "table":
+        case "number":
+          return isNumber(value) ? Number(value) : null;
+        case "boolean":
+          return typeof value === "string" ? value === "true" : Boolean(value);
+        case "array":
+          if (!Array.isArray(value)) return [value];
+
+          if (fieldChildrenType)
+            return value.map(
+              (v) =>
+                decode(
+                  v,
+                  Array.isArray(fieldChildrenType)
+                    ? detectFieldType(v, fieldChildrenType)
+                    : fieldChildrenType,
+                  undefined,
+                  secretKey
+                ) as string | number | boolean | null
+            );
+          else return value;
+        case "id":
+          return isNumber(value) ? encodeID(value as number, secretKey) : value;
+        default:
+          return value;
+      }
+    };
+  if (input === null || input === "") return null;
+  if (Array.isArray(fieldType))
+    fieldType = detectFieldType(String(input), fieldType);
+  return decodeHelper(
+    typeof input === "string"
+      ? input.includes(",")
+        ? unSecureArray(reverseJoinMultidimensionalArray(input))
+        : unSecureString(input)
+      : input
+  );
 };
 
 export const get = async (
   filePath: string,
-  fieldType?: FieldType,
-  lineNumbers?: number | number[]
-) => {
-  const file = await open(filePath);
+  lineNumbers?: number | number[],
+  fieldType?: FieldType | FieldType[],
+  fieldChildrenType?: FieldType | FieldType[],
+  secretKey?: string | Buffer
+): Promise<
+  [
+    Record<
+      number,
+      | string
+      | number
+      | boolean
+      | (string | number | boolean | (string | number | boolean)[])[]
+    > | null,
+    number
+  ]
+> => {
+  let rl: Interface;
+  if (doesSupportReadLines()) rl = (await open(filePath)).readLines();
+  else
+    rl = createInterface({
+      input: createReadStream(filePath),
+      crlfDelay: Infinity,
+    });
   let lines: Record<
       number,
       | string
@@ -32,27 +201,36 @@ 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,
+          secretKey
+        ));
   } 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, secretKey),
+      };
   } 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, secretKey);
       lineNumbersArray[indexOfLineCount] = 0;
       if (!lineNumbersArray.filter((lineN) => lineN !== 0).length) break;
     }
   }
 
-  return lines ?? null;
+  return [lines ?? null, lineCount];
 };
 
 export const replace = async (
@@ -66,35 +244,48 @@ export const replace = async (
     | Record<
         number,
         string | boolean | number | null | (string | boolean | number | null)[]
-      >
+      >,
+  secretKey?: string | Buffer
 ) => {
-  if (existsSync(filePath)) {
-    const file = await open(filePath, "w+"),
+  if (await isExists(filePath)) {
+    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])
+            ? encode(replacements[lineCount], secretKey)
             : 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, secretKey) + "\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])
+          ? encode(replacements[lineCount], secretKey)
           : "") + "\n"
       );
     }
@@ -108,39 +299,52 @@ export const remove = async (
 ): Promise<void> => {
   let lineCount = 0;
 
-  const tempFilePath = `${filePath}.tmp`,
+  const tempFilePath = `${filePath}-${Date.now()}.tmp`,
     linesToDeleteArray = [
       ...(Array.isArray(linesToDelete) ? linesToDelete : [linesToDelete]),
-    ],
-    writeStream = createWriteStream(tempFilePath),
-    file = await open(filePath);
+    ];
 
-  for await (const line of file.readLines()) {
+  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 rl) {
     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
+  writeStream.end(async () => {
+    await unlink(filePath); // Remove the original file
+    await rename(tempFilePath, filePath); // Rename the temp file to the original file name
   });
 };
 
 export const count = async (filePath: string): Promise<number> => {
-  let lineCount = 0;
+  let lineCount = 0,
+    rl: Interface;
+  if (doesSupportReadLines()) rl = (await open(filePath)).readLines();
+  else
+    rl = createInterface({
+      input: createReadStream(filePath),
+      crlfDelay: Infinity,
+    });
 
-  const file = await open(filePath);
-
-  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,9 +353,12 @@ export const search = async (
     | null
     | (string | number | boolean | null)[],
   logicalOperator?: "and" | "or",
+  fieldType?: FieldType | FieldType[],
+  fieldChildrenType?: FieldType | FieldType[],
   limit?: number,
   offset?: number,
-  readWholeFile?: boolean
+  readWholeFile?: boolean,
+  secretKey?: string | Buffer
 ): Promise<
   [
     Record<
@@ -166,7 +373,7 @@ export const search = async (
 > => {
   const handleComparisonOperator = (
     operator: ComparisonOperator,
-    value:
+    originalValue:
       | string
       | number
       | boolean
@@ -178,71 +385,80 @@ 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 = detectFieldType(String(originalValue), fieldType);
+    if (Array.isArray(comparedAtValue) && !["[]", "![]"].includes(operator))
+      return comparedAtValue.some((comparedAtValueSingle) =>
+        handleComparisonOperator(
+          operator,
+          originalValue,
+          comparedAtValueSingle,
+          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"
+              ? comparePassword(originalValue, comparedAtValue)
+              : false;
+          case "boolean":
+            return Number(originalValue) - Number(comparedAtValue) === 0;
+          default:
+            return originalValue === comparedAtValue;
+        }
       case "!=":
         return !handleComparisonOperator(
           "=",
-          value,
+          originalValue,
           comparedAtValue,
           fieldType
         );
       case ">":
-        return (
-          value !== null && comparedAtValue !== null && value > comparedAtValue
-        );
+        return originalValue > comparedAtValue;
       case "<":
-        return (
-          value !== null && comparedAtValue !== null && value < comparedAtValue
-        );
+        return originalValue < comparedAtValue;
       case ">=":
-        return (
-          value !== null && comparedAtValue !== null && value >= comparedAtValue
-        );
+        return originalValue >= comparedAtValue;
       case "<=":
-        return (
-          value !== null && comparedAtValue !== null && value <= comparedAtValue
-        );
+        return 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 new RegExp(
+          `^${(String(comparedAtValue).includes("%")
+            ? String(comparedAtValue)
+            : "%" + String(comparedAtValue) + "%"
+          ).replace(/%/g, ".*")}$`,
+          "i"
+        ).test(String(originalValue));
       case "!*":
         return !handleComparisonOperator(
           "*",
-          value,
+          originalValue,
           comparedAtValue,
           fieldType
         );
@@ -260,16 +476,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 = 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, secretKey);
     if (
-      decodedLine &&
-      ((Array.isArray(operator) &&
+      (Array.isArray(operator) &&
         Array.isArray(comparedAtValue) &&
         ((logicalOperator &&
           logicalOperator === "or" &&
@@ -289,13 +510,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 +534,11 @@ export const search = async (
 
 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;
+  static count = count;
+  static encode = encode;
+  static decode = decode;
+  static isExists = isExists;
 }