inibase 1.0.0-rc.12 → 1.0.0-rc.13

package/dist/utils.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+import { FieldType, Schema } from ".";
+export declare const isArrayOfObjects: (input: any) => input is Record<any, any>[];
+export declare const isArrayOfArrays: (input: any) => input is any[][];
+export declare const isObject: (obj: any) => boolean;
+export declare const deepMerge: (target: any, source: any) => any;
+export declare const combineObjects: (arr: Record<string, any>[]) => Record<string, any>;
+export declare const isNumber: (input: any) => input is number;
+export declare const isEmail: (input: any) => boolean;
+export declare const isURL: (input: any) => boolean;
+export declare const isHTML: (input: any) => boolean;
+export declare const isString: (input: any) => input is string;
+export declare const isIP: (input: any) => boolean;
+export declare const isBoolean: (input: any) => input is boolean;
+export declare const isPassword: (input: any) => input is string;
+export declare const isDate: (input: any) => boolean;
+export declare const isValidID: (input: any) => input is string;
+export declare const findChangedProperties: (obj1: Record<string, string>, obj2: Record<string, string>) => Record<string, string> | null;
+export declare const detectFieldType: (input: any, availableTypes: FieldType[]) => FieldType | undefined;
+export declare const validateFieldType: (value: any, fieldType: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[]) => boolean;
+export declare const hashPassword: (password: string) => string;
+export declare const comparePassword: (hashedPassword: string, inputPassword: string) => boolean;
+export declare const encodeID: (id: number, secretKeyOrSalt: string | number | Buffer) => string;
+export declare const decodeID: (input: string, secretKeyOrSalt: string | number | Buffer) => number;
+export declare const findLastIdNumber: (schema: Schema, secretKeyOrSalt: string | number | Buffer) => number;
+export declare const addIdToSchema: (schema: Schema, oldIndex: number, secretKeyOrSalt: string | number | Buffer) => import(".").Field[];
+export declare const objectToDotNotation: (input: Record<string, any>) => Record<string, string | number | (string | number)[]>;
+export default class Utils {
+    static isNumber: (input: any) => input is number;
+    static isObject: (obj: any) => boolean;
+    static isEmail: (input: any) => boolean;
+    static isDate: (input: any) => boolean;
+    static isURL: (input: any) => boolean;
+    static isValidID: (input: any) => input is string;
+    static isPassword: (input: any) => input is string;
+    static deepMerge: (target: any, source: any) => any;
+    static combineObjects: (arr: Record<string, any>[]) => Record<string, any>;
+    static isArrayOfObjects: (input: any) => input is Record<any, any>[];
+    static findChangedProperties: (obj1: Record<string, string>, obj2: Record<string, string>) => Record<string, string>;
+    static detectFieldType: (input: any, availableTypes: FieldType[]) => FieldType;
+    static isArrayOfArrays: (input: any) => input is any[][];
+    static isBoolean: (input: any) => input is boolean;
+    static isString: (input: any) => input is string;
+    static isHTML: (input: any) => boolean;
+    static isIP: (input: any) => boolean;
+    static validateFieldType: (value: any, fieldType: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[]) => boolean;
+    static encodeID: (id: number, secretKeyOrSalt: string | number | Buffer) => string;
+    static decodeID: (input: string, secretKeyOrSalt: string | number | Buffer) => number;
+    static hashPassword: (password: string) => string;
+    static comparePassword: (hashedPassword: string, inputPassword: string) => boolean;
+    static findLastIdNumber: (schema: Schema, secretKeyOrSalt: string | number | Buffer) => number;
+    static addIdToSchema: (schema: Schema, oldIndex: number, secretKeyOrSalt: string | number | Buffer) => import(".").Field[];
+    static objectToDotNotation: (input: Record<string, any>) => Record<string, string | number | (string | number)[]>;
+}

package/dist/utils.js

