inibase 1.0.0-rc.124 → 1.0.0-rc.126

package/README.md

@@ -106,40 +106,124 @@ interface {
 <summary>Schema</summary>
 <blockquote>
 
+<details>
+<summary>Types</summary>
+<blockquote>
+
 ```ts
-interface {
+interface Field {
   id: number; // stored as a Number but displayed as a hashed ID
   key: string;
   required?: boolean;
-  unique?: boolean;
-  type: "string" | "number" | "boolean" | "date" | "email" | "url" | "password" | "html" | "ip" | "json" | "id";
+  unique?: boolean | string; // boolean for simple uniqueness, string for grouped uniqueness
+  regex?: RegExp; // Regular expression for custom validation
+  type:
+    | "string"
+    | "number"
+    | "boolean"
+    | "date"
+    | "email"
+    | "url"
+    | "password"
+    | "html"
+    | "ip"
+    | "json"
+    | "id";
 }
-interface Table {
+
+interface TableField {
   id: number;
   key: string;
   required?: boolean;
+  unique?: boolean | string; // Supports uniqueness constraints
   type: "table";
   table: string;
 }
-interface Array {
+
+interface ArrayField {
   id: number;
   key: string;
   required?: boolean;
+  unique?: boolean | string; // Supports uniqueness constraints
   type: "array";
-  children: string|string[];
+  children: string | string[]; // Can be a single type or an array of types
 }
-interface ObjectOrArrayOfObjects {
+
+interface ObjectOrArrayOfObjectsField {
   id: number;
   key: string;
   required?: boolean;
+  unique?: boolean | string; // Supports uniqueness constraints
+  regex?: RegExp; // For validation of object-level keys
   type: "object" | "array";
-  children: Schema;
+  children: Schema; // Nested schema for objects or arrays
+}
+```
+
+</blockquote>
+</details>
+
+<details>
+<summary>Unique</summary>
+<blockquote>
+
+The `unique` property ensures that the values of a specific column or a group of columns are unique within a table. This property can be either a boolean or a string.
+- **Boolean**: Setting `unique: true` ensures that the values in the column are unique across all rows.
+- **String**: By setting a string value, you can group columns to enforce a combined uniqueness constraint. This is useful when you need to ensure that a combination of values across multiple fields is unique.
+
+<details>
+<summary>Examples</summary>
+<blockquote>
+
+<details>
+<summary>Unique Column</summary>
+<blockquote>
+
+```js
+{
+  key: "email",
+  type: "string",
+  required: true,
+  unique: true, // Ensures all email values are unique
 }
 ```
 
 </blockquote>
 </details>
 
+<details>
+<summary>Group of Unique Columns</summary>
+<blockquote>
+
+```js
+[
+  {
+    key: "firstName",
+    type: "string",
+    required: true,
+    unique: "nameGroup", // Part of "nameGroup" uniqueness
+  },
+  {
+    key: "lastName",
+    type: "string",
+    required: true,
+    unique: "nameGroup", // Part of "nameGroup" uniqueness
+  },
+]
+```
+
+</blockquote>
+</details>
+
+</blockquote>
+</details>
+
+</blockquote>
+</details>
+
+</blockquote>
+</details>
+
 <details>
 <summary>Create Table</summary>
 <blockquote>
@@ -357,7 +441,7 @@ const product = await db.post("product", productTableData);
 </blockquote>
 </details>
 
-<details>
+<details open>
 <summary>Methods</summary>
 <blockquote>
 

package/dist/file.js

@@ -1,11 +1,9 @@
-import { createWriteStream } from "node:fs";
 import { access, appendFile, copyFile, constants as fsConstants, open, readFile, unlink, writeFile, } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createGunzip, createGzip } from "node:zlib";
-import { spawn as spawnSync } from "node:child_process";
 import Inison from "inison";
 import { detectFieldType, isArrayOfObjects, isStringified, isNumber, isObject, } from "./utils.js";
 import { compare, encodeID, exec, gunzip, gzip } from "./utils.server.js";
