inibase 1.0.0-rc.49 → 1.0.0-rc.50

package/README.md

@@ -284,8 +284,9 @@ const product_schema = [
     type: "number",
   },
   {
-    key: "user",
+    key: "createdBy",
     type: "table",
+    table: "user",
     required: true,
   },
 ];
@@ -294,12 +295,12 @@ const product_data = [
   {
     title: "Product 1",
     price: 16,
-    user: "1d88385d4b1581f8fb059334dec30f4c",
+    createdBy: "1d88385d4b1581f8fb059334dec30f4c",
   },
   {
     title: "Product 2",
     price: 10,
-    user: "5011c230aa44481bf7e8dcfe0710474f",
+    createdBy: "5011c230aa44481bf7e8dcfe0710474f",
   },
 ];
 
@@ -309,7 +310,7 @@ const product = await db.post("product", product_data);
 //     "id": "1d88385d4b1581f8fb059334dec30f4c",
 //     "title": "Product 1",
 //     "price": 16,
-//     "user": {
+//     "createdBy": {
 //       "id": "1d88385d4b1581f8fb059334dec30f4c",
 //       "username": "user1",
 //       "email": "user1@example.com",
@@ -320,7 +321,7 @@ const product = await db.post("product", product_data);
 //     "id": "5011c230aa44481bf7e8dcfe0710474f",
 //     "title": "Product 2",
 //     "price": 10,
-//     "user": {
+//     "createdBy": {
 //       "id": "5011c230aa44481bf7e8dcfe0710474f",
 //       "username": "user2",
 //       ...

package/dist/file.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" resolution-mode="require"/>
-import { ComparisonOperator, FieldType } from "./index.js";
+import { ComparisonOperator, FieldType, Schema } from "./index.js";
 export declare const lock: (folderPath: string, prefix?: string) => Promise<void>;
 export declare const unlock: (folderPath: string, prefix?: string) => Promise<void>;
 export declare const write: (filePath: string, data: any, disableCompression?: boolean) => Promise<void>;
