inibase 1.0.0-rc.46 → 1.0.0-rc.47

package/dist/index.d.ts

@@ -74,8 +74,7 @@ export default class Inibase {
     private _schemaToIdsPath;
     setTableSchema(tableName: string, schema: Schema): Promise<void>;
     getTableSchema(tableName: string): Promise<Schema | undefined>;
-    isTableEmpty(tableName: string): Promise<never | Schema>;
-    static getField(keyPath: string, schema: Schema): Field | null;
+    getSchemaWhenTableNotEmpty(tableName: string, schema?: Schema): Promise<never | Schema>;
     private validateData;
     private formatField;
     private formatData;
@@ -96,9 +95,9 @@ export default class Inibase {
     post(tableName: string, data: Data | Data[], options?: Options, returnPostedData?: boolean): Promise<void | null>;
     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>;
-    put(tableName: string, data: Data | Data[], where?: number | string | (number | string)[] | Criteria, options?: Options, returnPostedData?: false): Promise<void | null>;
-    put(tableName: string, data: Data, where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnPostedData: true): Promise<Data | null>;
-    put(tableName: string, data: Data[], where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnPostedData: true): Promise<Data[] | null>;
+    put(tableName: string, data: Data | Data[], where?: number | string | (number | string)[] | Criteria, options?: Options, returnUpdatedData?: false): Promise<void | null>;
+    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>;
     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>;
     sum(tableName: string, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;

package/dist/index.js

@@ -147,43 +147,31 @@ export default class Inibase {
             },
         ];
     }
-    async isTableEmpty(tableName) {
-        const schema = await this.getTableSchema(tableName), tablePath = join(this.folder, this.database, tableName);
+    async getSchemaWhenTableNotEmpty(tableName, schema) {
+        const tablePath = join(this.folder, this.database, tableName);
+        if (!schema)
+            schema = await this.getTableSchema(tableName);
         if (!schema)
             throw this.throwError("NO_SCHEMA", tableName);
         if (!(await File.isExists(join(tablePath, "id.inib"))))
             throw this.throwError("NO_ITEMS", tableName);
         return schema;
     }
-    static getField(keyPath, schema) {
-        let RETURN = null;
-        const keyPathSplited = keyPath.split(".");
-        for (const [index, key] of keyPathSplited.entries()) {
-            const foundItem = schema.find((item) => item.key === key);
-            if (!foundItem)
-                return null;
-            if (index === keyPathSplited.length - 1)
-                RETURN = foundItem;
-            if ((foundItem.type === "array" || foundItem.type === "object") &&
-                foundItem.children &&
-                Utils.isArrayOfObjects(foundItem.children))
-                RETURN = foundItem.children;
-        }
-        if (!RETURN)
-            return null;
-        return Utils.isArrayOfObjects(RETURN) ? RETURN[0] : RETURN;
-    }
     validateData(data, schema, skipRequiredField = false) {
         if (Utils.isArrayOfObjects(data))
             for (const single_data of data)
                 this.validateData(single_data, schema, skipRequiredField);
         else if (Utils.isObject(data)) {
             for (const field of schema) {
-                if (!data.hasOwnProperty(field.key) &&
-                    field.required &&
-                    !skipRequiredField)
-                    throw this.throwError("FIELD_REQUIRED", field.key);
-                if (data.hasOwnProperty(field.key) &&
+                if (!Object.hasOwn(data, field.key) ||
+                    data[field.key] === null ||
+                    data[field.key] === undefined) {
+                    if (field.required && !skipRequiredField)
+                        throw this.throwError("FIELD_REQUIRED", field.key);
+                    else
+                        return;
+                }
+                if (Object.hasOwn(data, field.key) &&
                     !Utils.validateFieldType(data[field.key], field.type, (field.type === "array" || field.type === "object") &&
                         field.children &&
                         !Utils.isArrayOfObjects(field.children)
@@ -203,14 +191,15 @@ export default class Inibase {
     }
     formatField(value, field, formatOnlyAvailiableKeys) {
         if (Array.isArray(field.type))
-            field.type = Utils.detectFieldType(value, field.type) ?? field.type[0];
+            field.type = (Utils.detectFieldType(value, field.type) ??
+                field.type[0]);
         switch (field.type) {
             case "array":
                 if (typeof field.children === "string") {
                     if (field.children === "table") {
                         if (Array.isArray(value)) {
                             if (Utils.isArrayOfObjects(value)) {
-                                if (value.every((item) => item.hasOwnProperty("id") &&
+                                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)
@@ -245,7 +234,7 @@ export default class Inibase {
                 if (Array.isArray(value))
                     value = value[0];
                 if (Utils.isObject(value)) {
-                    if (value.hasOwnProperty("id") &&
+                    if (Object.hasOwn(value, "id") &&
                         (Utils.isValidID(value.id) ||
                             Utils.isNumber(value.id)))
                         return Utils.isNumber(value.id)
@@ -287,7 +276,7 @@ export default class Inibase {
         else if (Utils.isObject(data)) {
             let RETURN = {};
             for (const field of schema) {
-                if (!data.hasOwnProperty(field.key)) {
+                if (!Object.hasOwn(data, field.key)) {
                     if (formatOnlyAvailiableKeys || !field.required)
                         continue;
                     RETURN[field.key] = this.getDefaultValue(field);
@@ -468,19 +457,22 @@ 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 (options.columns)
-                        options.columns = options.columns
-                            .filter((column) => column.includes(`${field.key}.`))
-                            .map((column) => column.replace(`${field.key}.`, ""));
-                    const items = await File.get(join(tablePath, (prefix ?? "") + field.key + ".inib"), linesNumber, field.type, field.children, this.salt);
-                    if (items)
-                        await Promise.all(Object.entries(items).map(async ([index, item]) => {
-                            if (!RETURN[index])
-                                RETURN[index] = {};
-                            RETURN[index][field.key] = item
-                                ? await this.get(field.key, item, options)
-                                : this.getDefaultValue(field);
-                        }));
+                    if ((await File.isExists(join(this.folder, this.database, field.key))) &&
+                        (await File.isExists(join(tablePath, (prefix ?? "") + field.key + ".inib")))) {
+                        if (options.columns)
+                            options.columns = options.columns
+                                .filter((column) => column.includes(`${field.key}.`))
+                                .map((column) => column.replace(`${field.key}.`, ""));
+                        const items = await File.get(join(tablePath, (prefix ?? "") + field.key + ".inib"), linesNumber, field.type, field.children, this.salt);
+                        if (items)
+                            await Promise.allSettled(Object.entries(items).map(async ([index, item]) => {
+                                if (!RETURN[index])
+                                    RETURN[index] = {};
+                                RETURN[index][field.key] = item
+                                    ? await this.get(field.key, 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);
@@ -516,13 +508,13 @@ export default class Inibase {
                             .map((column) => column.replace(`${field.key}.`, ""));
                     const items = await File.get(join(tablePath, (prefix ?? "") + field.key + ".inib"), linesNumber, "number", undefined, this.salt);
                     if (items)
-                        for await (const [index, item] of Object.entries(items)) {
+                        await Promise.allSettled(Object.entries(items).map(async ([index, item]) => {
                             if (!RETURN[index])
                                 RETURN[index] = {};
                             RETURN[index][field.key] = item
                                 ? await this.get(field.key, item, options)
                                 : this.getDefaultValue(field);
-                        }
+                        }));
                 }
             }
             else if (await File.isExists(join(tablePath, (prefix ?? "") + field.key + ".inib"))) {
@@ -570,7 +562,7 @@ export default class Inibase {
                 allTrue = true;
             let index = -1;
             for await (const [key, value] of Object.entries(criteria)) {
-                const field = Inibase.getField(key, schema);
+                const field = Utils.getField(key, schema);
                 index++;
                 let searchOperator = undefined, searchComparedAtValue = undefined, searchLogicalOperator = undefined;
                 if (Utils.isObject(value)) {
@@ -693,9 +685,13 @@ export default class Inibase {
         options.page = options.page || 1;
         options.perPage = options.perPage || 15;
         let RETURN;
-        let schema = tableSchema ?? (await this.isTableEmpty(tableName));
+        let schema = await this.getSchemaWhenTableNotEmpty(tableName, tableSchema);
         if (options.columns && options.columns.length)
             schema = this._filterSchemaByColumns(schema, options.columns);
+        if (where &&
+            ((Array.isArray(where) && !where.length) ||
+                (Utils.isObject(where) && !Object.keys(where).length)))
+            where = undefined;
         if (!where) {
             // Display all data
             RETURN = Object.values(await this.getItemsFromSchema(tableName, schema, Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
@@ -841,9 +837,10 @@ export default class Inibase {
                 : await File.append(path, content))));
             await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
             renameList = [];
+            totalItems += Array.isArray(RETURN) ? RETURN.length : 1;
             if (Config.isCacheEnabled) {
                 await this.clearCache(tablePath);
-                await File.write(join(tablePath, ".cache", "pagination.inib"), `${lastId},${totalItems + (Array.isArray(RETURN) ? RETURN.length : 1)}`, true);
+                await File.write(join(tablePath, ".cache", "pagination.inib"), `${lastId},${totalItems}`, true);
             }
             if (returnPostedData)
                 return this.get(tableName, Config.isReverseEnabled
@@ -864,19 +861,19 @@ export default class Inibase {
     async put(tableName, data, where, options = {
         page: 1,
         perPage: 15,
-    }, returnPostedData) {
+    }, returnUpdatedData) {
         let renameList = [];
-        const tablePath = join(this.folder, this.database, tableName), schema = await this.isTableEmpty(tableName);
+        const tablePath = join(this.folder, this.database, tableName), schema = await this.getSchemaWhenTableNotEmpty(tableName);
         data = this.formatData(data, schema, true);
         if (!where) {
             if (Utils.isArrayOfObjects(data)) {
-                if (!data.every((item) => item.hasOwnProperty("id") && Utils.isValidID(item.id)))
+                if (!data.every((item) => Object.hasOwn(item, "id") && Utils.isValidID(item.id)))
                     throw this.throwError("INVALID_ID");
                 return this.put(tableName, data, data
                     .filter(({ id }) => id !== undefined)
                     .map(({ id }) => id));
             }
-            else if (data.hasOwnProperty("id")) {
+            else if (Object.hasOwn(data, "id")) {
                 if (!Utils.isValidID(data.id))
                     throw this.throwError("INVALID_ID", data.id);
                 return this.put(tableName, data, data.id);
@@ -909,8 +906,8 @@ export default class Inibase {
                     await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
                     if (Config.isCacheEnabled)
                         await this.clearCache(join(tablePath, ".cache"));
-                    if (returnPostedData)
-                        return this.get(tableName, where, options, undefined, undefined, schema);
+                    if (returnUpdatedData)
+                        return await this.get(tableName, where, options, undefined, undefined, schema);
                 }
                 finally {
                     if (renameList.length)
@@ -951,7 +948,7 @@ export default class Inibase {
                 renameList = [];
                 if (Config.isCacheEnabled)
                     await this.clearCache(tablePath);
-                if (returnPostedData)
+                if (returnUpdatedData)
                     return this.get(tableName, where, options, !Array.isArray(where), undefined, schema);
             }
             finally {
@@ -962,14 +959,17 @@ export default class Inibase {
         }
         else if (Utils.isObject(where)) {
             const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
-            return this.put(tableName, data, lineNumbers);
+            if (returnUpdatedData)
+                return this.put(tableName, data, lineNumbers, options, returnUpdatedData);
+            else
+                await this.put(tableName, data, lineNumbers, options, returnUpdatedData);
         }
         else
             throw this.throwError("INVALID_PARAMETERS");
     }
     async delete(tableName, where, _id) {
         let renameList = [];
-        const tablePath = join(this.folder, this.database, tableName), schema = await this.isTableEmpty(tableName);
+        const tablePath = join(this.folder, this.database, tableName), schema = await this.getSchemaWhenTableNotEmpty(tableName);
         if (!where) {
             try {
                 await File.lock(join(tablePath, ".tmp"));
@@ -1035,7 +1035,7 @@ export default class Inibase {
     }
     async sum(tableName, columns, where) {
         let RETURN = {};
-        const tablePath = join(this.folder, this.database, tableName), schema = await this.isTableEmpty(tableName);
+        const tablePath = join(this.folder, this.database, tableName), schema = await this.getSchemaWhenTableNotEmpty(tableName);
         if (!Array.isArray(columns))
             columns = [columns];
         for await (const column of columns) {
@@ -1055,7 +1055,7 @@ export default class Inibase {
     }
     async max(tableName, columns, where) {
         let RETURN = {};
-        const tablePath = join(this.folder, this.database, tableName), schema = await this.isTableEmpty(tableName);
+        const tablePath = join(this.folder, this.database, tableName), schema = await this.getSchemaWhenTableNotEmpty(tableName);
         if (!Array.isArray(columns))
             columns = [columns];
         for await (const column of columns) {
@@ -1075,7 +1075,7 @@ export default class Inibase {
     }
     async min(tableName, columns, where) {
         let RETURN = {};
-        const tablePath = join(this.folder, this.database, tableName), schema = await this.isTableEmpty(tableName);
+        const tablePath = join(this.folder, this.database, tableName), schema = await this.getSchemaWhenTableNotEmpty(tableName);
         if (!Array.isArray(columns))
             columns = [columns];
         for await (const column of columns) {
@@ -1098,7 +1098,7 @@ export default class Inibase {
         perPage: 15,
     }) {
         // TO-DO: Cache Results based on "Columns and Sort Direction"
-        const tablePath = join(this.folder, this.database, tableName), schema = await this.isTableEmpty(tableName);
+        const tablePath = join(this.folder, this.database, tableName), schema = await this.getSchemaWhenTableNotEmpty(tableName);
         // Default values for page and perPage
         options.page = options.page || 1;
         options.perPage = options.perPage || 15;
@@ -1138,7 +1138,7 @@ export default class Inibase {
         let index = 2;
         const sortColumns = sortArray
             .map(([key, ascending], i) => {
-            const field = Inibase.getField(key, schema);
+            const field = Utils.getField(key, schema);
             if (field)
                 return `-k${i + index},${i + index}${field.type === "number" ? "n" : ""}${!ascending ? "r" : ""}`;
             else
@@ -1171,7 +1171,7 @@ export default class Inibase {
                 const outputObject = {};
                 // Extract values for each file, including "id.inib"
                 filesPathes.forEach((fileName, index) => {
-                    const Field = Inibase.getField(parse(fileName).name, schema);
+                    const Field = Utils.getField(parse(fileName).name, schema);
                     if (Field)
                         outputObject[Field.key] = File.decode(splitedFileColumns[index], Field?.type, Field?.children, this.salt);
                 });

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import type { FieldType, ComparisonOperator } from "./index.js";
+import type { FieldType, ComparisonOperator, Field, Schema } from "./index.js";
 /**
  * Type guard function to check if the input is an array of objects.
  *
@@ -180,6 +180,7 @@ export declare function FormatObjectCriteriaValue(value: string, isParentArray?:
 ];
 type ValidKey = number | string;
 export declare const swapKeyValue: <K extends ValidKey, V extends ValidKey>(object: Record<K, V>) => Record<V, K>;
+export declare function getField(keyPath: string, schema: Schema): Field | null;
 export default class Utils {
     static isNumber: (input: any) => input is number;
     static isObject: (obj: any) => obj is Record<any, any>;
@@ -202,5 +203,6 @@ export default class Utils {
     static isArrayOfNulls: (input: any) => input is null[] | null[][];
     static FormatObjectCriteriaValue: typeof FormatObjectCriteriaValue;
     static swapKeyValue: <K extends ValidKey, V extends ValidKey>(object: Record<K, V>) => Record<V, K>;
+    static getField: typeof getField;
 }
 export {};

package/dist/utils.js

@@ -216,7 +216,7 @@ export const isValidID = (input) => {
  * @param {string} str - The string to be checked.
  * @returns {boolean} Returns true if the string is valid JSON, otherwise false.
  */
-export const isJSON = (str) => str[0] === "{" || str[0] === "[";
+export const isJSON = (str) => str === "null" || str === "undefined" || str[0] === "{" || str[0] === "[";
 /**
  * Identifies and returns properties that have changed between two objects.
  *
@@ -239,42 +239,43 @@ export const findChangedProperties = (obj1, obj2) => {
  * @returns The detected field type as a string, or undefined if no matching type is found.
  */
 export const detectFieldType = (input, availableTypes) => {
-    if (!Array.isArray(input)) {
-        if ((input === "0" ||
-            input === "1" ||
-            input === "true" ||
-            input === "false") &&
-            availableTypes.includes("boolean"))
-            return "boolean";
-        else if (isNumber(input)) {
-            if (availableTypes.includes("table"))
+    if (input !== null && input !== undefined)
+        if (!Array.isArray(input)) {
+            if ((input === "0" ||
+                input === "1" ||
+                input === "true" ||
+                input === "false") &&
+                availableTypes.includes("boolean"))
+                return "boolean";
+            else if (isNumber(input)) {
+                if (availableTypes.includes("table"))
+                    return "table";
+                else if (availableTypes.includes("date"))
+                    return "date";
+                else if (availableTypes.includes("number"))
+                    return "number";
+            }
+            else if (availableTypes.includes("table") && isValidID(input))
                 return "table";
-            else if (availableTypes.includes("date"))
-                return "date";
-            else if (availableTypes.includes("number"))
-                return "number";
+            else if (input.startsWith("[") && availableTypes.includes("array"))
+                return "array";
+            else if (availableTypes.includes("email") && isEmail(input))
+                return "email";
+            else if (availableTypes.includes("url") && isURL(input))
+                return "url";
+            else if (availableTypes.includes("password") && isPassword(input))
+                return "password";
+            else if (availableTypes.includes("json") && isJSON(input))
+                return "json";
+            else if (availableTypes.includes("json") && isDate(input))
+                return "json";
+            else if (availableTypes.includes("string") && isString(input))
+                return "string";
+            else if (availableTypes.includes("ip") && isIP(input))
+                return "ip";
         }
-        else if (availableTypes.includes("table") && isValidID(input))
-            return "table";
-        else if (input.includes(",") && availableTypes.includes("array"))
+        else
             return "array";
-        else if (availableTypes.includes("email") && isEmail(input))
-            return "email";
-        else if (availableTypes.includes("url") && isURL(input))
-            return "url";
-        else if (availableTypes.includes("password") && isPassword(input))
-            return "password";
-        else if (availableTypes.includes("json") && isJSON(input))
-            return "json";
-        else if (availableTypes.includes("json") && isDate(input))
-            return "json";
-        else if (availableTypes.includes("string") && isString(input))
-            return "string";
-        else if (availableTypes.includes("ip") && isIP(input))
-            return "ip";
-    }
-    else
-        return "array";
     return undefined;
 };
 /**
@@ -393,6 +394,24 @@ export function FormatObjectCriteriaValue(value, isParentArray = false) {
     }
 }
 export const swapKeyValue = (object) => Object.entries(object).reduce((swapped, [key, value]) => ({ ...swapped, [value]: key }), {});
+export function getField(keyPath, schema) {
+    let RETURN = null;
+    const keyPathSplited = keyPath.split(".");
+    for (const [index, key] of keyPathSplited.entries()) {
+        const foundItem = schema.find((item) => item.key === key);
+        if (!foundItem)
+            return null;
+        if (index === keyPathSplited.length - 1)
+            RETURN = foundItem;
+        if ((foundItem.type === "array" || foundItem.type === "object") &&
+            foundItem.children &&
+            isArrayOfObjects(foundItem.children))
+            RETURN = foundItem.children;
+    }
+    if (!RETURN)
+        return null;
+    return isArrayOfObjects(RETURN) ? RETURN[0] : RETURN;
+}
 export default class Utils {
     static isNumber = isNumber;
     static isObject = isObject;
@@ -415,4 +434,5 @@ export default class Utils {
     static isArrayOfNulls = isArrayOfNulls;
     static FormatObjectCriteriaValue = FormatObjectCriteriaValue;
     static swapKeyValue = swapKeyValue;
+    static getField = getField;
 }

package/package.json

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