inibase 1.0.0-rc.125 → 1.0.0-rc.127

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);
@@ -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?.size && (!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;
@@ -132,36 +132,37 @@ export default class Inibase {
      * @param {boolean} [onlyLinesNumbers]
      * @return {*}  {(Promise<Data | number | (Data | number)[] | null>)}
      */
-    get(tableName: string, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: true, onlyLinesNumbers?: false): Promise<Data | null>;
-    get(tableName: string, where: string | number, options?: Options, onlyOne?: boolean, onlyLinesNumbers?: false): Promise<Data | null>;
-    get(tableName: string, where?: string | number | (string | number)[] | Criteria, options?: Options, onlyOne?: boolean, onlyLinesNumbers?: false): Promise<Data[] | null>;
-    get(tableName: string, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: false | undefined, onlyLinesNumbers: true): Promise<number[] | null>;
-    get(tableName: string, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: true, onlyLinesNumbers: true): Promise<number | null>;
+    get<TData extends Record<string, any> & Partial<Data>>(tableName: string, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: true, onlyLinesNumbers?: false): Promise<(Data & TData) | null>;
+    get<TData extends Record<string, any> & Partial<Data>>(tableName: string, where: string | number, options?: Options, onlyOne?: boolean, onlyLinesNumbers?: false): Promise<(Data & TData) | null>;
+    get<TData extends Record<string, any> & Partial<Data>>(tableName: string, where?: string | number | (string | number)[] | Criteria, options?: Options, onlyOne?: boolean, onlyLinesNumbers?: false): Promise<(Data & TData)[] | null>;
+    get<TData extends Record<string, any> & Partial<Data>>(tableName: string, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: false | undefined, onlyLinesNumbers: true): Promise<number[] | null>;
+    get<TData extends Record<string, any> & Partial<Data>>(tableName: string, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: true, onlyLinesNumbers: true): Promise<number | null>;
     /**
      * Create new item(s) in a table
      *
      * @param {string} tableName
-     * @param {(Data | Data[])} data Can be array of objects or a single object
+     * @param {((Data & TData) | (Data & TData)[])} data Can be array of objects or a single object
      * @param {Options} [options] Pagination options, useful when the returnPostedData param is true
      * @param {boolean} [returnPostedData] By default function returns void, if you want to get the posted data, set this param to true
      * @return {*}  {Promise<Data | Data[] | null | void>}
      */
-    post(tableName: string, data: Data | Data[], options?: Options, returnPostedData?: boolean): Promise<void>;
-    post(tableName: string, data: Data, options: Options | undefined, returnPostedData: true): Promise<Data | null>;
-    post(tableName: string, data: Data[], options: Options | undefined, returnPostedData: true): Promise<Data[] | null>;
+    post<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: (Data & TData) | (Data & TData)[], options?: Options, returnPostedData?: boolean): Promise<void>;
+    post<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: Data & TData, options: Options | undefined, returnPostedData: true): Promise<(Data & TData) | null>;
+    post<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: (Data & TData)[], options: Options | undefined, returnPostedData: true): Promise<(Data & TData)[] | null>;
     /**
      * Update item(s) in a table
      *
      * @param {string} tableName
-     * @param {(Data | Data[])} data
+     * @param {(Data & TData) | (Data & TData[])} data
      * @param {(number | string | (number | string)[] | Criteria)} [where]
      * @param {Options} [options]
-     * @param {false} [returnUpdatedData]
+     * @param {boolean} [returnUpdatedData]
      * @return {*}  {Promise<Data | Data[] | null | undefined | void>}
      */
-    put(tableName: string, data: Data | Data[], where?: number | string | (number | string)[] | Criteria, options?: Options, returnUpdatedData?: false): Promise<void>;
-    put(tableName: string, data: Data, where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: true): Promise<Data | null>;
-    put(tableName: string, data: Data[], where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: true): Promise<Data[] | null>;
+    put<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: (Data & TData) | (Data & TData)[], where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: false): Promise<void>;
+    put<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: Data & TData, where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: true | boolean): Promise<(Data & TData) | null>;
+    put<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: (Data & TData)[], where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: true | boolean): Promise<(Data & TData)[] | null>;
+    put<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: (Data & TData) | (Data & TData)[], where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: true | boolean): Promise<(Data & TData) | (Data & TData)[] | null>;
     /**
      * Delete item(s) in a table
      *

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))
@@ -381,7 +390,7 @@ export default class Inibase {
                 if (!Array.isArray(value))
                     value = [value];
                 if (Utils.isArrayOfObjects(fieldChildrenType))
-                    return this.formatData(value, fieldChildrenType);
+                    return this.formatData(value, fieldChildrenType, _formatOnlyAvailiableKeys);
                 if (!value.length)
                     return null;
                 return value.map((_value) => this.formatField(_value, fieldChildrenType));
@@ -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)}`), "[]", Array.from(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.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
-                    return;
             }
+            if (shouldContinueParent)
+                continue;
         }
         this.uniqueMap = new Map();
     }
@@ -1118,9 +1143,8 @@ export default class Inibase {
                     .slice((options.page - 1) * options.perPage, options.page * options.perPage)
                     .map(Number), options, onlyOne);
             }
-            let linesNumbers = null;
-            [RETURN, linesNumbers] = await this.applyCriteria(tableName, schema, options, where);
-            if (RETURN && linesNumbers?.size) {
+            const [LineNumberDataMap, linesNumbers] = await this.applyCriteria(tableName, schema, options, where);
+            if (LineNumberDataMap && linesNumbers?.size) {
                 if (!this.totalItems.has(`${tableName}-*`))
                     this.totalItems.set(`${tableName}-*`, linesNumbers.size);
                 if (onlyLinesNumbers)
@@ -1130,8 +1154,8 @@ export default class Inibase {
                 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.processSchemaData(tableName, Utils.filterSchema(schema, ({ id, type, children }) => !alreadyExistsColumnsIDs.includes(id) ||
-                    Utils.isFieldType("table", type, children)), Object.keys(RETURN).map(Number), options)));
+                RETURN = Object.values(Utils.deepMerge(LineNumberDataMap, await this.processSchemaData(tableName, Utils.filterSchema(schema, ({ id, type, children }) => !alreadyExistsColumnsIDs.includes(id) ||
+                    Utils.isFieldType("table", type, children)), Object.keys(LineNumberDataMap).map(Number), options)));
                 if (this.tablesMap.get(tableName).config.cache)
                     await writeFile(cachedFilePath, Array.from(linesNumbers).join(","));
             }
@@ -1165,8 +1189,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 +1202,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, false);
             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 +1233,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 +1255,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);
             }
-            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 (Object.hasOwn(clonedData, "id")) {
+                if (!Utils.isValidID(clonedData.id))
+                    throw this.createError("INVALID_ID", clonedData.id);
+                return this.put(tableName, clonedData, clonedData.id, options, returnUpdatedData);
             }
-            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 +1297,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, false);
         }
         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 +1338,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);
         }
         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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.125",
+  "version": "1.0.0-rc.127",
   "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"
   }
 }