inibase 1.0.0-rc.4 → 1.0.0-rc.6

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.4",
+  "version": "1.0.0-rc.6",
   "description": "File-based Relational Database for large data",
   "main": "index.ts",
+  "type": "module",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/inicontent/inibase.git"
@@ -29,9 +30,9 @@
   },
   "homepage": "https://github.com/inicontent/inibase#readme",
   "devDependencies": {
-    "@types/node": "^20.6.0"
+    "@types/node": "^20.8.6"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "npx tsx watch ./index.test.ts"
   }
 }

package/tsconfig.json

@@ -1,6 +1,7 @@
 {
   "compilerOptions": {
-    "target": "ES2021",
+    "module": "ES2022",
+    "target": "ES2022",
     "moduleResolution": "node"
   }
 }

package/utils.ts

@@ -1,49 +1,20 @@
+import {
+  scryptSync,
+  randomBytes,
+  timingSafeEqual,
+  createDecipheriv,
+  createCipheriv,
+  Cipher,
+  Decipher,
+} from "node:crypto";
 import { FieldType } from ".";
-import { scryptSync, randomBytes, timingSafeEqual } from "crypto";
-
-export const encode = (
-  input: string | number | boolean | null | (string | number | boolean | null)[]
-) => {
-  const secureString = (input: string | number | boolean | null) => {
-    if (["true", "false"].includes((input ?? "").toString()))
-      return input ? 1 : 0;
-    return typeof input === "string"
-      ? decodeURIComponent(input)
-          .replaceAll("<", "&lt;")
-          .replaceAll(">", "&gt;")
-          .replaceAll(",", "%2C")
-          .replaceAll("\n", "\\n")
-          .replaceAll("\r", "\\r")
-      : input;
-  };
-  return Array.isArray(input)
-    ? input.map(secureString).join(",")
-    : secureString(input);
-};
-
-export const decode = (
-  input: string | null | number,
-  fieldType?: FieldType
-): string | number | boolean | null | (string | number | null | boolean)[] => {
-  const unSecureString = (input: string) =>
-    decodeURIComponent(input)
-      .replaceAll("&lt;", "<")
-      .replaceAll("&gt;", ">")
-      .replaceAll("%2C", ",")
-      .replaceAll("\\n", "\n")
-      .replaceAll("\\r", "\r") || null;
-
-  if (input === null || input === "") return null;
-  if (!isNaN(Number(input)) && isFinite(Number(input)))
-    return fieldType === "boolean" ? Boolean(Number(input)) : Number(input);
-  return (input as string).includes(",")
-    ? (input as string).split(",").map(unSecureString)
-    : unSecureString(input as string);
-};
 
 export const isArrayOfObjects = (arr: any) => {
   return Array.isArray(arr) && (arr.length === 0 || arr.every(isObject));
 };
+export const isArrayOfArrays = (arr: any) => {
+  return Array.isArray(arr) && (arr.length === 0 || arr.every(Array.isArray));
+};
 
 export const isObject = (obj: any) =>
   obj != null &&
@@ -71,11 +42,44 @@ export const combineObjects = (objectArray: Record<string, any>[]) => {
   return combinedValues;
 };
 
-export const isNumber = (input: any): boolean =>
+export const isNumber = (input: any | any[]): boolean =>
   Array.isArray(input)
     ? input.every(isNumber)
     : !isNaN(parseFloat(input)) && !isNaN(input - 0);
 