@@ -0,0 +1,301 @@
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync, createHash, } from "node:crypto";
+export const isArrayOfObjects = (input) => Array.isArray(input) && (input.length === 0 || input.every(isObject));
+export const isArrayOfArrays = (input) => Array.isArray(input) && (input.length === 0 || input.every(Array.isArray));
+export const isObject = (obj) => obj != null &&
+    (obj.constructor.name === "Object" ||
+        (typeof obj === "object" && !Array.isArray(obj)));
+export const deepMerge = (target, source) => {
+    for (const key in source) {
+        if (source.hasOwnProperty(key)) {
+            if (source[key] instanceof Object && target[key] instanceof Object)
+                target[key] = deepMerge(target[key], source[key]);
+            else
+                target[key] = source[key];
+        }
+    }
+    return target;
+};
+export const combineObjects = (arr) => {
+    const result = {};
+    for (const obj of arr) {
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                const existingValue = result[key];
+                const newValue = obj[key];
+                if (typeof existingValue === "object" &&
+                    typeof newValue === "object" &&
+                    existingValue !== null &&
+                    newValue !== null) {
+                    // If both values are objects, recursively combine them
+                    result[key] = combineObjects([existingValue, newValue]);
+                }
+                else {
+                    // If one or both values are not objects, overwrite the existing value
+                    result[key] = newValue;
+                }
+            }
+        }
+    }
+    return result;
+};
+export const isNumber = (input) => !isNaN(parseFloat(input)) && !isNaN(input - 0);
+export const isEmail = (input) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(input));
+export const isURL = (input) => {
+    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) => /<\/?\s*[a-z-][^>]*\s*>|(\&(?:[\w\d]+|#\d+|#x[a-f\d]+);)/g.test(input);
+export const isString = (input) => 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) => /^(?:(?:^|\.)(?:2(?:5[0-5]|[0-4]\d)|1?\d?\d)){4}$/.test(input);
+export const isBoolean = (input) => typeof input === "boolean" ||
+    input === "true" ||
+    input === "false" ||
+    input === true ||
+    input === false;
+export const isPassword = (input) => input.length === 161;
+export const isDate = (input) => !isNaN(Date.parse(String(input))) && Date.parse(String(input)) >= 0;
+export const isValidID = (input) => {
+    return typeof input === "string" && input.length === 32;
+};
+export const findChangedProperties = (obj1, obj2) => {
+    const result = {};
+    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, availableTypes) => {
+    if (!Array.isArray(input)) {
+        if ((input === "0" ||
+            input === "1" ||
+            input === "true" ||
+            input === "false") &&
+            availableTypes.includes("boolean"))
+            return "boolean";
+        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 (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";
+        else if (availableTypes.includes("password") && isPassword(input))
+            return "password";
+        else if (availableTypes.includes("date") && isDate(input))
+            return "date";
+        else if (availableTypes.includes("string") && isString(input))
+            return "string";
+        else if (availableTypes.includes("ip") && isIP(input))
+            return "ip";
+    }
+    else
+        return "array";
+    return undefined;
+};
+export const validateFieldType = (value, fieldType, fieldChildrenType) => {
+    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) => element.hasOwnProperty("id") &&
+                        (isValidID(element.id) || isNumber(element.id)))) ||
+                    value.every(isNumber) ||
+                    isValidID(value));
+            else if (isObject(value))
+                return (value.hasOwnProperty("id") &&
+                    (isValidID(value.id) || isNumber(value.id)));
+            else
+                return isNumber(value) || isValidID(value);
+        case "id":
+            return isNumber(value) || isValidID(value);
+        default:
+            return false;
+    }
+};
+export const hashPassword = (password) => {
+    const salt = randomBytes(16).toString("hex");
+    const hash = createHash("sha256")
+        .update(password + salt)
+        .digest("hex");
+    return `${salt}:${hash}`;
+};
+export const comparePassword = (hashedPassword, inputPassword) => {
+    const [salt, originalHash] = hashedPassword.split(":");
+    const inputHash = createHash("sha256")
+        .update(inputPassword + salt)
+        .digest("hex");
+    return inputHash === originalHash;
+};
+export const encodeID = (id, secretKeyOrSalt) => {
+    let cipher, ret;
+    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, secretKeyOrSalt) => {
+    let 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, "hex", "utf8") + decipher.final("utf8"));
+};
+export const findLastIdNumber = (schema, secretKeyOrSalt) => {
+    const lastField = schema[schema.length - 1];
+    if (lastField) {
+        if ((lastField.type === "array" || lastField.type === "object") &&
+            isArrayOfObjects(lastField.children))
+            return findLastIdNumber(lastField.children, secretKeyOrSalt);
+        else if (lastField.id)
+            return isValidID(lastField.id)
+                ? decodeID(lastField.id, secretKeyOrSalt)
+                : lastField.id;
+    }
+    return 0;
+};
+export const addIdToSchema = (schema, oldIndex = 0, secretKeyOrSalt) => 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, oldIndex, secretKeyOrSalt);
+        oldIndex += field.children.length;
+    }
+    return field;
+});
+export const objectToDotNotation = (input) => {
+    const result = {};
+    const stack = [
+        { obj: input },
+    ];
+    while (stack.length > 0) {
+        const { obj, parentKey } = stack.pop();
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                const newKey = parentKey ? `${parentKey}.${key}` : key;
+                const value = obj[key];
+                const isArray = Array.isArray(value);
+                const isStringOrNumberArray = isArray &&
+                    value.every((item) => typeof item === "string" || typeof item === "number");
+                if (isStringOrNumberArray) {
+                    // If the property is an array of strings or numbers, keep the array as is
+                    result[newKey] = value;
+                }
+                else if (typeof value === "object" && value !== null) {
+                    // If the property is an object, push it onto the stack for further processing
+                    stack.push({ obj: value, parentKey: newKey });
+                }
+                else {
+                    // Otherwise, assign the value to the dot notation key
+                    result[newKey] = value;
+                }
+            }
+        }
+    }
+    return result;
+};
+export default class Utils {
+    static isNumber = isNumber;
+    static isObject = isObject;
+    static isEmail = isEmail;
+    static isDate = isDate;
+    static isURL = isURL;
+    static isValidID = isValidID;
+    static isPassword = isPassword;
+    static deepMerge = deepMerge;
+    static combineObjects = combineObjects;
+    static isArrayOfObjects = isArrayOfObjects;
+    static findChangedProperties = findChangedProperties;
+    static detectFieldType = detectFieldType;
+    static isArrayOfArrays = isArrayOfArrays;
+    static isBoolean = isBoolean;
+    static isString = isString;
+    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;
+    static objectToDotNotation = objectToDotNotation;
+}

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.12",
+  "version": "1.0.0-rc.13",
   "description": "File-based Relational Database for large data",