@@ -30,7 +30,7 @@ export declare const encode: (input: string | number | boolean | null | (string
  * @param secretKey - Optional secret key for decoding, can be a string or Buffer.
  * @returns Decoded value as a string, number, boolean, or array of these, or null if no fieldType or input is null/empty.
  */
-export declare const decode: (input: string | null | number, fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[], secretKey?: string | Buffer) => string | number | boolean | null | (string | number | null | boolean)[];
+export declare const decode: (input: string | null | number, fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[] | Schema, secretKey?: string | Buffer) => string | number | boolean | null | (string | number | null | boolean)[];
 /**
  * Asynchronously reads and decodes data from a file at specified line numbers.
  * Decodes each line based on specified field types and an optional secret key.
@@ -44,7 +44,7 @@ export declare const decode: (input: string | null | number, fieldType?: FieldTy
  *   1. Record of line numbers and their decoded content or null if no lines are read.
  *   2. Total count of lines processed.
  */
-export declare function get(filePath: string, lineNumbers?: number | number[], fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[], secretKey?: string | Buffer, readWholeFile?: false): Promise<Record<number, string | number | boolean | null | (string | number | boolean | (string | number | boolean)[] | null)[]> | null>;
+export declare function get(filePath: string, lineNumbers?: number | number[], fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[] | Schema, secretKey?: string | Buffer, readWholeFile?: false): Promise<Record<number, string | number | boolean | null | (string | number | boolean | (string | number | boolean)[] | null)[]> | null>;
 export declare function get(filePath: string, lineNumbers: undefined | number | number[], fieldType: undefined | FieldType | FieldType[], fieldChildrenType: undefined | FieldType | FieldType[], secretKey: undefined | string | Buffer, readWholeFile: true): Promise<[
     Record<number, string | number | boolean | null | (string | number | boolean | (string | number | boolean)[] | null)[]> | null,
     number
@@ -98,7 +98,7 @@ export declare const remove: (filePath: string, linesToDelete: number | number[]
  *
  * Note: Decodes each line for comparison and can handle complex queries with multiple conditions.
  */
-export declare const search: (filePath: string, operator: ComparisonOperator | ComparisonOperator[], comparedAtValue: string | number | boolean | null | (string | number | boolean | null)[], logicalOperator?: "and" | "or", fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[], limit?: number, offset?: number, readWholeFile?: boolean, secretKey?: string | Buffer) => Promise<[
+export declare const search: (filePath: string, operator: ComparisonOperator | ComparisonOperator[], comparedAtValue: string | number | boolean | null | (string | number | boolean | null)[], logicalOperator?: "and" | "or", fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[] | Schema, limit?: number, offset?: number, readWholeFile?: boolean, secretKey?: string | Buffer) => Promise<[
     Record<number, string | number | boolean | null | (string | number | boolean | null)[]> | null,
     number,
     Set<number> | null
@@ -158,10 +158,10 @@ export declare const sort: (filePath: string, sortDirection: 1 | -1 | "asc" | "d
 export default class File {
     static get: typeof get;
     static remove: (filePath: string, linesToDelete: number | number[]) => Promise<string[]>;
-    static search: (filePath: string, operator: ComparisonOperator | ComparisonOperator[], comparedAtValue: string | number | boolean | (string | number | boolean | null)[] | null, logicalOperator?: "and" | "or" | undefined, fieldType?: FieldType | FieldType[] | undefined, fieldChildrenType?: FieldType | FieldType[] | undefined, limit?: number | undefined, offset?: number | undefined, readWholeFile?: boolean | undefined, secretKey?: string | Buffer | undefined) => Promise<[Record<number, string | number | boolean | (string | number | boolean | null)[] | null> | null, number, Set<number> | null]>;
+    static search: (filePath: string, operator: ComparisonOperator | ComparisonOperator[], comparedAtValue: string | number | boolean | (string | number | boolean | null)[] | null, logicalOperator?: "and" | "or" | undefined, fieldType?: FieldType | FieldType[] | undefined, fieldChildrenType?: FieldType | FieldType[] | Schema | undefined, limit?: number | undefined, offset?: number | undefined, readWholeFile?: boolean | undefined, secretKey?: string | Buffer | undefined) => Promise<[Record<number, string | number | boolean | (string | number | boolean | null)[] | null> | null, number, Set<number> | null]>;
     static replace: (filePath: string, replacements: string | number | boolean | (string | number | boolean | null)[] | Record<number, string | number | boolean | (string | number | boolean | null)[] | null> | null) => Promise<string[]>;
     static encode: (input: string | number | boolean | (string | number | boolean | null)[] | null) => string | number | boolean | null;
-    static decode: (input: string | number | null, fieldType?: FieldType | FieldType[] | undefined, fieldChildrenType?: FieldType | FieldType[] | undefined, secretKey?: string | Buffer | undefined) => string | number | boolean | (string | number | boolean | null)[] | null;
+    static decode: (input: string | number | null, fieldType?: FieldType | FieldType[] | undefined, fieldChildrenType?: FieldType | FieldType[] | Schema | undefined, secretKey?: string | Buffer | undefined) => string | number | boolean | (string | number | boolean | null)[] | null;
     static isExists: (path: string) => Promise<boolean>;
     static sum: (filePath: string, lineNumbers?: number | number[] | undefined) => Promise<number>;
     static min: (filePath: string, lineNumbers?: number | number[] | undefined) => Promise<number>;

package/dist/file.js

@@ -5,7 +5,7 @@ import { pipeline } from "node:stream/promises";
 import { createGzip, createGunzip, gunzipSync, gzipSync } from "node:zlib";
 import { join } from "node:path";
 import { Worker } from "node:worker_threads";
-import { detectFieldType, isJSON, isNumber, isObject } from "./utils.js";
+import { detectFieldType, isArrayOfObjects, isJSON, isNumber, isObject, } from "./utils.js";
 import { encodeID, compare } from "./utils.server.js";
 import Config from "./config.js";
 import Inison from "inison";
@@ -122,7 +122,7 @@ const unSecureString = (input) => {
     if (isNumber(input))
         return Number(input);
     if (typeof input === "string")
-        return input.replace(/\n/g, "\\n") || null;
+        return input.replace(/\\n/g, "\n") || null;
     return null;
 };
 /**
@@ -146,7 +146,7 @@ const decodeHelper = (value, fieldType, fieldChildrenType, secretKey) => {
         case "array":
             if (!Array.isArray(value))
                 return [value];
-            if (fieldChildrenType)
+            if (fieldChildrenType && !isArrayOfObjects(fieldChildrenType))
                 return fieldChildrenType
                     ? value.map((v) => decode(v, Array.isArray(fieldChildrenType)
                         ? detectFieldType(v, fieldChildrenType)
@@ -423,11 +423,7 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
         }
         // Convert the Map to an object using Object.fromEntries and return the result.
         return foundItems
-            ? [
-                matchingLines,
-                readWholeFile ? foundItems : foundItems - 1,
-                linesNumbers.size ? linesNumbers : null,
-            ]
+            ? [matchingLines, foundItems, linesNumbers.size ? linesNumbers : null]
             : [null, 0, null];
     }
     finally {

package/dist/index.d.ts

@@ -6,32 +6,15 @@ export interface Data {
     updatedAt?: number;
 }
 export type FieldType = "string" | "number" | "boolean" | "date" | "email" | "url" | "table" | "object" | "array" | "password" | "html" | "ip" | "json" | "id";
-type FieldDefault = {
+export type Field = {
     id?: string | number;
     key: string;
+    type: FieldType | FieldType[];
     required?: boolean;
+    table?: string;
+    unique?: boolean;
+    children?: FieldType | FieldType[] | Schema;
 };
-type FieldStringType = {
-    type: Exclude<FieldType, "array" | "object">;
-    children?: never;
-};
-type FieldStringArrayType = {
-    type: Array<Exclude<FieldType, "object">>;
-    children?: never;
-};
-type FieldArrayType = {
-    type: "array";
-    children: Exclude<FieldType, "array"> | Array<Exclude<FieldType, "array">> | Schema;
-};
-type FieldArrayArrayType = {
-    type: Array<"array" | Exclude<FieldType, "array" | "object">>;
-    children: Exclude<FieldType, "array" | "object"> | Array<Exclude<FieldType, "array" | "object">>;
-};
-type FieldObjectType = {
-    type: "object";
-    children: Schema;
-};
-export type Field = FieldDefault & (FieldStringType | FieldStringArrayType | FieldArrayArrayType | FieldObjectType | FieldArrayType);
 export type Schema = Field[];
 export interface Options {
     page?: number;
@@ -57,26 +40,27 @@ declare global {
         entries<T extends object>(o: T): Entries<T>;
     }
 }
-export type ErrorCodes = "FIELD_REQUIRED" | "NO_SCHEMA" | "NO_ITEMS" | "NO_RESULTS" | "INVALID_ID" | "INVALID_TYPE" | "INVALID_PARAMETERS";
+export type ErrorCodes = "FIELD_UNIQUE" | "FIELD_REQUIRED" | "NO_SCHEMA" | "NO_ITEMS" | "NO_RESULTS" | "INVALID_ID" | "INVALID_TYPE" | "INVALID_PARAMETERS";
 export type ErrorLang = "en";
 export default class Inibase {
     folder: string;
     database: string;
     table: string | null;
     pageInfo: Record<string, pageInfo>;
+    private checkIFunique;
     private isThreadEnabled;
     private totalItems;
     salt: Buffer;
     constructor(database: string, mainFolder?: string, _table?: string | null, _totalItems?: Record<string, number>, _pageInfo?: Record<string, pageInfo>, _isThreadEnabled?: boolean);
     private throwError;
     createWorker(functionName: "get" | "post" | "put" | "delete" | "sum" | "min" | "max" | "sort", arg: any[]): Promise<any>;
-    private _decodeIdFromSchema;
     private _schemaToIdsPath;
     setTableSchema(tableName: string, schema: Schema): Promise<void>;
-    getTableSchema(tableName: string): Promise<Schema | undefined>;
+    getTableSchema(tableName: string, encodeIDs?: boolean): Promise<Schema | undefined>;
     getSchemaWhenTableNotEmpty(tableName: string, schema?: Schema): Promise<never | Schema>;
     private validateData;
     private formatField;
+    private checkUnique;
     private formatData;
     private getDefaultValue;
     private _combineObjectsToArray;

package/dist/index.js

@@ -14,6 +14,7 @@ export default class Inibase {
     database;
     table;
     pageInfo;
+    checkIFunique;
     isThreadEnabled = false;
     totalItems;
     salt;
@@ -24,6 +25,7 @@ export default class Inibase {
         this.totalItems = _totalItems;
         this.pageInfo = _pageInfo;
         this.isThreadEnabled = _isThreadEnabled;
+        this.checkIFunique = {};
         if (!existsSync(".env") || !process.env.INIBASE_SECRET) {
             this.salt = scryptSync(randomBytes(16), randomBytes(16), 32);
             appendFileSync(".env", `\nINIBASE_SECRET=${this.salt.toString("hex")}\n`);
@@ -34,6 +36,7 @@ export default class Inibase {
     throwError(code, variable, language = "en") {
         const errorMessages = {
             en: {
+                FIELD_UNIQUE: "Field {variable} should be unique, got {variable} instead",
                 FIELD_REQUIRED: "Field {variable} is required",
                 NO_SCHEMA: "Table {variable} does't have a schema",
                 NO_ITEMS: "Table {variable} is empty",
@@ -73,15 +76,6 @@ export default class Inibase {
             worker.on("error", reject);
         });
     }
-    _decodeIdFromSchema = (schema) => schema.map((field) => {
-        if ((field.type === "array" || field.type === "object") &&
-            field.children &&
-            Utils.isArrayOfObjects(field.children))
-            field.children = this._decodeIdFromSchema(field.children);
-        if (field.id && !Utils.isNumber(field.id))
-            field.id = UtilsServer.decodeID(field.id, this.salt);
-        return field;
-    });
     _schemaToIdsPath = (schema, prefix = "") => {
         let RETURN = {};
         for (const field of schema)
@@ -90,16 +84,14 @@ export default class Inibase {
                 Utils.isArrayOfObjects(field.children)) {
                 Utils.deepMerge(RETURN, this._schemaToIdsPath(field.children, (prefix ?? "") + field.key + "."));
             }
-            else if (Utils.isValidID(field.id))
-                RETURN[UtilsServer.decodeID(field.id, this.salt)] =
-                    (prefix ?? "") + field.key + ".inib";
+            else if (field.id)
+                RETURN[field.id] = (prefix ?? "") + field.key + ".inib";
         return RETURN;
     };
     async setTableSchema(tableName, schema) {
         const tablePath = join(this.folder, this.database, tableName), tableSchemaPath = join(tablePath, "schema.json"), isTablePathExists = await File.isExists(tablePath);
         // remove id from schema
         schema = schema.filter(({ key }) => !["id", "createdAt", "updatedAt"].includes(key));
-        schema = UtilsServer.addIdToSchema(schema, UtilsServer.findLastIdNumber(schema, this.salt), this.salt, isTablePathExists);
         if (!isTablePathExists)
             await mkdir(tablePath, { recursive: true });
         if (!(await File.isExists(join(tablePath, ".tmp"))))
@@ -108,16 +100,24 @@ export default class Inibase {
             await mkdir(join(tablePath, ".cache"));
         if (await File.isExists(tableSchemaPath)) {
             // update columns files names based on field id
-            const replaceOldPathes = Utils.findChangedProperties(this._schemaToIdsPath((await this.getTableSchema(tableName)) ?? []), this._schemaToIdsPath(schema));
-            if (replaceOldPathes)
-                await Promise.all(Object.entries(replaceOldPathes).map(async ([oldPath, newPath]) => {
-                    if (await File.isExists(join(tablePath, oldPath)))
-                        await rename(join(tablePath, oldPath), join(tablePath, newPath));
-                }));
+            const currentSchema = await this.getTableSchema(tableName, false);
+            schema = UtilsServer.addIdToSchema(schema, currentSchema && currentSchema.length
+                ? UtilsServer.findLastIdNumber(currentSchema, this.salt)
+                : undefined, this.salt, false);
+            if (currentSchema && currentSchema.length) {
+                const replaceOldPathes = Utils.findChangedProperties(this._schemaToIdsPath(currentSchema), this._schemaToIdsPath(schema));
+                if (replaceOldPathes)
+                    await Promise.all(Object.entries(replaceOldPathes).map(async ([oldPath, newPath]) => {
+                        if (await File.isExists(join(tablePath, oldPath)))
+                            await rename(join(tablePath, oldPath), join(tablePath, newPath));
+                    }));
+            }
         }
-        await File.write(join(tablePath, "schema.json"), JSON.stringify(isTablePathExists ? this._decodeIdFromSchema(schema) : schema, null, 2), true);
+        else
+            schema = UtilsServer.addIdToSchema(schema, undefined, this.salt, false);
+        await File.write(join(tablePath, "schema.json"), JSON.stringify(schema, null, 2), true);
     }
-    async getTableSchema(tableName) {
+    async getTableSchema(tableName, encodeIDs = true) {
         const tableSchemaPath = join(this.folder, this.database, tableName, "schema.json");
         if (!(await File.isExists(tableSchemaPath)))
             return undefined;
@@ -125,27 +125,30 @@ export default class Inibase {
         if (!schemaFile)
             return undefined;
         const schema = JSON.parse(schemaFile), lastIdNumber = UtilsServer.findLastIdNumber(schema, this.salt);
-        return [
-            {
-                id: UtilsServer.encodeID(0, this.salt),
-                key: "id",
-                type: "id",
-                required: true,
-            },
-            ...UtilsServer.addIdToSchema(schema, lastIdNumber, this.salt, true),
-            {
-                id: UtilsServer.encodeID(lastIdNumber + 1, this.salt),
-                key: "createdAt",
-                type: "date",
-                required: true,
-            },
-            {
-                id: UtilsServer.encodeID(lastIdNumber + 2, this.salt),
-                key: "updatedAt",
-                type: "date",
-                required: false,
-            },
-        ];
+        if (!encodeIDs)
+            return schema;
+        else
+            return [
+                {
+                    id: UtilsServer.encodeID(0, this.salt),
+                    key: "id",
+                    type: "id",
+                    required: true,
+                },
+                ...UtilsServer.encodeSchemaID(schema, this.salt),
+                {
+                    id: UtilsServer.encodeID(lastIdNumber + 1, this.salt),
+                    key: "createdAt",
+                    type: "date",
+                    required: true,
+                },
+                {
+                    id: UtilsServer.encodeID(lastIdNumber + 2, this.salt),
+                    key: "updatedAt",
+                    type: "date",
+                    required: false,
+                },
+            ];
     }
     async getSchemaWhenTableNotEmpty(tableName, schema) {
         const tablePath = join(this.folder, this.database, tableName);
@@ -186,6 +189,11 @@ export default class Inibase {
                     field.children &&
                     Utils.isArrayOfObjects(field.children))
                     this.validateData(data[field.key], field.children, skipRequiredField);
+                else if (field.unique) {
+                    if (!this.checkIFunique[field.key])
+                        this.checkIFunique[field.key] = [];
+                    this.checkIFunique[`${field.key}`].push(data[field.key]);
+                }
             }
         }
     }
@@ -271,8 +279,22 @@ export default class Inibase {
         }
         return null;
     }
+    async checkUnique(tableName, schema) {
+        const tablePath = join(this.folder, this.database, tableName);
+        for await (const [key, values] of Object.entries(this.checkIFunique)) {
+            const field = Utils.getField(key, schema);
+            if (!field)
+                continue;
+            const [searchResult, totalLines] = await File.search(join(tablePath, key + ".inib"), Array.isArray(values) ? "=" : "[]", values, undefined, field.type, field.children, 1, undefined, false, this.salt);
+            if (searchResult && totalLines > 0)
+                throw this.throwError("FIELD_UNIQUE", [
+                    field.key,
+                    Array.isArray(values) ? values.join(", ") : values,
+                ]);
+        }
+        this.checkIFunique = {};
+    }
     formatData(data, schema, formatOnlyAvailiableKeys) {
-        this.validateData(data, schema, formatOnlyAvailiableKeys);
         if (Utils.isArrayOfObjects(data))
             return data.map((single_data) => this.formatData(single_data, schema, formatOnlyAvailiableKeys));
         else if (Utils.isObject(data)) {
@@ -311,6 +333,8 @@ export default class Inibase {
                     ]
                     : null;
             case "object":
+                if (!field.children || !Utils.isArrayOfObjects(field.children))
+                    return null;
                 return Utils.combineObjects(field.children.map((f) => ({
                     [f.key]: this.getDefaultValue(f),
                 })));
@@ -464,7 +488,8 @@ export default class Inibase {
                 else if (field.children === "table" ||
                     (Array.isArray(field.type) && field.type.includes("table")) ||
                     (Array.isArray(field.children) && field.children.includes("table"))) {
-                    if ((await File.isExists(join(this.folder, this.database, field.key))) &&
+                    if (field.table &&
+                        (await File.isExists(join(this.folder, this.database, field.table))) &&
                         (await File.isExists(join(tablePath, (prefix ?? "") + field.key + ".inib")))) {
                         if (options.columns)
                             options.columns = options.columns
@@ -476,13 +501,13 @@ export default class Inibase {
                                 if (!RETURN[index])
                                     RETURN[index] = {};
                                 RETURN[index][field.key] = item
-                                    ? await this.get(field.key, item, options)
+                                    ? await this.get(field.table, item, options)
                                     : this.getDefaultValue(field);
                             }));
                     }
                 }
                 else if (await File.isExists(join(tablePath, (prefix ?? "") + field.key + ".inib"))) {
-                    const items = await File.get(join(tablePath, (prefix ?? "") + field.key + ".inib"), linesNumber, field.type, field?.children, this.salt);
+                    const items = await File.get(join(tablePath, (prefix ?? "") + field.key + ".inib"), linesNumber, field.type, field.children, this.salt);
                     if (items)
                         for (const [index, item] of Object.entries(items)) {
                             if (!RETURN[index])
@@ -510,8 +535,7 @@ export default class Inibase {
                     (await File.isExists(join(tablePath, (prefix ?? "") + field.key + ".inib")))) {
                     if (options.columns)
                         options.columns = options.columns
-                            .filter((column) => column.includes(`${field.key}.`) &&
-                            !column.includes(`${field.key}.`))
+                            .filter((column) => column.includes(`${field.key}.`))
                             .map((column) => column.replace(`${field.key}.`, ""));
                     const items = await File.get(join(tablePath, (prefix ?? "") + field.key + ".inib"), linesNumber, "number", undefined, this.salt);
                     if (items)
@@ -525,7 +549,7 @@ export default class Inibase {
                 }
             }
             else if (await File.isExists(join(tablePath, (prefix ?? "") + field.key + ".inib"))) {
-                const items = await File.get(join(tablePath, (prefix ?? "") + field.key + ".inib"), linesNumber, field.type, field?.children, this.salt);
+                const items = await File.get(join(tablePath, (prefix ?? "") + field.key + ".inib"), linesNumber, field.type, field.children, this.salt);
                 if (items)
                     for (const [index, item] of Object.entries(items)) {
                         if (!RETURN[index])
@@ -833,6 +857,8 @@ export default class Inibase {
                     ...rest,
                     createdAt: Date.now(),
                 }))(data);
+            this.validateData(RETURN, schema);
+            await this.checkUnique(tableName, schema);
             RETURN = this.formatData(RETURN, schema);
             const pathesContents = this.joinPathesContents(tablePath, Config.isReverseEnabled
                 ? Array.isArray(RETURN)
@@ -871,6 +897,8 @@ export default class Inibase {
     }, returnUpdatedData) {
         let renameList = [];
         const tablePath = join(this.folder, this.database, tableName), schema = await this.getSchemaWhenTableNotEmpty(tableName);
+        this.validateData(data, schema, true);
+        await this.checkUnique(tableName, schema);
         data = this.formatData(data, schema, true);
         if (!where) {
             if (Utils.isArrayOfObjects(data)) {

package/dist/utils.server.d.ts

@@ -52,6 +52,7 @@ export declare const findLastIdNumber: (schema: Schema, secretKeyOrSalt: string
  * @returns The updated schema with encoded IDs.
  */
 export declare const addIdToSchema: (schema: Schema, oldIndex: number | undefined, secretKeyOrSalt: string | number | Buffer, encodeIDs?: boolean) => import("./index.js").Field[];
+export declare const encodeSchemaID: (schema: Schema, secretKeyOrSalt: string | number | Buffer) => Schema;
 export declare const hashString: (str: string) => string;
 /**
  * Evaluates a comparison between two values based on a specified operator and field types.
@@ -104,4 +105,5 @@ export default class UtilsServer {
     static isEqual: (originalValue: string | number | boolean | (string | number | boolean | null)[] | null, comparedAtValue: string | number | boolean | (string | number | boolean | null)[] | null, fieldType?: FieldType | FieldType[] | undefined) => boolean;
     static isArrayEqual: (originalValue: string | number | boolean | (string | number | boolean | null)[] | null, comparedAtValue: string | number | boolean | (string | number | boolean | null)[] | null) => boolean;
     static isWildcardMatch: (originalValue: string | number | boolean | (string | number | boolean | null)[] | null, comparedAtValue: string | number | boolean | (string | number | boolean | null)[] | null) => boolean;
+    static encodeSchemaID: (schema: Schema, secretKeyOrSalt: string | number | Buffer) => Schema;
 }

package/dist/utils.server.js

@@ -64,6 +64,19 @@ 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
+const _flattenSchema = (schema, secretKeyOrSalt) => {
+    const result = [];
+    for (const field of schema) {
+        if (field.id)
+            result.push(typeof field.id === "number"
+                ? field.id
+                : decodeID(field.id, secretKeyOrSalt));
+        if (field.children && isArrayOfObjects(field.children))
+            result.push(..._flattenSchema(field.children, secretKeyOrSalt));
+    }
+    return result;
+};
 /**
  * Finds the last ID number in a schema, potentially decoding it if encrypted.
  *
@@ -71,19 +84,7 @@ export const decodeID = (input, 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) => {
-    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 findLastIdNumber = (schema, secretKeyOrSalt) => Math.max(..._flattenSchema(schema, secretKeyOrSalt));
 /**
  * Adds or updates IDs in a schema, encoding them using a provided secret key or salt.
  *
@@ -99,11 +100,15 @@ export const addIdToSchema = (schema, oldIndex = 0, secretKeyOrSalt, encodeIDs)
         field.id = encodeIDs ? encodeID(oldIndex, secretKeyOrSalt) : oldIndex;
     }
     else {
-        if (!isNumber(field.id))
+        if (isValidID(field.id)) {
             oldIndex = decodeID(field.id, secretKeyOrSalt);
+            if (!encodeIDs)
+                field.id = oldIndex;
+        }
         else {
             oldIndex = field.id;
-            field.id = encodeIDs ? encodeID(field.id, secretKeyOrSalt) : field.id;
+            if (encodeIDs)
+                field.id = encodeID(field.id, secretKeyOrSalt);
         }
     }
     if ((field.type === "array" || field.type === "object") &&
@@ -113,6 +118,17 @@ export const addIdToSchema = (schema, oldIndex = 0, secretKeyOrSalt, encodeIDs)
     }
     return field;
 });
+export const encodeSchemaID = (schema, secretKeyOrSalt) => schema.map((field) => ({
+    ...field,
+    id: isNumber(field.id) ? encodeID(field.id, secretKeyOrSalt) : field.id,
+    ...(field.children
+        ? isArrayOfObjects(field.children)
+            ? {
+                children: encodeSchemaID(field.children, secretKeyOrSalt),
+            }
+            : { children: field.children }
+        : {}),
+}));
 export const hashString = (str) => createHash("sha256").update(str).digest("hex");
 /**
  * Evaluates a comparison between two values based on a specified operator and field types.
@@ -251,4 +267,5 @@ export default class UtilsServer {
     static isEqual = isEqual;
     static isArrayEqual = isArrayEqual;
     static isWildcardMatch = isWildcardMatch;
+    static encodeSchemaID = encodeSchemaID;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.49",
+  "version": "1.0.0-rc.50",
   "author": {
     "name": "Karim Amahtil",
     "email": "karim.amahtil@gmail.com"