inibase 1.0.0-rc.72 → 1.0.0-rc.74

package/dist/cli.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import "dotenv/config";
+import { readFileSync } from "node:fs";
+import { basename, join } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
-import { basename, join } from "node:path";
-import { readFileSync } from "node:fs";
 import Inison from "inison";
+import { isExists } from "./file.js";
 import Inibase from "./index.js";
 import { isJSON, isNumber, setField, unsetField } from "./utils.js";
-import { isExists } from "./file.js";
 const textGreen = (input) => `\u001b[1;32m${input}\u001b[0m`;
 const textRed = (input) => `\u001b[1;31m${input}\u001b[0m`;
 const textBlue = (input) => `\u001b[1;34m${input}\u001b[0m`;

package/dist/file.js

@@ -1,12 +1,12 @@
-import { open, access, writeFile, readFile, constants as fsConstants, unlink, copyFile, appendFile, } from "node:fs/promises";
+import { access, appendFile, copyFile, constants as fsConstants, open, readFile, unlink, writeFile, } from "node:fs/promises";
+import { join } from "node:path";
 import { createInterface } from "node:readline";
 import { Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { createGzip, createGunzip } from "node:zlib";
-import { join } from "node:path";
+import { createGunzip, createGzip } from "node:zlib";
 import Inison from "inison";
 import { detectFieldType, isArrayOfObjects, isJSON, isNumber, isObject, } from "./utils.js";
-import { encodeID, compare, exec, gzip, gunzip } from "./utils.server.js";
+import { compare, encodeID, exec, gunzip, gzip } from "./utils.server.js";
 export const lock = async (folderPath, prefix) => {
     let lockFile = null;
     const lockFilePath = join(folderPath, `${prefix ?? ""}.locked`);
@@ -109,7 +109,7 @@ export const encode = (input) => Array.isArray(input)
  */
 const unSecureString = (input) => {
     if (isNumber(input))
-        return Number(input);
+        return String(input).at(0) === "0" ? input : Number(input);
     if (typeof input === "string")
         return input.replace(/\\n/g, "\n") || null;
     return null;
@@ -401,7 +401,6 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
     const matchingLines = {};
     // Initialize counters for line number, found items, and processed items.
     let linesCount = 0;
-    let foundItems = 0;
     const linesNumbers = new Set();
     let fileHandle = null;
     try {
@@ -426,13 +425,12 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
             // If the line meets the conditions, process it.
             if (meetsConditions) {
                 // Increment the found items counter.
-                foundItems++;
                 linesNumbers.add(linesCount);
                 // Check if the line should be skipped based on the offset.
-                if (offset && foundItems < offset)
+                if (offset && linesNumbers.size < offset)
                     continue;
                 // Check if the limit has been reached.
-                if (limit && foundItems > limit) {
+                if (limit && linesNumbers.size > limit + (offset ?? 0)) {
                     if (readWholeFile)
                         continue;
                     break;
@@ -442,8 +440,8 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
             }
         }
         // Convert the Map to an object using Object.fromEntries and return the result.
-        return foundItems
-            ? [matchingLines, foundItems, linesNumbers.size ? linesNumbers : null]
+        return linesNumbers.size
+            ? [matchingLines, linesNumbers.size, linesNumbers]
             : [null, 0, null];
     }
     finally {

package/dist/index.d.ts

@@ -150,12 +150,9 @@ export default class Inibase {
      *
      * @param {string} tableName
      * @param {(number | string | (number | string)[] | Criteria)} [where]
-     * @return {*}  {(Promise<string | number | (string | number)[] | null>)}
+     * @return {boolean | null}  {(Promise<boolean | null>)}
      */
-    delete(tableName: string, where?: number | string, _id?: string | string[]): Promise<string | null>;
-    delete(tableName: string, where?: (number | string)[] | Criteria, _id?: string | string[]): Promise<string[] | null>;
-    delete(tableName: string, where?: number, _id?: string | string[]): Promise<number | null>;
-    delete(tableName: string, where?: number[], _id?: string | string[]): Promise<number[] | null>;
+    delete(tableName: string, where?: number | string | (number | string)[] | Criteria, _id?: string | string[]): Promise<boolean | null>;
     /**
      * Generate sum of column(s) in a table
      *

package/dist/index.js

@@ -1,8 +1,8 @@
 import "dotenv/config";
-import { unlink, rename, mkdir, readdir, writeFile, readFile, } from "node:fs/promises";
-import { existsSync, appendFileSync, readFileSync } from "node:fs";
+import { randomBytes, scryptSync } from "node:crypto";
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+import { mkdir, readFile, readdir, rename, unlink, writeFile, } from "node:fs/promises";
 import { join, parse } from "node:path";
-import { scryptSync, randomBytes } from "node:crypto";
 import { inspect } from "node:util";
 import Inison from "inison";
 import * as File from "./file.js";
@@ -97,7 +97,7 @@ export default class Inibase {
         // if config not set => load default global env config
         if (!config)
             config = {
-                compression: process.env.INIBASE_COMPRESSION === "true",
+                compression: process.env.INIBASE_COMPRESSION == "true",
                 cache: process.env.INIBASE_CACHE === "true",
                 prepend: process.env.INIBASE_PREPEND === "true",
             };
@@ -110,7 +110,7 @@ export default class Inibase {
                 await writeFile(join(tablePath, ".prepend.config"), "");
         }
         if (schema)
-            await writeFile(join(tablePath, "schema.json"), JSON.stringify(UtilsServer.addIdToSchema(schema, 0, this.salt, false), null, 2));
+            await writeFile(join(tablePath, "schema.json"), JSON.stringify(UtilsServer.addIdToSchema(schema, 0, this.salt), null, 2));
     }
     /**
      * Update table schema or config
@@ -178,7 +178,7 @@ export default class Inibase {
                 // update columns files names based on field id
                 schema = UtilsServer.addIdToSchema(schema, table.schema?.length
                     ? UtilsServer.findLastIdNumber(table.schema, this.salt)
-                    : 0, this.salt, false);
+                    : 0, this.salt);
                 if (table.schema?.length) {
                     const replaceOldPathes = Utils.findChangedProperties(this._schemaToIdsPath(tableName, table.schema), this._schemaToIdsPath(tableName, schema));
                     if (replaceOldPathes)
@@ -189,7 +189,7 @@ export default class Inibase {
                 }
             }
             else
-                schema = UtilsServer.addIdToSchema(schema, 0, this.salt, false);
+                schema = UtilsServer.addIdToSchema(schema, 0, this.salt);
             await writeFile(join(tablePath, "schema.json"), JSON.stringify(schema, null, 2));
         }
         delete this.tables[tableName];
@@ -277,22 +277,7 @@ export default class Inibase {
                     throw this.throwError("INVALID_TYPE", [
                         field.key,
                         Array.isArray(field.type) ? field.type.join(", ") : field.type,
-                        Utils.detectFieldType(data[field.key], [
-                            "string",
-                            "number",
-                            "boolean",
-                            "date",
-                            "email",
-                            "url",
-                            "table",
-                            "object",
-                            "array",
-                            "password",
-                            "html",
-                            "ip",
-                            "json",
-                            "id",
-                        ]) ?? "undefinedType",
+                        data[field.key],
                     ]);
                 if ((field.type === "array" || field.type === "object") &&
                     field.children &&
@@ -306,46 +291,26 @@ export default class Inibase {
             }
         }
     }
-    formatField(value, field, formatOnlyAvailiableKeys) {
-        if (Array.isArray(field.type))
-            field.type = (Utils.detectFieldType(value, field.type) ??
-                field.type[0]);
-        switch (field.type) {
+    formatField(value, fieldType, fieldChildrenType, _formatOnlyAvailiableKeys) {
+        if (Array.isArray(fieldType))
+            fieldType = (Utils.detectFieldType(value, fieldType) ??
+                fieldType[0]);
+        if (!value)
+            return null;
+        switch (fieldType) {
             case "array":
-                if (typeof field.children === "string") {
-                    if (field.children === "table") {
-                        if (Array.isArray(value)) {
-                            if (Utils.isArrayOfObjects(value)) {
-                                if (value.every((item) => Object.hasOwn(item, "id") &&
-                                    (Utils.isValidID(item.id) || Utils.isNumber(item.id))))
-                                    value.map((item) => item.id
-                                        ? Utils.isNumber(item.id)
-                                            ? Number(item.id)
-                                            : UtilsServer.decodeID(item.id, this.salt)
-                                        : null);
-                            }
-                            else if (value.every(Utils.isValidID) ||
-                                value.every(Utils.isNumber))
-                                return value.map((item) => Utils.isNumber(item)
-                                    ? Number(item)
-                                    : UtilsServer.decodeID(item, this.salt));
-                        }
-                        else if (Utils.isValidID(value))
-                            return [UtilsServer.decodeID(value, this.salt)];
-                        else if (Utils.isNumber(value))
-                            return [Number(value)];
-                    }
-                    else
-                        return Array.isArray(value) ? value : [value];
-                }
-                else if (Utils.isArrayOfObjects(field.children))
-                    return this.formatData(value, field.children, formatOnlyAvailiableKeys);
-                else if (Array.isArray(field.children))
-                    return Array.isArray(value) ? value : [value];
-                break;
+                if (!fieldChildrenType)
+                    return null;
+                if (!Array.isArray(value))
+                    value = [value];
+                if (Utils.isArrayOfObjects(fieldChildrenType))
+                    return this.formatData(value, fieldChildrenType, _formatOnlyAvailiableKeys);
+                return value.map((_value) => this.formatField(_value, fieldChildrenType));
             case "object":
-                if (Utils.isArrayOfObjects(field.children))
-                    return this.formatData(value, field.children, formatOnlyAvailiableKeys);
+                if (Array.isArray(value))
+                    value = value[0];
+                if (Utils.isArrayOfObjects(fieldChildrenType))
+                    return this.formatData(value, fieldChildrenType, _formatOnlyAvailiableKeys);
                 break;
             case "table":
                 if (Array.isArray(value))
@@ -373,6 +338,14 @@ export default class Inibase {
                 if (Array.isArray(value))
                     value = value[0];
                 return Utils.isNumber(value) ? Number(value) : null;
+            case "date": {
+                if (Array.isArray(value))
+                    value = value[0];
+                if (Utils.isNumber(value))
+                    return value;
+                const dateToTimestamp = Date.parse(value);
+                return Number.isNaN(dateToTimestamp) ? null : dateToTimestamp;
+            }
             case "id":
                 if (Array.isArray(value))
                     value = value[0];
@@ -410,12 +383,12 @@ export default class Inibase {
             const RETURN = {};
             for (const field of schema) {
                 if (!Object.hasOwn(data, field.key)) {
-                    if (formatOnlyAvailiableKeys || !field.required)
+                    if (formatOnlyAvailiableKeys)
                         continue;
                     RETURN[field.key] = this.getDefaultValue(field);
                     continue;
                 }
-                RETURN[field.key] = this.formatField(data[field.key], field, formatOnlyAvailiableKeys);
+                RETURN[field.key] = this.formatField(data[field.key], field.type, field.children, formatOnlyAvailiableKeys);
             }
             return RETURN;
         }
@@ -764,7 +737,7 @@ export default class Inibase {
                     searchOperator = "=";
                     searchComparedAtValue = value;
                 }
-                const [searchResult, totalLines, linesNumbers] = await File.search(join(tablePath, `${key}${this.getFileExtension(tableName)}`), searchOperator ?? "=", searchComparedAtValue ?? null, searchLogicalOperator, field?.type, field?.children, options.perPage, options.page - 1 * options.perPage + 1, true, this.salt);
+                const [searchResult, totalLines, linesNumbers] = await File.search(join(tablePath, `${key}${this.getFileExtension(tableName)}`), searchOperator ?? "=", searchComparedAtValue ?? null, searchLogicalOperator, field?.type, field?.children, options.perPage, (options.page - 1) * options.perPage + 1, true, this.salt);
                 if (searchResult) {
                     RETURN = Utils.deepMerge(RETURN, Object.fromEntries(Object.entries(searchResult).map(([id, value]) => [
                         id,
@@ -813,7 +786,10 @@ export default class Inibase {
      * @param {string} tableName
      */
     async clearCache(tableName) {
-        await Promise.all((await readdir(join(this.databasePath, tableName, ".cache"))).map((file) => unlink(join(this.databasePath, tableName, ".cache", file))));
+        const cacheFolderPath = join(this.databasePath, tableName, ".cache");
+        await Promise.all((await readdir(cacheFolderPath))
+            .filter((file) => file !== ".pagination")
+            .map((file) => unlink(join(cacheFolderPath, file))));
     }
     async get(tableName, where, options = {
         page: 1,
@@ -834,8 +810,11 @@ export default class Inibase {
         options.page = options.page || 1;
         options.perPage = options.perPage || 15;
         let RETURN;
-        let schema = (await this.throwErrorIfTableEmpty(tableName))
-            .schema;
+        let schema = (await this.getTable(tableName)).schema;
+        if (!schema)
+            throw this.throwError("NO_SCHEMA", tableName);
+        if (!(await File.isExists(join(tablePath, `id${this.getFileExtension(tableName)}`))))
+            return null;
         if (options.columns?.length)
             schema = this._filterSchemaByColumns(schema, options.columns);
         if (where &&
@@ -847,12 +826,12 @@ export default class Inibase {
             RETURN = Object.values(await this.getItemsFromSchema(tableName, schema, Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
                 index +
                 1), options));
-            if (await File.isExists(join(tablePath, ".pagination")))
-                this.totalItems[`${tableName}-*`] = Number((await readFile(join(tablePath, ".pagination"), "utf8")).split(",")[1]);
+            if (await File.isExists(join(tablePath, ".cache", ".pagination")))
+                this.totalItems[`${tableName}-*`] = Number((await readFile(join(tablePath, ".cache", ".pagination"), "utf8")).split(",")[1]);
             else {
                 const lastId = Number(Object.keys((await File.get(join(tablePath, `id${this.getFileExtension(tableName)}`), -1, "number", undefined, this.salt, true))?.[0] ?? 0));
                 this.totalItems[`${tableName}-*`] = await File.count(join(tablePath, `id${this.getFileExtension(tableName)}`));
-                await writeFile(join(tablePath, ".pagination"), `${lastId},${this.totalItems[`${tableName}-*`]}`);
+                await writeFile(join(tablePath, ".cache", ".pagination"), `${lastId},${this.totalItems[`${tableName}-*`]}`);
             }
         }
         else if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
@@ -908,8 +887,11 @@ export default class Inibase {
             if (RETURN && linesNumbers) {
                 if (onlyLinesNumbers)
                     return Object.keys(RETURN).map(Number);
-                const alreadyExistsColumns = Object.keys(Object.values(RETURN)[0]);
-                RETURN = Object.values(Utils.deepMerge(RETURN, await this.getItemsFromSchema(tableName, schema.filter(({ key }) => !alreadyExistsColumns.includes(key)), Object.keys(RETURN).map(Number), options)));
+                const alreadyExistsColumns = Object.keys(Object.values(RETURN)[0]), alreadyExistsColumnsIDs = Utils.flattenSchema(schema)
+                    .filter(({ key }) => alreadyExistsColumns.includes(key))
+                    .map(({ id }) => id);
+                RETURN = Object.values(Utils.deepMerge(RETURN, await this.getItemsFromSchema(tableName, Utils.filterSchema(schema, ({ id, type, children }) => !alreadyExistsColumnsIDs.includes(id) ||
+                    Utils.isFieldType("table", type, children)), Object.keys(RETURN).map(Number), options)));
                 if (this.tables[tableName].config.cache)
                     await writeFile(cachedFilePath, Array.from(linesNumbers).join(","));
             }
@@ -947,8 +929,8 @@ export default class Inibase {
         try {
             await File.lock(join(tablePath, ".tmp"), keys);
             if (await File.isExists(join(tablePath, `id${this.getFileExtension(tableName)}`))) {
-                if (await File.isExists(join(tablePath, ".pagination")))
-                    [lastId, this.totalItems[`${tableName}-*`]] = (await readFile(join(tablePath, ".pagination"), "utf8"))
+                if (await File.isExists(join(tablePath, ".cache", ".pagination")))
+                    [lastId, this.totalItems[`${tableName}-*`]] = (await readFile(join(tablePath, ".cache", ".pagination"), "utf8"))
                         .split(",")
                         .map(Number);
                 else {
@@ -988,7 +970,7 @@ export default class Inibase {
             this.totalItems[`${tableName}-*`] += Array.isArray(RETURN)
                 ? RETURN.length
                 : 1;
-            await writeFile(join(tablePath, ".pagination"), `${lastId},${this.totalItems[`${tableName}-*`]}`);
+            await writeFile(join(tablePath, ".cache", ".pagination"), `${lastId},${this.totalItems[`${tableName}-*`]}`);
             if (returnPostedData)
                 return this.get(tableName, this.tables[tableName].config.prepend
                     ? Array.isArray(RETURN)
@@ -1028,8 +1010,8 @@ export default class Inibase {
                 return this.put(tableName, data, data.id);
             }
             let totalItems;
-            if (await File.isExists(join(tablePath, ".pagination")))
-                totalItems = (await readFile(join(tablePath, ".pagination"), "utf8"))
+            if (await File.isExists(join(tablePath, ".cache", ".pagination")))
+                totalItems = (await readFile(join(tablePath, ".cache", ".pagination"), "utf8"))
                     .split(",")
                     .map(Number)[1];
             else
@@ -1078,7 +1060,7 @@ export default class Inibase {
                 }), {}),
             ]));
             const keys = UtilsServer.hashString(Object.keys(pathesContents)
-                .map((path) => path.replaceAll(".inib", ""))
+                .map((path) => path.replaceAll(this.getFileExtension(tableName), ""))
                 .join("."));
             try {
                 await File.lock(join(tablePath, ".tmp"), keys);
@@ -1105,6 +1087,13 @@ export default class Inibase {
         else
             throw this.throwError("INVALID_PARAMETERS");
     }
+    /**
+     * Delete item(s) in a table
+     *
+     * @param {string} tableName
+     * @param {(number | string | (number | string)[] | Criteria)} [where]
+     * @return {boolean | null}  {(Promise<boolean | null>)}
+     */
     async delete(tableName, where, _id) {
         const renameList = [];
         const tablePath = join(this.databasePath, tableName);
@@ -1113,15 +1102,15 @@ export default class Inibase {
             try {
                 await File.lock(join(tablePath, ".tmp"));
                 await Promise.all((await readdir(tablePath))
-                    ?.filter((fileName) => fileName.endsWith(".inib"))
+                    ?.filter((fileName) => fileName.endsWith(this.getFileExtension(tableName)))
                     .map(async (file) => unlink(join(tablePath, file))));
                 if (this.tables[tableName].config.cache)
                     await this.clearCache(tableName);
+                return true;
             }
             finally {
                 await File.unlock(join(tablePath, ".tmp"));
             }
-            return "*";
         }
         if ((Array.isArray(where) && where.every(Utils.isValidID)) ||
             Utils.isValidID(where)) {
@@ -1139,15 +1128,13 @@ export default class Inibase {
                     await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
                     if (this.tables[tableName].config.cache)
                         await this.clearCache(tableName);
-                    if (await File.isExists(join(tablePath, ".pagination"))) {
-                        const [lastId, totalItems] = (await readFile(join(tablePath, ".pagination"), "utf8"))
+                    if (await File.isExists(join(tablePath, ".cache", ".pagination"))) {
+                        const [lastId, totalItems] = (await readFile(join(tablePath, ".cache", ".pagination"), "utf8"))
                             .split(",")
                             .map(Number);
-                        await writeFile(join(tablePath, ".pagination"), `${lastId},${totalItems - (Array.isArray(where) ? where.length : 1)}`);
+                        await writeFile(join(tablePath, ".cache", ".pagination"), `${lastId},${totalItems - (Array.isArray(where) ? where.length : 1)}`);
                     }
-                    if (_id)
-                        return Array.isArray(_id) && _id.length === 1 ? _id[0] : _id;
-                    return where;
+                    return true;
                 }
                 finally {
                     if (renameList.length)
@@ -1162,7 +1149,7 @@ export default class Inibase {
         }
         else
             throw this.throwError("INVALID_PARAMETERS");
-        return null;
+        return false;
     }
     async sum(tableName, columns, where) {
         const RETURN = {};

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import type { FieldType, ComparisonOperator, Field, Schema } from "./index.js";
+import type { ComparisonOperator, Field, FieldType, Schema } from "./index.js";
 /**
  * Type guard function to check if the input is an array of objects.
  *
@@ -156,6 +156,9 @@ export declare const findChangedProperties: (obj1: Record<string, string>, obj2:
  * @returns The detected field type as a string, or undefined if no matching type is found.
  */
 export declare const detectFieldType: (input: any, availableTypes: FieldType[]) => FieldType | undefined;
+export declare const isFieldType: (compareAtType: string | string[], fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[] | Schema) => boolean;
+export declare const flattenSchema: (schema: Schema, keepParents?: boolean) => Schema;
+export declare const filterSchema: (schema: Schema, callback: (arg0: Field) => boolean) => Field[];
 /**
  * Validates if the given value matches the specified field type(s).
  *
@@ -165,7 +168,7 @@ export declare const detectFieldType: (input: any, availableTypes: FieldType[])
  * @returns A boolean indicating whether the value matches the specified field type(s).
  */
 export declare const validateFieldType: (value: any, fieldType: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[]) => boolean;
-export declare function FormatObjectCriteriaValue(value: string, isParentArray?: boolean): [
+export declare function FormatObjectCriteriaValue(value: string): [
     ComparisonOperator,
     string | number | boolean | null | (string | number | null)[]
 ];

package/dist/utils.js

@@ -118,7 +118,7 @@ export const isHTML = (input) => /<\/?\s*[a-z-][^>]*\s*>|(\&(?:[\w\d]+|#\d+|#x[a
  * Note: Validates the input against being a number, boolean, email, URL, or IP address to ensure it's a general string.
  */
 export const isString = (input) => Object.prototype.toString.call(input) === "[object String]" &&
-    !isNumber(input);
+    (!isNumber(input) || String(input).at(0) === "0");
 /**
  * Checks if the input is a valid IP address format.
  *
@@ -152,7 +152,9 @@ export const isPassword = (input) => typeof input === "string" && input.length =
  * @param input - The input to be checked, can be of any type.
  * @returns A boolean indicating whether the input is a valid date.
  */
-export const isDate = (input) => !Number.isNaN(new Date(input).getTime()) || !Number.isNaN(Date.parse(input));
+export const isDate = (input) => !Number.isNaN(new Date(input).getTime()) ||
+    !Number.isNaN(Date.parse(input)) ||
+    !!input.match(/\b\d{2}[/.-]\d{2}[/.-]\d{4}\b/);
 /**
  * Checks if the input is a valid ID.
  *
@@ -206,6 +208,8 @@ export const detectFieldType = (input, availableTypes) => {
                     return "date";
                 if (availableTypes.includes("number"))
                     return "number";
+                if (availableTypes.includes("string") && String(input).at(0) === "0")
+                    return "string";
             }
             else if (typeof input === "string") {
                 if (availableTypes.includes("table") && isValidID(input))
@@ -232,6 +236,59 @@ export const detectFieldType = (input, availableTypes) => {
             return "array";
     return undefined;
 };
+export const isFieldType = (compareAtType, fieldType, fieldChildrenType) => {
+    if (fieldType) {
+        if (Array.isArray(fieldType)) {
+            if (fieldType.some((type) => Array.isArray(compareAtType)
+                ? compareAtType.includes(type)
+                : compareAtType === type))
+                return true;
+        }
+        else if ((Array.isArray(compareAtType) && compareAtType.includes(fieldType)) ||
+            compareAtType === fieldType)
+            return true;
+    }
+    if (fieldChildrenType) {
+        if (Array.isArray(fieldChildrenType)) {
+            if (!isArrayOfObjects(fieldChildrenType)) {
+                if (fieldChildrenType.some((type) => Array.isArray(compareAtType)
+                    ? compareAtType.includes(type)
+                    : compareAtType === type))
+                    return true;
+            }
+        }
+        else if ((Array.isArray(compareAtType) &&
+            compareAtType.includes(fieldChildrenType)) ||
+            compareAtType === fieldChildrenType)
+            return true;
+    }
+    return false;
+};
+// Function to recursively flatten an array of objects and their nested children
+export const flattenSchema = (schema, keepParents = false) => {
+    const result = [];
+    function _flattenHelper(item, parentKey) {
+        if (item.children && isArrayOfObjects(item.children)) {
+            if (keepParents)
+                result.push((({ children, ...rest }) => rest)(item));
+            for (const child of item.children)
+                _flattenHelper(child, item.key);
+        }
+        else
+            result.push({
+                ...item,
+                key: parentKey ? `${parentKey}.${item.key}` : item.key,
+            });
+    }
+    for (const item of schema)
+        _flattenHelper(item, "");
+    return result;
+};
+export const filterSchema = (schema, callback) => schema.filter((field) => {
+    if (field.children && isArrayOfObjects(field.children))
+        field.children = filterSchema(field.children, callback);
+    return callback(field);
+});
 /**
  * Validates if the given value matches the specified field type(s).
  *
@@ -303,7 +360,7 @@ export const validateFieldType = (value, fieldType, fieldChildrenType) => {
             return false;
     }
 };
-export function FormatObjectCriteriaValue(value, isParentArray = false) {
+export function FormatObjectCriteriaValue(value) {
     switch (value[0]) {
         case ">":
         case "<":
@@ -339,15 +396,10 @@ export function FormatObjectCriteriaValue(value, isParentArray = false) {
                         value.slice(1),
                     ];
         case "=":
-            return isParentArray
-                ? [
-                    value.slice(0, 1),
-                    value.slice(1),
-                ]
-                : [
-                    value.slice(0, 1),
-                    `${value.slice(1)},`,
-                ];
+            return [
+                value.slice(0, 1),
+                value.slice(1),
+            ];
         case "*":
             return [
                 value.slice(0, 1),

package/dist/utils.server.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
-import type { ComparisonOperator, FieldType, Schema } from "./index.js";
 import { exec as execAsync, execFile as execFileAsync } from "node:child_process";
 import { gunzip as gunzipAsync, gzip as gzipAsync } from "node:zlib";
+import type { ComparisonOperator, Field, FieldType, Schema } from "./index.js";
 export declare const exec: typeof execAsync.__promisify__;
 export declare const execFile: typeof execFileAsync.__promisify__;
 export declare const gzip: typeof gzipAsync.__promisify__;
@@ -39,7 +39,7 @@ export declare const encodeID: (id: number | string, secretKeyOrSalt: string | n
  * @returns The decoded ID as a number.
  */
 export declare const decodeID: (input: string, secretKeyOrSalt: string | number | Buffer) => number;
-export declare const flattenSchema: (schema: Schema, secretKeyOrSalt: string | number | Buffer) => number[];
+export declare const extractIdsFromSchema: (schema: Schema, secretKeyOrSalt: string | number | Buffer) => number[];
 /**
  * Finds the last ID number in a schema, potentially decoding it if encrypted.
  *
@@ -57,7 +57,7 @@ export declare const findLastIdNumber: (schema: Schema, secretKeyOrSalt: string
  * @param encodeIDs - If true, IDs will be encoded, else they will remain as numbers.
  * @returns The updated schema with encoded IDs.
  */
-export declare const addIdToSchema: (schema: Schema, oldIndex: number, secretKeyOrSalt: string | number | Buffer, encodeIDs?: boolean) => import("./index.js").Field[];
+export declare const addIdToSchema: (schema: Schema, startWithID: number, secretKeyOrSalt: string | number | Buffer, encodeIDs?: boolean) => Field[];
 export declare const encodeSchemaID: (schema: Schema, secretKeyOrSalt: string | number | Buffer) => Schema;
 export declare const hashString: (str: string) => string;
 /**

package/dist/utils.server.js

@@ -1,8 +1,8 @@
-import { createCipheriv, createDecipheriv, randomBytes, scryptSync, createHash, } from "node:crypto";
-import { detectFieldType, isArrayOfObjects, isNumber, isPassword, isValidID, } from "./utils.js";
-import { promisify } from "node:util";
 import { exec as execAsync, execFile as execFileAsync, } from "node:child_process";
+import { createCipheriv, createDecipheriv, createHash, randomBytes, scryptSync, } from "node:crypto";
+import { promisify } from "node:util";
 import { gunzip as gunzipAsync, gzip as gzipAsync } from "node:zlib";
+import { detectFieldType, isArrayOfObjects, isNumber, isPassword, isValidID, } from "./utils.js";
 export const exec = promisify(execAsync);
 export const execFile = promisify(execFileAsync);
 export const gzip = promisify(gzipAsync);
@@ -69,7 +69,7 @@ export const decodeID = (input, secretKeyOrSalt) => {
     return Number(decipher.update(input, "hex", "utf8") + decipher.final("utf8"));
 };
 // Function to recursively flatten an array of objects and their nested children
-export const flattenSchema = (schema, secretKeyOrSalt) => {
+export const extractIdsFromSchema = (schema, secretKeyOrSalt) => {
     const result = [];
     for (const field of schema) {
         if (field.id)
@@ -77,7 +77,7 @@ export const flattenSchema = (schema, secretKeyOrSalt) => {
                 ? field.id
                 : decodeID(field.id, secretKeyOrSalt));
         if (field.children && isArrayOfObjects(field.children))
-            result.push(...flattenSchema(field.children, secretKeyOrSalt));
+            result.push(...extractIdsFromSchema(field.children, secretKeyOrSalt));
     }
     return result;
 };
@@ -88,7 +88,7 @@ export const flattenSchema = (schema, secretKeyOrSalt) => {
  * @param secretKeyOrSalt - The secret key or salt for decoding an encrypted ID, can be a string, number, or Buffer.
  * @returns The last ID number in the schema, decoded if necessary.
  */
-export const findLastIdNumber = (schema, secretKeyOrSalt) => Math.max(...flattenSchema(schema, secretKeyOrSalt));
+export const findLastIdNumber = (schema, secretKeyOrSalt) => Math.max(...extractIdsFromSchema(schema, secretKeyOrSalt));
 /**
  * Adds or updates IDs in a schema, encoding them using a provided secret key or salt.
  *
@@ -98,30 +98,30 @@ export const findLastIdNumber = (schema, secretKeyOrSalt) => Math.max(...flatten
  * @param encodeIDs - If true, IDs will be encoded, else they will remain as numbers.
  * @returns The updated schema with encoded IDs.
  */
-export const addIdToSchema = (schema, oldIndex, secretKeyOrSalt, encodeIDs) => schema.map((field) => {
-    if (!field.id) {
-        oldIndex++;
-        field.id = encodeIDs ? encodeID(oldIndex, secretKeyOrSalt) : oldIndex;
-    }
-    else {
-        if (isValidID(field.id)) {
-            oldIndex = decodeID(field.id, secretKeyOrSalt);
-            if (!encodeIDs)
-                field.id = oldIndex;
+export const addIdToSchema = (schema, startWithID, secretKeyOrSalt, encodeIDs) => {
+    function _addIdToField(field) {
+        if (!field.id) {
+            startWithID++;
+            field.id = encodeIDs
+                ? encodeID(startWithID, secretKeyOrSalt)
+                : startWithID;
         }
         else {
-            oldIndex = field.id;
-            if (encodeIDs)
+            if (isValidID(field.id)) {
+                if (!encodeIDs)
+                    field.id = decodeID(field.id, secretKeyOrSalt);
+            }
+            else if (encodeIDs)
                 field.id = encodeID(field.id, secretKeyOrSalt);
         }
+        if ((field.type === "array" || field.type === "object") &&
+            isArrayOfObjects(field.children))
+            field.children = _addIdToSchema(field.children);
+        return field;
     }
-    if ((field.type === "array" || field.type === "object") &&
-        isArrayOfObjects(field.children)) {
-        field.children = addIdToSchema(field.children, oldIndex, secretKeyOrSalt, encodeIDs);
-        oldIndex += field.children.length;
-    }
-    return field;
-});
+    const _addIdToSchema = (schema) => schema.map(_addIdToField);
+    return _addIdToSchema(schema);
+};
 export const encodeSchemaID = (schema, secretKeyOrSalt) => schema.map((field) => ({
     ...field,
     id: isNumber(field.id) ? encodeID(field.id, secretKeyOrSalt) : field.id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.72",
+  "version": "1.0.0-rc.74",
   "type": "module",
   "author": {
     "name": "Karim Amahtil",
@@ -74,7 +74,7 @@
   },
   "dependencies": {
     "dotenv": "^16.4.5",
-    "inison": "^1.0.0-rc.2"
+    "inison": "1.0.0-rc.3"
   },
   "scripts": {
     "build": "npx tsc",