inibase 1.0.0-rc.6 → 1.0.0-rc.8

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.6",
+  "version": "1.0.0-rc.8",
   "description": "File-based Relational Database for large data",
   "main": "index.ts",
   "type": "module",
+  "scripts": {
+    "test": "npx tsx watch ./index.test.ts"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/inicontent/inibase.git"
@@ -31,8 +34,5 @@
   "homepage": "https://github.com/inicontent/inibase#readme",
   "devDependencies": {
     "@types/node": "^20.8.6"
-  },
-  "scripts": {
-    "test": "npx tsx watch ./index.test.ts"
   }
-}
+}

package/utils.server.ts

@@ -0,0 +1,79 @@
+import {
+  scryptSync,
+  randomBytes,
+  timingSafeEqual,
+  createDecipheriv,
+  createCipheriv,
+  Cipher,
+  Decipher,
+} from "node:crypto";
+
+export const hashPassword = (password: string) => {
+  const salt = randomBytes(16).toString("hex");
+  const buf = scryptSync(password, salt, 64);
+  // return "161" length string
+  return `${buf.toString("hex")}.${salt}`;
+};
+
+export const comparePassword = (
+  storedPassword: string,
+  suppliedPassword: string
+) => {
+  // split() returns array
+  const [hashedPassword, salt] = storedPassword.split(".");
+  // we need to pass buffer values to timingSafeEqual
+  const hashedPasswordBuf = Buffer.from(hashedPassword, "hex");
+  // we hash the new sign-in password
+  const suppliedPasswordBuf = scryptSync(suppliedPassword, salt, 64);
+  // compare the new supplied password with the stored hashed password
+  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 default class Utils {
+  static encodeID = encodeID;
+  static decodeID = decodeID;
+  static hashPassword = hashPassword;
+  static comparePassword = comparePassword;
+}

package/utils.ts

@@ -1,13 +1,4 @@
-import {
-  scryptSync,
-  randomBytes,
-  timingSafeEqual,
-  createDecipheriv,
-  createCipheriv,
-  Cipher,
-  Decipher,
-} from "node:crypto";
-import { FieldType } from ".";
+import { FieldType, Data } from ".";
 
 export const isArrayOfObjects = (arr: any) => {
   return Array.isArray(arr) && (arr.length === 0 || arr.every(isObject));
@@ -80,69 +71,6 @@ 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);
-  // return "161" length string
-  return `${buf.toString("hex")}.${salt}`;
-};
-
-export const comparePassword = (
-  storedPassword: string,
-  suppliedPassword: string
-) => {
-  // split() returns array
-  const [hashedPassword, salt] = storedPassword.split(".");
-  // we need to pass buffer values to timingSafeEqual
-  const hashedPasswordBuf = Buffer.from(hashedPassword, "hex");
-  // we hash the new sign-in password
-  const suppliedPasswordBuf = scryptSync(suppliedPassword, salt, 64);
-  // compare the new supplied password with the stored hashed password
-  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)
@@ -175,30 +103,94 @@ export const detectFieldType = (
       availableTypes.includes("boolean")
     )
       return "boolean";
-    else if (Utils.isNumber(input)) {
+    else if (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))
+    else if (availableTypes.includes("email") && isEmail(input)) return "email";
+    else if (availableTypes.includes("url") && isURL(input)) return "url";
+    else if (availableTypes.includes("password") && isPassword(input))
       return "password";
-    else if (availableTypes.includes("date") && Utils.isDate(input))
-      return "date";
-    else if (availableTypes.includes("string") && Utils.isString(input))
+    else if (availableTypes.includes("date") && isDate(input)) return "date";
+    else if (availableTypes.includes("string") && isString(input))
       return "string";
-    else if (availableTypes.includes("ip") && Utils.isIP(input)) return "ip";
+    else if (availableTypes.includes("ip") && isIP(input)) return "ip";
   } else return "array";
 
   return undefined;
 };
 
+export const validateFieldType = (
+  value: any,
+  fieldType: FieldType | FieldType[],
+  fieldChildrenType?: FieldType | FieldType[]
+): boolean => {
+  if (value === null) return true;
+  if (Array.isArray(fieldType))
+    return detectFieldType(value, fieldType) !== undefined;
+  if (fieldType === "array" && fieldChildrenType && Array.isArray(value))
+    return value.some(
+      (v) =>
+        detectFieldType(
+          v,
+          Array.isArray(fieldChildrenType)
+            ? fieldChildrenType
+            : [fieldChildrenType]
+        ) !== undefined
+    );
+
+  switch (fieldType) {
+    case "string":
+      return isString(value);
+    case "password":
+      return isNumber(value) || isString(value) || isPassword(value);
+    case "number":
+      return isNumber(value);
+    case "html":
+      return isHTML(value);
+    case "ip":
+      return isIP(value);
+    case "boolean":
+      return isBoolean(value);
+    case "date":
+      return isDate(value);
+    case "object":
+      return isObject(value);
+    case "array":
+      return Array.isArray(value);
+    case "email":
+      return isEmail(value);
+    case "url":
+      return isURL(value);
+    case "table":
+      // feat: check if id exists
+      if (Array.isArray(value))
+        return (
+          (isArrayOfObjects(value) &&
+            value.every(
+              (element: Data) =>
+                element.hasOwnProperty("id") &&
+                (isValidID(element.id) || isNumber(element.id))
+            )) ||
+          value.every(isNumber) ||
+          isValidID(value)
+        );
+      else if (isObject(value))
+        return (
+          value.hasOwnProperty("id") &&
+          (isValidID((value as Data).id) || isNumber((value as Data).id))
+        );
+      else return isNumber(value) || isValidID(value);
+    case "id":
+      return isNumber(value) || isValidID(value);
+    default:
+      return false;
+  }
+};
+
 export default class Utils {
-  static encodeID = encodeID;
-  static decodeID = decodeID;
   static isNumber = isNumber;
   static isObject = isObject;
   static isEmail = isEmail;
@@ -206,10 +198,8 @@ export default class Utils {
   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;
@@ -218,4 +208,5 @@ export default class Utils {
   static isString = isString;
   static isHTML = isHTML;
   static isIP = isIP;
+  static validateFieldType = validateFieldType;
 }