inibase 1.0.0-rc.124 → 1.0.0-rc.125

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

@@ -399,7 +399,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 +542,7 @@ 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.js

@@ -438,16 +438,16 @@ export default class Inibase {
             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] = 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)
                         throw this.createError("FIELD_UNIQUE", [
                             field.key,
-                            Array.isArray(values) ? values.join(", ") : values,
+                            Array.from(values).join(", "),
                         ]);
                 }
                 else
-                    continue;
+                    return;
             }
         }
         this.uniqueMap = new Map();

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.125",
   "type": "module",
   "author": {
     "name": "Karim Amahtil",