inibase 1.0.0-rc.10 → 1.0.0-rc.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.10",
+  "version": "1.0.0-rc.12",
   "description": "File-based Relational Database for large data",
   "main": "index.ts",
   "type": "module",
@@ -24,6 +24,7 @@
     "sql",
     "sqlite",
     "supabase",
+    "pocketbase",
     "firebase"
   ],
   "author": "Inicontent",

package/utils.ts

@@ -1,11 +1,19 @@
-import { FieldType, Data } from ".";
+import { FieldType, Data, Schema } from ".";
+import {
+  createCipheriv,
+  createDecipheriv,
+  randomBytes,
+  scryptSync,
+  timingSafeEqual,
+  type Cipher,
+  type Decipher,
+} from "node:crypto";
 
-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 isArrayOfObjects = (input: any): input is Record<any, any>[] =>
+  Array.isArray(input) && (input.length === 0 || input.every(isObject));
+
+export const isArrayOfArrays = (input: any): input is any[][] =>
+  Array.isArray(input) && (input.length === 0 || input.every(Array.isArray));
 
 export const isObject = (obj: any) =>
   obj != null &&
@@ -33,20 +41,39 @@ export const combineObjects = (objectArray: Record<string, any>[]) => {
   return combinedValues;
 };
 
-export const isNumber = (input: any | any[]): boolean =>
-  Array.isArray(input)
-    ? input.every(isNumber)
-    : !isNaN(parseFloat(input)) && !isNaN(input - 0);
+export const isNumber = (input: any): input is number =>
+  !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 isURL = (input: any) => {
+  if (typeof input !== "string") return false;
+  if (
+    input[0] === "#" ||
+    input.startsWith("tel:") ||
+    input.startsWith("mailto:")
+  )
+    return true;
+  else if ("canParse" in URL) return URL.canParse(input);
+  else {
+    var pattern = new RegExp(
+      "^(https?:\\/\\/)?" + // protocol
+        "((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|" + // domain name
+        "((\\d{1,3}\\.){3}\\d{1,3}))" + // OR ip (v4) address
+        "(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*" + // port and path
+        "(\\?[;&a-z\\d%_.~+=-]*)?" + // query string
+        "(\\#[-a-z\\d_]*)?$",
+      "i"
+    ); // fragment locator
+    return !!pattern.test(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) =>
+export const isString = (input: any): input is string =>
   Object.prototype.toString.call(input) === "[object String]" &&
   !isNumber(input) &&
   !isBoolean(input) &&
@@ -59,22 +86,20 @@ export const isString = (input: any) =>
 export const isIP = (input: any) =>
   /^(?:(?:^|\.)(?:2(?:5[0-5]|[0-4]\d)|1?\d?\d)){4}$/.test(input);
 
-export const isBoolean = (input: any) =>
+export const isBoolean = (input: any): input is boolean =>
   typeof input === "boolean" ||
   input === "true" ||
   input === "false" ||
   input === true ||
   input === false;
 
-export const isPassword = (input: any) => input.length === 161;
+export const isPassword = (input: any): input is string => input.length === 161;
 
 export const isDate = (input: any) =>
   !isNaN(Date.parse(String(input))) && Date.parse(String(input)) >= 0;
 
-export const isValidID = (input: any): boolean => {
-  return Array.isArray(input)
-    ? input.every(isValidID)
-    : typeof input === "string" && input.length === 32;
+export const isValidID = (input: any): input is string => {
+  return typeof input === "string" && input.length === 32;
 };
 
 export const findChangedProperties = (
@@ -107,7 +132,9 @@ export const detectFieldType = (
       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"))
+    } else if (availableTypes.includes("table") && isValidID(input))
+      return "table";
+    else if (input.includes(",") && availableTypes.includes("array"))
       return "array";
     else if (availableTypes.includes("email") && isEmail(input)) return "email";
     else if (availableTypes.includes("url") && isURL(input)) return "url";
@@ -190,6 +217,126 @@ export const validateFieldType = (
   }
 };
 
+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,
+  secretKeyOrSalt: string | number | Buffer
+): string => {
+  let cipher: Cipher, ret: string;
+
+  if (Buffer.isBuffer(secretKeyOrSalt))
+    cipher = createCipheriv(
+      "aes-256-cbc",
+      secretKeyOrSalt,
+      secretKeyOrSalt.subarray(0, 16)
+    );
+  else {
+    const salt = scryptSync(
+      secretKeyOrSalt.toString(),
+      (process.env.INIBASE_SECRET ?? "inibase") + "_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,
+  secretKeyOrSalt: string | number | Buffer
+): number => {
+  let decipher: Decipher;
+
+  if (Buffer.isBuffer(secretKeyOrSalt))
+    decipher = createDecipheriv(
+      "aes-256-cbc",
+      secretKeyOrSalt,
+      secretKeyOrSalt.subarray(0, 16)
+    );
+  else {
+    const salt = scryptSync(
+      secretKeyOrSalt.toString(),
+      (process.env.INIBASE_SECRET ?? "inibase") + "_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 findLastIdNumber = (
+  schema: Schema,
+  secretKeyOrSalt: string | number | Buffer
+): number => {
+  const lastField = schema[schema.length - 1];
+  if (lastField) {
+    if (
+      (lastField.type === "array" || lastField.type === "object") &&
+      isArrayOfObjects(lastField.children)
+    )
+      return findLastIdNumber(lastField.children as Schema, secretKeyOrSalt);
+    else if (lastField.id)
+      return isValidID(lastField.id)
+        ? decodeID(lastField.id as string, secretKeyOrSalt)
+        : lastField.id;
+  }
+  return 0;
+};
+
+export const addIdToSchema = (
+  schema: Schema,
+  oldIndex: number = 0,
+  secretKeyOrSalt: string | number | Buffer
+) =>
+  schema.map((field) => {
+    if (!field.id) {
+      oldIndex++;
+      field.id = encodeID(oldIndex, secretKeyOrSalt);
+    } else {
+      if (!isNumber(field.id)) oldIndex = decodeID(field.id, secretKeyOrSalt);
+      else {
+        oldIndex = field.id;
+        field.id = encodeID(field.id, secretKeyOrSalt);
+      }
+    }
+    if (
+      (field.type === "array" || field.type === "object") &&
+      isArrayOfObjects(field.children)
+    ) {
+      field.children = addIdToSchema(
+        field.children as Schema,
+        oldIndex,
+        secretKeyOrSalt
+      );
+      oldIndex += field.children.length;
+    }
+    return field;
+  });
+
 export default class Utils {
   static isNumber = isNumber;
   static isObject = isObject;
@@ -209,4 +356,11 @@ export default class Utils {
   static isHTML = isHTML;
   static isIP = isIP;
   static validateFieldType = validateFieldType;
+
+  static encodeID = encodeID;
+  static decodeID = decodeID;
+  static hashPassword = hashPassword;
+  static comparePassword = comparePassword;
+  static findLastIdNumber = findLastIdNumber;
+  static addIdToSchema = addIdToSchema;
 }

package/utils.server.ts

@@ -1,79 +0,0 @@
-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;
-}