+export const isEmail = (input: any) =>
+  /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(input));
+
+export const isURL = (input: any) => input[0] === "#" || URL.canParse(input);
+
+export const isHTML = (input: any) =>
+  /<\/?\s*[a-z-][^>]*\s*>|(\&(?:[\w\d]+|#\d+|#x[a-f\d]+);)/g.test(input);
+
+export const isString = (input: any) =>
+  Object.prototype.toString.call(input) === "[object String]" &&
+  !isNumber(input) &&
+  !isBoolean(input) &&
+  !isEmail(input) &&
+  !isDate(input) &&
+  !isURL(input) &&
+  !isIP(input) &&
+  !isHTML(input);
+
+export const isIP = (input: any) =>
+  /^(?:(?:^|\.)(?:2(?:5[0-5]|[0-4]\d)|1?\d?\d)){4}$/.test(input);
+
+export const isBoolean = (input: any) =>
+  typeof input === "boolean" ||
+  input === "true" ||
+  input === "false" ||
+  input === true ||
+  input === false;
+
+export const isPassword = (input: any) => input.length === 161;
+
+export const isDate = (input: any) =>
+  !isNaN(Date.parse(String(input))) && Date.parse(String(input)) >= 0;
+
 export const hashPassword = (password: string) => {
   const salt = randomBytes(16).toString("hex");
   const buf = scryptSync(password, salt, 64);
@@ -97,14 +101,121 @@ export const comparePassword = (
   return timingSafeEqual(hashedPasswordBuf, suppliedPasswordBuf);
 };
 
+export const encodeID = (
+  id: number,
+  secretKey: string | number | Buffer
+): string => {
+  let cipher: Cipher, ret: string;
+
+  if (Buffer.isBuffer(secretKey))
+    cipher = createCipheriv(
+      "aes-256-cbc",
+      secretKey,
+      secretKey.subarray(0, 16)
+    );
+  else {
+    const salt = scryptSync(secretKey.toString(), "salt", 32);
+    cipher = createCipheriv("aes-256-cbc", salt, salt.subarray(0, 16));
+  }
+
+  return cipher.update(id.toString(), "utf8", "hex") + cipher.final("hex");
+};
+
+export const decodeID = (
+  input: string,
+  secretKey: string | number | Buffer
+): number => {
+  let decipher: Decipher;
+
+  if (Buffer.isBuffer(secretKey))
+    decipher = createDecipheriv(
+      "aes-256-cbc",
+      secretKey,
+      secretKey.subarray(0, 16)
+    );
+  else {
+    const salt = scryptSync(secretKey.toString(), "salt", 32);
+    decipher = createDecipheriv("aes-256-cbc", salt, salt.subarray(0, 16));
+  }
+
+  return Number(
+    decipher.update(input as string, "hex", "utf8") + decipher.final("utf8")
+  );
+};
+
+export const isValidID = (input: any): boolean => {
+  return Array.isArray(input)
+    ? input.every(isValidID)
+    : typeof input === "string" && input.length === 32;
+};
+
+export const findChangedProperties = (
+  obj1: Record<string, string>,
+  obj2: Record<string, string>
+): Record<string, string> | null => {
+  const result: Record<string, string> = {};
+
+  for (const key1 in obj1)
+    if (obj2.hasOwnProperty(key1) && obj1[key1] !== obj2[key1])
+      result[obj1[key1]] = obj2[key1];
+
+  return Object.keys(result).length ? result : null;
+};
+
+export const detectFieldType = (
+  input: any,
+  availableTypes: FieldType[]
+): FieldType | undefined => {
+  if (!Array.isArray(input)) {
+    if (
+      (input === "0" ||
+        input === "1" ||
+        input === "true" ||
+        input === "false") &&
+      availableTypes.includes("boolean")
+    )
+      return "boolean";
+    else if (Utils.isNumber(input)) {
+      if (availableTypes.includes("table")) return "table";
+      else if (availableTypes.includes("date")) return "date";
+      else if (availableTypes.includes("number")) return "number";
+    } else if (input.includes(",") && availableTypes.includes("array"))
+      return "array";
+    else if (availableTypes.includes("email") && Utils.isEmail(input))
+      return "email";
+    else if (availableTypes.includes("url") && Utils.isURL(input)) return "url";
+    else if (availableTypes.includes("password") && Utils.isPassword(input))
+      return "password";
+    else if (availableTypes.includes("date") && Utils.isDate(input))
+      return "date";
+    else if (availableTypes.includes("string") && Utils.isString(input))
+      return "string";
+    else if (availableTypes.includes("ip") && Utils.isIP(input)) return "ip";
+  } else return "array";
+
+  return undefined;
+};
+
 export default class Utils {
-  static encode = encode;
-  static decode = decode;
+  static encodeID = encodeID;
+  static decodeID = decodeID;
   static isNumber = isNumber;
   static isObject = isObject;
-  static deepMerge = deepMerge;
+  static isEmail = isEmail;
+  static isDate = isDate;
+  static isURL = isURL;
+  static isValidID = isValidID;
+  static isPassword = isPassword;
   static hashPassword = hashPassword;
+  static deepMerge = deepMerge;
   static combineObjects = combineObjects;
   static comparePassword = comparePassword;
   static isArrayOfObjects = isArrayOfObjects;
+  static findChangedProperties = findChangedProperties;
+  static detectFieldType = detectFieldType;
+  static isArrayOfArrays = isArrayOfArrays;
+  static isBoolean = isBoolean;
+  static isString = isString;
+  static isHTML = isHTML;
+  static isIP = isIP;
 }