inibase 1.0.0-rc.0 → 1.0.0-rc.10

package/file.ts

@@ -1,26 +1,152 @@
-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 isExists = async (path: string) => {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
 };
 
-export const decodeFileName = (fileName: string) => {
-  return fileName.replaceAll("%", "*").replaceAll("*25", "%");
+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("\n", "\\n")
+          .replaceAll("\r", "\\r")
+      : input;
+  };
+  return Array.isArray(input)
+    ? 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[],
+  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("\\n", "\n")
+      .replaceAll("\\r", "\r") || null;
+  if (input === null || input === "") return null;
+  if (Array.isArray(fieldType))
+    fieldType = 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 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;
+    }
+  };
+  return decodeHelper(
+    typeof input === "string"
+      ? input.includes(",")
+        ? input.includes("|")
+          ? input
+              .split("|")
+              .map((_input) => _input.split(",").map(unSecureString))
+          : input.split(",").map(unSecureString)
+        : input.includes("|")
+        ? input
+            .split("|")
+            .map((_input) => [
+              _input
+                ? fieldType === "array"
+                  ? [unSecureString(_input)]
+                  : unSecureString(_input)
+                : null,
+            ])
+        : 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 +158,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 +201,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 +256,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);
+    ];
+
+  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`);
     }
   }
-  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;
-
-  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,9 +310,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 +330,7 @@ export const search = async (
 > => {
   const handleComparisonOperator = (
     operator: ComparisonOperator,
-    value:
+    originalValue:
       | string
       | number
       | boolean
@@ -178,71 +342,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 +433,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 +467,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 +491,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;
 }