inibase 1.0.0-rc.123 → 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.d.ts

@@ -99,7 +99,6 @@ export default class Inibase {
     private cleanObject;
     private formatField;
     private checkUnique;
-    private _formatData;
     private formatData;
     private getDefaultValue;
     private _combineObjectsToArray;

package/dist/index.js

@@ -381,13 +381,13 @@ export default class Inibase {
                 if (!Array.isArray(value))
                     value = [value];
                 if (Utils.isArrayOfObjects(fieldChildrenType))
-                    return this._formatData(value, fieldChildrenType);
+                    return this.formatData(value, fieldChildrenType);
                 if (!value.length)
                     return null;
                 return value.map((_value) => this.formatField(_value, fieldChildrenType));
             case "object":
                 if (Utils.isArrayOfObjects(fieldChildrenType))
-                    return this._formatData(value, fieldChildrenType, _formatOnlyAvailiableKeys);
+                    return this.formatData(value, fieldChildrenType, _formatOnlyAvailiableKeys);
                 break;
             case "table":
                 if (Utils.isObject(value)) {
@@ -438,24 +438,24 @@ 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();
     }
-    _formatData(data, schema, formatOnlyAvailiableKeys) {
+    formatData(data, schema, formatOnlyAvailiableKeys) {
         const clonedData = JSON.parse(JSON.stringify(data));
         if (Utils.isArrayOfObjects(clonedData))
-            return clonedData.map((singleData) => this._formatData(singleData, schema, formatOnlyAvailiableKeys));
+            return clonedData.map((singleData) => this.formatData(singleData, schema, formatOnlyAvailiableKeys));
         if (Utils.isObject(clonedData)) {
             const RETURN = {};
             for (const field of schema) {
@@ -471,9 +471,6 @@ export default class Inibase {
         }
         return [];
     }
-    formatData(tableName, data, formatOnlyAvailiableKeys) {
-        data = this._formatData(data, this.tablesMap.get(tableName).schema, formatOnlyAvailiableKeys);
-    }
     getDefaultValue(field) {
         if (Array.isArray(field.type))
             return this.getDefaultValue({
@@ -1192,7 +1189,7 @@ export default class Inibase {
                 data.createdAt = Date.now();
                 data.updatedAt = undefined;
             }
-            this.formatData(tableName, data);
+            data = this.formatData(data, this.tablesMap.get(tableName).schema, true);
             const pathesContents = this.joinPathesContents(tableName, this.tablesMap.get(tableName).config.prepend
                 ? Array.isArray(data)
                     ? data.toReversed()
@@ -1245,7 +1242,7 @@ export default class Inibase {
                 return this.put(tableName, data, data.id, options, returnUpdatedData || undefined);
             }
             await this.validateData(tableName, data, true);
-            this.formatData(tableName, data, true);
+            data = this.formatData(data, this.tablesMap.get(tableName).schema, true);
             const pathesContents = this.joinPathesContents(tableName, {
                 ...(({ id, ...restOfData }) => restOfData)(data),
                 updatedAt: Date.now(),
@@ -1280,7 +1277,7 @@ export default class Inibase {
             Utils.isNumber(where)) {
             // "where" in this case, is the line(s) number(s) and not id(s)
             await this.validateData(tableName, data, true);
-            this.formatData(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) => ({
                     ...item,

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