@@ -275,9 +273,9 @@ export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, s
 export const replace = async (filePath, replacements, totalItems) => {
     const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
     const isReplacementsObject = isObject(replacements);
-    const isReplacementsObjectHasLineNumbers = isReplacementsObject && !Number.isNaN(Number(Object.keys(replacements)[0]));
+    const isReplacementsLineNumbered = isReplacementsObject && !Number.isNaN(Number(Object.keys(replacements)[0]));
     if (await isExists(filePath)) {
-        if (isReplacementsObjectHasLineNumbers) {
+        if (isReplacementsLineNumbered) {
             let fileHandle = null;
             let fileTempHandle = null;
             try {
@@ -328,34 +326,24 @@ export const replace = async (filePath, replacements, totalItems) => {
             }
         }
         else {
-            return new Promise((resolve) => {
-                const sedProcess = spawnSync("sed", [
-                    "-e",
-                    `s/.*/${replacements}/`,
-                    "-e",
-                    `/^$/s/^/${replacements}/`,
-                    filePath,
-                ]);
-                const outputStream = createWriteStream(fileTempPath); // Temp file for output
-                // Pipe sed output to the temporary file
-                sedProcess.stdout.pipe(outputStream);
-                // Handle the process close
-                sedProcess.on("close", (code) => {
-                    if (code === 0)
-                        resolve([fileTempPath, filePath]);
-                    else
-                        resolve([fileTempPath, null]);
-                });
-                // Handle errors in spawning the sed process
-                sedProcess.on("error", () => {
-                    resolve([fileTempPath, null]);
-                });
-            });
+            const escapedFilePath = escapeShellPath(filePath);
+            const escapedFileTempPath = escapeShellPath(fileTempPath);
+            const sedCommand = `sed -e s/.*/${replacements}/ -e /^$/s/^/${replacements}/ ${escapedFilePath}`;
+            const command = filePath.endsWith(".gz")
+                ? `zcat ${escapedFilePath} | ${sedCommand} | gzip > ${escapedFileTempPath}`
+                : `${sedCommand} > ${escapedFileTempPath}`;
+            try {
+                await exec(command);
+                return [fileTempPath, filePath];
+            }
+            catch {
+                return [fileTempPath, null];
+            }
         }
     }
     else if (isReplacementsObject) {
         try {
-            if (isReplacementsObjectHasLineNumbers) {
+            if (isReplacementsLineNumbered) {
                 const replacementsKeys = Object.keys(replacements)
                     .map(Number)
                     .toSorted((a, b) => a - b);
@@ -399,7 +387,7 @@ export const append = async (filePath, data) => {
             }
             else {
                 const escapedFileTempPath = escapeShellPath(fileTempPath);
-                await exec(`echo $'${(Array.isArray(data) ? data.join("\n") : data)
+                await exec(`echo '${(Array.isArray(data) ? data.join("\n") : data)
                     .toString()
                     .replace(/'/g, "\\'")}' | gzip - >> ${escapedFileTempPath}`);
             }
@@ -542,7 +530,8 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
             // Increment the line count for each line.
             linesCount++;
             // Search only in provided linesNumbers
-            if (searchIn && (!searchIn.has(linesCount) || searchIn.has(-linesCount)))
+            if (searchIn?.size &&
+                (!searchIn.has(linesCount) || searchIn.has(-linesCount)))
                 continue;
             // Decode the line for comparison.
             const decodedLine = decode(line, fieldType, fieldChildrenType, secretKey);

package/dist/index.d.ts

@@ -62,7 +62,7 @@ export default class Inibase {
     private totalItems;
     constructor(database: string, mainFolder?: string);
     private static errorMessages;
-    createError(code: ErrorCodes, variable?: string | number | (string | number)[], language?: ErrorLang): Error;
+    createError(name: ErrorCodes, variable?: string | number | (string | number)[], language?: ErrorLang): Error;
     clear(): void;
     private getFileExtension;
     private _schemaToIdsPath;

package/dist/index.js

@@ -1,5 +1,5 @@
 import "dotenv/config";
-import { randomBytes, randomInt, scryptSync } from "node:crypto";
+import { randomBytes, scryptSync } from "node:crypto";
 import { appendFileSync, existsSync, readFileSync } from "node:fs";
 import { glob, mkdir, readFile, readdir, rename, rm, unlink, writeFile, } from "node:fs/promises";
 import { join, parse } from "node:path";
@@ -48,15 +48,17 @@ export default class Inibase {
                 : "please use dotenv",
         },
     };
-    createError(code, variable, language = "en") {
-        const errorMessage = Inibase.errorMessages[language]?.[code];
+    createError(name, variable, language = "en") {
+        const errorMessage = Inibase.errorMessages[language]?.[name];
         if (!errorMessage)
             return new Error("ERR");
-        return new Error(variable
+        const error = new Error(variable
             ? Array.isArray(variable)
                 ? errorMessage.replace(/\{variable\}/g, () => variable.shift()?.toString() ?? "")
                 : errorMessage.replaceAll("{variable}", `'${variable.toString()}'`)
             : errorMessage.replaceAll("{variable}", ""));
+        error.name = name;
+        return error;
     }
     clear() {
         this.tablesMap = new Map();
@@ -293,10 +295,12 @@ export default class Inibase {
             throw this.createError("TABLE_EMPTY", tableName);
     }
     _validateData(data, schema, skipRequiredField = false) {
-        if (Utils.isArrayOfObjects(data))
+        if (Utils.isArrayOfObjects(data)) {
             for (const single_data of data)
                 this._validateData(single_data, schema, skipRequiredField);
-        else if (Utils.isObject(data)) {
+            return;
+        }
+        if (Utils.isObject(data)) {
             for (const field of schema) {
                 if (!Object.hasOwn(data, field.key) ||
                     data[field.key] === null ||
@@ -304,7 +308,7 @@ export default class Inibase {
                     data[field.key] === "") {
                     if (field.required && !skipRequiredField)
                         throw this.createError("FIELD_REQUIRED", field.key);
-                    return;
+                    continue;
                 }
                 if (!Utils.validateFieldType(data[field.key], field.type, (field.type === "array" || field.type === "object") &&
                     field.children &&
@@ -313,7 +317,12 @@ export default class Inibase {
                     : undefined))
                     throw this.createError("INVALID_TYPE", [
                         field.key,
-                        Array.isArray(field.type) ? field.type.join(", ") : field.type,
+                        (Array.isArray(field.type) ? field.type.join(", ") : field.type) +
+                            (Array.isArray(field.children)
+                                ? Utils.isArrayOfObjects(field.children)
+                                    ? "[object]"
+                                    : `[${field.children.join("|")}]`
+                                : `[${field.children}]`),
                         data[field.key],
                     ]);
                 if ((field.type === "array" || field.type === "object") &&
@@ -329,7 +338,7 @@ export default class Inibase {
                     if (field.unique) {
                         let uniqueKey;
                         if (typeof field.unique === "boolean")
-                            uniqueKey = randomInt(55);
+                            uniqueKey = field.id;
                         else
                             uniqueKey = field.unique;
                         if (!this.uniqueMap.has(uniqueKey))
@@ -433,22 +442,38 @@ export default class Inibase {
     async checkUnique(tableName) {
         const tablePath = join(this.databasePath, tableName);
         const flattenSchema = Utils.flattenSchema(this.tablesMap.get(tableName).schema);
+        function hasDuplicates(setA, setB) {
+            for (const value of setA)
+                if (setB.has(value))
+                    return true; // Stop and return true if a duplicate is found
+            return false; // No duplicates found
+        }
         for await (const [_uniqueID, valueObject] of this.uniqueMap) {
             let index = 0;
+            let shouldContinueParent = false; // Flag to manage parent loop continuation
+            const mergedLineNumbers = new Set();
             for await (const [columnID, values] of valueObject.columnsValues) {
                 index++;
                 const field = flattenSchema.find(({ id }) => id === columnID);
-                const [searchResult, totalLines] = await File.search(join(tablePath, `${field.key}${this.getFileExtension(tableName)}`), "[]", values, undefined, valueObject.exclude, field.type, field.children, 1, undefined, false, this.salt);
+                const [searchResult, totalLines, lineNumbers] = await File.search(join(tablePath, `${field.key}${this.getFileExtension(tableName)}`), "[]", Array.from(values), undefined, valueObject.exclude, field.type, field.children, 1, undefined, false, this.salt);
                 if (searchResult && totalLines > 0) {
-                    if (index === valueObject.columnsValues.size)
+                    if (valueObject.columnsValues.size === 1 ||
+                        hasDuplicates(lineNumbers, mergedLineNumbers)) {
+                        this.uniqueMap = new Map();
                         throw this.createError("FIELD_UNIQUE", [
                             field.key,
-                            Array.isArray(values) ? values.join(", ") : values,
+                            Array.from(values).join(", "),
                         ]);
+                    }
+                    lineNumbers.forEach(mergedLineNumbers.add, mergedLineNumbers);
+                }
+                else {
+                    shouldContinueParent = true; // Flag to skip the rest of this inner loop
+                    break; // Exit the inner loop
                 }
-                else
-                    continue;
             }
+            if (shouldContinueParent)
+                continue;
         }
         this.uniqueMap = new Map();
     }
@@ -1165,8 +1190,9 @@ export default class Inibase {
             throw this.createError("NO_SCHEMA", tableName);
         if (!returnPostedData)
             returnPostedData = false;
-        const keys = UtilsServer.hashString(Object.keys(Array.isArray(data) ? data[0] : data).join("."));
-        await this.validateData(tableName, data);
+        let clonedData = JSON.parse(JSON.stringify(data));
+        const keys = UtilsServer.hashString(Object.keys(Array.isArray(clonedData) ? clonedData[0] : clonedData).join("."));
+        await this.validateData(tableName, clonedData);
         const renameList = [];
         try {
             await File.lock(join(tablePath, ".tmp"), keys);
@@ -1177,24 +1203,24 @@ export default class Inibase {
                 .name.split("-")
                 .map(Number);
             this.totalItems.set(`${tableName}-*`, _totalItems);
-            if (Utils.isArrayOfObjects(data))
-                for (let index = 0; index < data.length; index++) {
-                    const element = data[index];
+            if (Utils.isArrayOfObjects(clonedData))
+                for (let index = 0; index < clonedData.length; index++) {
+                    const element = clonedData[index];
                     element.id = ++lastId;
                     element.createdAt = Date.now();
                     element.updatedAt = undefined;
                 }
             else {
-                data.id = ++lastId;
-                data.createdAt = Date.now();
-                data.updatedAt = undefined;
+                clonedData.id = ++lastId;
+                clonedData.createdAt = Date.now();
+                clonedData.updatedAt = undefined;
             }
-            data = this.formatData(data, this.tablesMap.get(tableName).schema, true);
+            clonedData = this.formatData(clonedData, this.tablesMap.get(tableName).schema, true);
             const pathesContents = this.joinPathesContents(tableName, this.tablesMap.get(tableName).config.prepend
-                ? Array.isArray(data)
-                    ? data.toReversed()
-                    : data
-                : data);
+                ? Array.isArray(clonedData)
+                    ? clonedData.toReversed()
+                    : clonedData
+                : clonedData);
             await Promise.allSettled(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(this.tablesMap.get(tableName).config.prepend
                 ? await File.prepend(path, content)
                 : await File.append(path, content))));
@@ -1208,14 +1234,14 @@ export default class Inibase {
             await rename(paginationFilePath, join(tablePath, `${lastId}-${this.totalItems.get(`${tableName}-*`)}.pagination`));
             if (returnPostedData)
                 return this.get(tableName, this.tablesMap.get(tableName).config.prepend
-                    ? Array.isArray(data)
-                        ? data.map((_, index) => index + 1).toReversed()
+                    ? Array.isArray(clonedData)
+                        ? clonedData.map((_, index) => index + 1).toReversed()
                         : 1
-                    : Array.isArray(data)
-                        ? data
+                    : Array.isArray(clonedData)
+                        ? clonedData
                             .map((_, index) => this.totalItems.get(`${tableName}-*`) - index)
                             .toReversed()
-                        : this.totalItems.get(`${tableName}-*`), options, !Utils.isArrayOfObjects(data));
+                        : this.totalItems.get(`${tableName}-*`), options, !Utils.isArrayOfObjects(clonedData));
         }
         finally {
             if (renameList.length)
@@ -1230,21 +1256,22 @@ export default class Inibase {
         const renameList = [];
         const tablePath = join(this.databasePath, tableName);
         await this.throwErrorIfTableEmpty(tableName);
+        let clonedData = JSON.parse(JSON.stringify(data));
         if (!where) {
-            if (Utils.isArrayOfObjects(data)) {
-                if (!data.every((item) => Object.hasOwn(item, "id") && Utils.isValidID(item.id)))
+            if (Utils.isArrayOfObjects(clonedData)) {
+                if (!clonedData.every((item) => Object.hasOwn(item, "id") && Utils.isValidID(item.id)))
                     throw this.createError("INVALID_ID");
-                return this.put(tableName, data, data.map(({ id }) => id), options, returnUpdatedData || undefined);
+                return this.put(tableName, clonedData, clonedData.map(({ id }) => id), options, returnUpdatedData || undefined);
             }
             if (Object.hasOwn(data, "id")) {
-                if (!Utils.isValidID(data.id))
-                    throw this.createError("INVALID_ID", data.id);
-                return this.put(tableName, data, data.id, options, returnUpdatedData || undefined);
+                if (!Utils.isValidID(clonedData.id))
+                    throw this.createError("INVALID_ID", clonedData.id);
+                return this.put(tableName, data, clonedData.id, options, returnUpdatedData || undefined);
             }
-            await this.validateData(tableName, data, true);
-            data = this.formatData(data, this.tablesMap.get(tableName).schema, true);
+            await this.validateData(tableName, clonedData, true);
+            clonedData = this.formatData(clonedData, this.tablesMap.get(tableName).schema, true);
             const pathesContents = this.joinPathesContents(tableName, {
-                ...(({ id, ...restOfData }) => restOfData)(data),
+                ...(({ id, ...restOfData }) => restOfData)(clonedData),
                 updatedAt: Date.now(),
             });
             try {
@@ -1271,19 +1298,19 @@ export default class Inibase {
         else if ((Array.isArray(where) && where.every(Utils.isValidID)) ||
             Utils.isValidID(where)) {
             const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
-            return this.put(tableName, data, lineNumbers, options, returnUpdatedData || undefined);
+            return this.put(tableName, clonedData, lineNumbers, options, returnUpdatedData || undefined);
         }
         else if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
             Utils.isNumber(where)) {
             // "where" in this case, is the line(s) number(s) and not id(s)
-            await this.validateData(tableName, data, true);
-            data = this.formatData(data, this.tablesMap.get(tableName).schema, true);
-            const pathesContents = Object.fromEntries(Object.entries(this.joinPathesContents(tableName, Utils.isArrayOfObjects(data)
-                ? data.map((item) => ({
+            await this.validateData(tableName, clonedData, true);
+            clonedData = this.formatData(clonedData, this.tablesMap.get(tableName).schema, true);
+            const pathesContents = Object.fromEntries(Object.entries(this.joinPathesContents(tableName, Utils.isArrayOfObjects(clonedData)
+                ? clonedData.map((item) => ({
                     ...item,
                     updatedAt: Date.now(),
                 }))
-                : { ...data, updatedAt: Date.now() })).map(([path, content]) => [
+                : { ...clonedData, updatedAt: Date.now() })).map(([path, content]) => [
                 path,
                 [...(Array.isArray(where) ? where : [where])].reduce((obj, lineNum, index) => Object.assign(obj, {
                     [lineNum]: Array.isArray(content) ? content[index] : content,
@@ -1312,7 +1339,7 @@ export default class Inibase {
         else if (Utils.isObject(where)) {
             const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
             if (lineNumbers)
-                return this.put(tableName, data, lineNumbers, options, returnUpdatedData || undefined);
+                return this.put(tableName, clonedData, lineNumbers, options, returnUpdatedData || undefined);
         }
         else
             throw this.createError("INVALID_PARAMETERS");

package/dist/utils.js

@@ -318,16 +318,17 @@ export const validateFieldType = (value, fieldType, fieldChildrenType) => {
         fieldType = detectedFieldType;
     }
     if (fieldType === "array" && fieldChildrenType)
-        return value.every((v) => {
-            let _fieldChildrenType = fieldChildrenType;
-            if (Array.isArray(_fieldChildrenType)) {
-                const detectedFieldType = detectFieldType(v, _fieldChildrenType);
-                if (!detectedFieldType)
-                    return false;
-                _fieldChildrenType = detectedFieldType;
-            }
-            return validateFieldType(v, _fieldChildrenType);
-        });
+        return (Array.isArray(value) &&
+            value.every((v) => {
+                let _fieldChildrenType = fieldChildrenType;
+                if (Array.isArray(_fieldChildrenType)) {
+                    const detectedFieldType = detectFieldType(v, _fieldChildrenType);
+                    if (!detectedFieldType)
+                        return false;
+                    _fieldChildrenType = detectedFieldType;
+                }
+                return validateFieldType(v, _fieldChildrenType);
+            }));
     switch (fieldType) {
         case "string":
             return isString(value);

package/dist/utils.server.js

@@ -210,9 +210,20 @@ export const isEqual = (originalValue, comparedValue, fieldType) => {
                 : false;
         case "boolean":
             return Number(originalValue) === Number(comparedValue);
-        default:
-            return ((!String(comparedValue).length && originalValue === undefined) ||
-                originalValue == comparedValue);
+        default: {
+            // Fast checks for null-like values
+            const isOriginalNullLike = originalValue === null ||
+                originalValue === undefined ||
+                originalValue === "";
+            const isComparedNullLike = comparedValue === null ||
+                comparedValue === undefined ||
+                comparedValue === "";
+            // If both are null-like, treat as equivalent
+            if (isOriginalNullLike && isComparedNullLike)
+                return true;
+            // Direct equality check for other cases
+            return originalValue === comparedValue;
+        }
     }
 };
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.124",
+  "version": "1.0.0-rc.126",
   "type": "module",
   "author": {
     "name": "Karim Amahtil",
@@ -68,6 +68,7 @@
     }
   },
   "devDependencies": {
+    "@biomejs/biome": "1.9.4",
     "@types/bun": "^1.1.10",
     "@types/node": "^22.7.4",
     "tinybench": "^3.0.7",
@@ -81,6 +82,7 @@
   "scripts": {
     "prepublish": "npx tsc",
     "build": "npx tsc",
-    "benchmark": "./benchmark/run.js"
+    "benchmark": "./benchmark/run.js",
+    "test": "npx tsx ./tests/inibase.test.ts"
   }
 }