-  "main": "index.ts",
+  "files": [
+    "dist"
+  ],
+  "types": "./dist",
   "type": "module",
   "scripts": {
-    "test": "npx tsx watch ./index.test.ts"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/inicontent/inibase.git"
+    "build": "npx tsc",
+    "test": "npx tsx watch ./index.test",
+    "benchmark": "npx tsx watch ./benchmark.ts",
+    "prepublishOnly": "npm run build",
+    "postversion": "git push --follow-tags && npm publish"
   },
+  "repository": "inicontent/inibase",
   "keywords": [
     "db",
     "nosql",
@@ -27,13 +31,21 @@
     "pocketbase",
     "firebase"
   ],
-  "author": "Inicontent",
+  "author": {
+    "name": "Karim Amahtil",
+    "email": "karim.amahtil@gmail.com"
+  },
+  "funding": "https://github.com/sponsors/inicontent",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/inicontent/inibase/issues"
   },
   "homepage": "https://github.com/inicontent/inibase#readme",
   "devDependencies": {
-    "@types/node": "^20.8.6"
+    "@types/node": "^20.8.6",
+    "typescript": "^5.3.2"
+  },
+  "engines": {
+    "node": ">=16"
   }
 }

package/.env.example

@@ -1 +0,0 @@
-INIBASE_SECRET=