inibase 1.0.0-rc.6 → 1.0.0-rc.8

package/index.ts

@@ -8,9 +8,10 @@ import {
   readdir,
 } from "node:fs/promises";
 import { join, parse } from "node:path";
-import Utils from "./utils";
-import File from "./file";
 import { scryptSync } from "node:crypto";
+import File from "./file";
+import Utils from "./utils";
+import UtilsServer from "./utils.server";
 
 export type Data = {
   id?: number | string;
@@ -88,7 +89,7 @@ export type ComparisonOperator =
   | "![]";
 
 type pageInfo = {
-  total_items?: number;
+  total?: number;
   total_pages?: number;
 } & Options;
 
@@ -112,20 +113,22 @@ declare global {
 }
 
 export default class Inibase {
+  public folder: string;
   public database: string;
-  public databasePath: string;
-  public cache: Map<string, string>;
-  public pageInfoArray: Record<string, Record<string, number>>;
+  public table: string;
   public pageInfo: pageInfo;
+  private cache: Map<string, string>;
+  private totalItems: Record<string, number>;
   private salt: Buffer;
 
-  constructor(databaseName: string, mainFolder: string = ".") {
-    this.database = databaseName;
-    this.databasePath = join(mainFolder, databaseName);
+  constructor(database: string, mainFolder: string = ".") {
+    this.database = database;
+    this.folder = mainFolder;
+    this.table = null;
     this.cache = new Map<string, any>();
-    this.pageInfoArray = {};
+    this.totalItems = {};
     this.pageInfo = { page: 1, per_page: 15 };
-    this.salt = scryptSync(this.databasePath, "salt", 32);
+    this.salt = scryptSync(database, "salt", 32);
   }
 
   private throwError(
@@ -183,7 +186,7 @@ export default class Inibase {
       )
         return this.findLastIdNumber(lastField.children as Schema);
       else if (lastField.id && Utils.isValidID(lastField.id))
-        return Utils.decodeID(lastField.id as string, this.salt);
+        return UtilsServer.decodeID(lastField.id as string, this.salt);
     }
     return 0;
   }
@@ -198,7 +201,9 @@ export default class Inibase {
         for (const field of schema) {
           if (!RETURN[index]) RETURN[index] = [];
           RETURN[index].push(
-            field.id ? Utils.decodeID(field.id as string, this.salt) : null
+            field.id
+              ? UtilsServer.decodeID(field.id as string, this.salt)
+              : null
           );
           RETURN[index].push(field.key ?? null);
           RETURN[index].push(field.required ?? null);
@@ -224,18 +229,19 @@ export default class Inibase {
               oldIndex++;
               field = {
                 ...field,
-                id: Utils.encodeID(oldIndex, this.salt),
+                id: UtilsServer.encodeID(oldIndex, this.salt),
               };
-            } else oldIndex = Utils.decodeID(field.id as string, this.salt);
+            } else
+              oldIndex = UtilsServer.decodeID(field.id as string, this.salt);
             field.children = addIdToSchema(field.children as Schema, oldIndex);
             oldIndex += field.children.length;
           } else if (field.id)
-            oldIndex = Utils.decodeID(field.id as string, this.salt);
+            oldIndex = UtilsServer.decodeID(field.id as string, this.salt);
           else {
             oldIndex++;
             field = {
               ...field,
-              id: Utils.encodeID(oldIndex, this.salt),
+              id: UtilsServer.encodeID(oldIndex, this.salt),
             };
           }
           return field;
@@ -246,8 +252,8 @@ export default class Inibase {
       (field) => !["id", "created_at", "updated_at"].includes(field.key)
     );
     schema = addIdToSchema(schema, this.findLastIdNumber(schema));
-    const TablePath = join(this.databasePath, tableName),
-      TableSchemaPath = join(TablePath, "schema.inib");
+    const TablePath = join(this.folder, this.database, tableName),
+      TableSchemaPath = join(TablePath, "schema");
     if (!(await File.isExists(TablePath)))
       await mkdir(TablePath, { recursive: true });
     if (await File.isExists(TableSchemaPath)) {
@@ -266,10 +272,8 @@ export default class Inibase {
                 )
               );
             } else if (Utils.isValidID(field.id))
-              RETURN[Utils.decodeID(field.id, this.salt)] = File.encodeFileName(
-                (prefix ?? "") + field.key,
-                "inib"
-              );
+              RETURN[UtilsServer.decodeID(field.id, this.salt)] =
+                File.encodeFileName((prefix ?? "") + field.key, "inib");
 
           return RETURN;
         },
@@ -284,7 +288,7 @@ export default class Inibase {
     }
 
     await writeFile(
-      join(TablePath, "schema.inib"),
+      join(TablePath, "schema"),
       JSON.stringify(encodeSchema(schema))
     );
   }
@@ -296,7 +300,7 @@ export default class Inibase {
             ? decodeSchema(field)
             : Object.fromEntries(
                 Object.entries({
-                  id: Utils.encodeID(field[0], this.salt),
+                  id: UtilsServer.encodeID(field[0], this.salt),
                   key: field[1],
                   required: field[2],
                   type: field[3],
@@ -309,7 +313,7 @@ export default class Inibase {
               )
         );
       },
-      TableSchemaPath = join(this.databasePath, tableName, "schema.inib");
+      TableSchemaPath = join(this.folder, this.database, tableName, "schema");
     if (!(await File.isExists(TableSchemaPath))) return undefined;
     if (!this.cache.has(TableSchemaPath)) {
       const TableSchemaPathContent = await readFile(TableSchemaPath, {
@@ -326,20 +330,20 @@ export default class Inibase {
       lastIdNumber = this.findLastIdNumber(schema);
     return [
       {
-        id: Utils.encodeID(0, this.salt),
+        id: UtilsServer.encodeID(0, this.salt),
         key: "id",
-        type: "number",
+        type: "id",
         required: true,
       },
       ...schema,
       {
-        id: Utils.encodeID(lastIdNumber, this.salt),
+        id: UtilsServer.encodeID(lastIdNumber + 1, this.salt),
         key: "created_at",
         type: "date",
         required: true,
       },
       {
-        id: Utils.encodeID(lastIdNumber + 1, this.salt),
+        id: UtilsServer.encodeID(lastIdNumber + 2, this.salt),
         key: "updated_at",
         type: "date",
         required: false,
@@ -388,79 +392,6 @@ export default class Inibase {
     schema: Schema,
     skipRequiredField: boolean = false
   ): void {
-    const validateFieldType = (
-      value: any,
-      fieldType: FieldType | FieldType[],
-      fieldChildrenType?: FieldType | FieldType[]
-    ): boolean => {
-      if (value === null) return true;
-      if (Array.isArray(fieldType))
-        return Utils.detectFieldType(value, fieldType) !== undefined;
-      if (fieldType === "array" && fieldChildrenType && Array.isArray(value))
-        return value.some(
-          (v) =>
-            Utils.detectFieldType(
-              v,
-              Array.isArray(fieldChildrenType)
-                ? fieldChildrenType
-                : [fieldChildrenType]
-            ) !== undefined
-        );
-
-      switch (fieldType) {
-        case "string":
-          return Utils.isString(value);
-        case "password":
-          return (
-            Utils.isNumber(value) ||
-            Utils.isString(value) ||
-            Utils.isPassword(value)
-          );
-        case "number":
-          return Utils.isNumber(value);
-        case "html":
-          return Utils.isHTML(value);
-        case "ip":
-          return Utils.isIP(value);
-        case "boolean":
-          return Utils.isBoolean(value);
-        case "date":
-          return Utils.isDate(value);
-        case "object":
-          return Utils.isObject(value);
-        case "array":
-          return Array.isArray(value);
-        case "email":
-          return Utils.isEmail(value);
-        case "url":
-          return Utils.isURL(value);
-        case "table":
-          // feat: check if id exists
-          if (Array.isArray(value))
-            return (
-              (Utils.isArrayOfObjects(value) &&
-                value.every(
-                  (element: Data) =>
-                    element.hasOwnProperty("id") &&
-                    (Utils.isValidID(element.id) || Utils.isNumber(element.id))
-                )) ||
-              value.every(Utils.isNumber) ||
-              Utils.isValidID(value)
-            );
-          else if (Utils.isObject(value))
-            return (
-              value.hasOwnProperty("id") &&
-              (Utils.isValidID((value as Data).id) ||
-                Utils.isNumber((value as Data).id))
-            );
-          else return Utils.isNumber(value) || Utils.isValidID(value);
-        case "id":
-          return Utils.isNumber(value) || Utils.isValidID(value);
-        default:
-          return false;
-      }
-    };
-
     if (Utils.isArrayOfObjects(data))
       for (const single_data of data as Data[])
         this.validateData(single_data, schema, skipRequiredField);
@@ -474,7 +405,7 @@ export default class Inibase {
           throw this.throwError("FIELD_REQUIRED", field.key);
         if (
           data.hasOwnProperty(field.key) &&
-          !validateFieldType(
+          !Utils.validateFieldType(
             data[field.key],
             field.type,
             (field as any)?.children &&
@@ -525,16 +456,16 @@ export default class Inibase {
                     value.map((item: any) =>
                       Utils.isNumber(item.id)
                         ? Number(item.id)
-                        : Utils.decodeID(item.id, this.salt)
+                        : UtilsServer.decodeID(item.id, this.salt)
                     );
                 } else if (Utils.isValidID(value) || Utils.isNumber(value))
                   return value.map((item: number | string) =>
                     Utils.isNumber(item)
                       ? Number(item as string)
-                      : Utils.decodeID(item as string, this.salt)
+                      : UtilsServer.decodeID(item as string, this.salt)
                   );
               } else if (Utils.isValidID(value))
-                return [Utils.decodeID(value, this.salt)];
+                return [UtilsServer.decodeID(value, this.salt)];
               else if (Utils.isNumber(value)) return [Number(value)];
             } else if (data.hasOwnProperty(field.key)) return value;
           } else if (Utils.isArrayOfObjects(field.children))
@@ -562,20 +493,20 @@ export default class Inibase {
             )
               return Utils.isNumber(value.id)
                 ? Number(value.id)
-                : Utils.decodeID(value.id, this.salt);
+                : UtilsServer.decodeID(value.id, this.salt);
           } else if (Utils.isValidID(value) || Utils.isNumber(value))
             return Utils.isNumber(value)
               ? Number(value)
-              : Utils.decodeID(value, this.salt);
+              : UtilsServer.decodeID(value, this.salt);
           break;
         case "password":
-          return value.length === 161 ? value : Utils.hashPassword(value);
+          return value.length === 161 ? value : UtilsServer.hashPassword(value);
         case "number":
           return Utils.isNumber(value) ? Number(value) : null;
         case "id":
           return Utils.isNumber(value)
-            ? Utils.encodeID(value, this.salt)
-            : value;
+            ? value
+            : UtilsServer.decodeID(value, this.salt);
         default:
           return value;
       }
@@ -726,7 +657,7 @@ export default class Inibase {
     let RETURN!: Data | Data[] | null;
     let schema = await this.getTableSchema(tableName);
     if (!schema) throw this.throwError("NO_SCHEMA", tableName);
-    const idFilePath = join(this.databasePath, tableName, "id.inib");
+    const idFilePath = join(this.folder, this.database, tableName, "id.inib");
     if (!(await File.isExists(idFilePath))) return null;
     const filterSchemaByColumns = (schema: Schema, columns: string[]): Schema =>
       schema
@@ -914,21 +845,23 @@ export default class Inibase {
               options.columns = (options.columns as string[])
                 .filter((column) => column.includes(`${field.key}.*.`))
                 .map((column) => column.replace(`${field.key}.*.`, ""));
-            for await (const [index, value] of Object.entries(
-              (await File.get(
-                join(
-                  path,
-                  File.encodeFileName((prefix ?? "") + field.key, "inib")
-                ),
-                linesNumber,
-                field.type,
-                (field as FieldDefault & (FieldArrayType | FieldArrayArrayType))
-                  .children as FieldType | FieldType[]
-              )) ?? {}
-            )) {
+            const [items, total_lines] = await File.get(
+              join(
+                path,
+                File.encodeFileName((prefix ?? "") + field.key, "inib")
+              ),
+              linesNumber,
+              field.type,
+              (field as FieldDefault & (FieldArrayType | FieldArrayArrayType))
+                .children as FieldType | FieldType[],
+              this.salt
+            );
+
+            this.totalItems[tableName + "-" + field.key] = total_lines;
+            for (const [index, item] of Object.entries(items)) {
               if (!RETURN[index]) RETURN[index] = {};
-              RETURN[index][field.key] = value
-                ? await this.get(field.key, value as number, options)
+              RETURN[index][field.key] = item
+                ? await this.get(field.key, item as number, options)
                 : this.getDefaultValue(field);
             }
           } else if (
@@ -938,40 +871,45 @@ export default class Inibase {
                 File.encodeFileName((prefix ?? "") + field.key, "inib")
               )
             )
-          )
-            Object.entries(
-              (await File.get(
-                join(
-                  path,
-                  File.encodeFileName((prefix ?? "") + field.key, "inib")
-                ),
-                linesNumber,
-                field.type,
-                (field as any)?.children
-              )) ?? {}
-            ).forEach(([index, item]) => {
+          ) {
+            const [items, total_lines] = await File.get(
+              join(
+                path,
+                File.encodeFileName((prefix ?? "") + field.key, "inib")
+              ),
+              linesNumber,
+              field.type,
+              (field as any)?.children,
+              this.salt
+            );
+
+            this.totalItems[tableName + "-" + field.key] = total_lines;
+            for (const [index, item] of Object.entries(items)) {
               if (!RETURN[index]) RETURN[index] = {};
               RETURN[index][field.key] = item ?? this.getDefaultValue(field);
-            });
+            }
+          }
         } else if (field.type === "object") {
-          Object.entries(
+          for (const [index, item] of Object.entries(
             (await getItemsFromSchema(
               path,
               field.children as Schema,
               linesNumber,
               (prefix ?? "") + field.key + "."
             )) ?? {}
-          ).forEach(([index, item]) => {
+          )) {
             if (!RETURN[index]) RETURN[index] = {};
             if (Utils.isObject(item)) {
               if (!Object.values(item).every((i) => i === null))
                 RETURN[index][field.key] = item;
               else RETURN[index][field.key] = null;
             } else RETURN[index][field.key] = null;
-          });
+          }
         } else if (field.type === "table") {
           if (
-            (await File.isExists(join(this.databasePath, field.key))) &&
+            (await File.isExists(
+              join(this.folder, this.database, field.key)
+            )) &&
             (await File.isExists(
               join(
                 path,
@@ -987,19 +925,21 @@ export default class Inibase {
                     !column.includes(`${field.key}.*.`)
                 )
                 .map((column) => column.replace(`${field.key}.`, ""));
-            for await (const [index, value] of Object.entries(
-              (await File.get(
-                join(
-                  path,
-                  File.encodeFileName((prefix ?? "") + field.key, "inib")
-                ),
-                linesNumber,
-                "number"
-              )) ?? {}
-            )) {
+            const [items, total_lines] = await File.get(
+              join(
+                path,
+                File.encodeFileName((prefix ?? "") + field.key, "inib")
+              ),
+              linesNumber,
+              "number",
+              undefined,
+              this.salt
+            );
+            this.totalItems[tableName + "-" + field.key] = total_lines;
+            for (const [index, item] of Object.entries(items)) {
               if (!RETURN[index]) RETURN[index] = {};
-              RETURN[index][field.key] = value
-                ? await this.get(field.key, value as number, options)
+              RETURN[index][field.key] = item
+                ? await this.get(field.key, item as number, options)
                 : this.getDefaultValue(field);
             }
           }
@@ -1007,21 +947,21 @@ export default class Inibase {
           await File.isExists(
             join(path, File.encodeFileName((prefix ?? "") + field.key, "inib"))
           )
-        )
-          Object.entries(
-            (await File.get(
-              join(
-                path,
-                File.encodeFileName((prefix ?? "") + field.key, "inib")
-              ),
-              linesNumber,
-              field.type,
-              (field as any)?.children
-            )) ?? {}
-          ).forEach(([index, item]) => {
+        ) {
+          const [items, total_lines] = await File.get(
+            join(path, File.encodeFileName((prefix ?? "") + field.key, "inib")),
+            linesNumber,
+            field.type,
+            (field as any)?.children,
+            this.salt
+          );
+
+          this.totalItems[tableName + "-" + field.key] = total_lines;
+          for (const [index, item] of Object.entries(items)) {
             if (!RETURN[index]) RETURN[index] = {};
             RETURN[index][field.key] = item ?? this.getDefaultValue(field);
-          });
+          }
+        }
       }
       return RETURN;
     };
@@ -1029,7 +969,7 @@ export default class Inibase {
       // Display all data
       RETURN = Object.values(
         await getItemsFromSchema(
-          join(this.databasePath, tableName),
+          join(this.folder, this.database, tableName),
           schema,
           Array.from(
             { length: options.per_page },
@@ -1048,14 +988,14 @@ export default class Inibase {
         "[]",
         Utils.isNumber(Ids)
           ? Ids.map((id) => Number(id as string))
-          : Ids.map((id) => Utils.decodeID(id as string, this.salt)),
+          : Ids.map((id) => UtilsServer.decodeID(id as string, this.salt)),
         undefined,
         "number",
         undefined,
         Ids.length,
         0,
         false,
-        this.databasePath
+        this.salt
       );
       if (!lineNumbers || !Object.keys(lineNumbers).length)
         throw this.throwError(
@@ -1064,7 +1004,7 @@ export default class Inibase {
         );
       RETURN = Object.values(
         (await getItemsFromSchema(
-          join(this.databasePath, tableName),
+          join(this.folder, this.database, tableName),
           schema,
           Object.keys(lineNumbers).map(Number)
         )) ?? {}
@@ -1257,9 +1197,10 @@ export default class Inibase {
               searchOperator = "=";
               searchComparedAtValue = value as number | boolean;
             }
-            const [searchResult, totlaItems] = await File.search(
+            const [searchResult, total_lines] = await File.search(
               join(
-                this.databasePath,
+                this.folder,
+                this.database,
                 tableName,
                 File.encodeFileName(key, "inib")
               ),
@@ -1271,12 +1212,11 @@ export default class Inibase {
               options.per_page,
               (options.page as number) - 1 * (options.per_page as number) + 1,
               true,
-              this.databasePath
+              this.salt
             );
             if (searchResult) {
               RETURN = Utils.deepMerge(RETURN, searchResult);
-              if (!this.pageInfoArray[key]) this.pageInfoArray[key] = {};
-              this.pageInfoArray[key].total_items = totlaItems;
+              this.totalItems[tableName + "-" + key] = total_lines;
             }
             if (allTrue && index > 0) {
               if (!Object.keys(RETURN).length) RETURN = {};
@@ -1295,30 +1235,12 @@ export default class Inibase {
       if (RETURN) {
         if (onlyLinesNumbers) return Object.keys(RETURN).map(Number);
         const alreadyExistsColumns = Object.keys(Object.values(RETURN)[0]).map(
-            (key) => File.decodeFileName(parse(key).name)
-          ),
-          greatestColumnTotalItems = alreadyExistsColumns.reduce(
-            (maxItem: string, currentItem: string) =>
-              this.pageInfoArray[currentItem]?.total_items ||
-              (0 > (this.pageInfoArray[maxItem]?.total_items || 0) &&
-                this.pageInfoArray[currentItem].total_items)
-                ? currentItem
-                : maxItem,
-            ""
-          );
-        if (greatestColumnTotalItems)
-          this.pageInfo = {
-            ...(({ columns, ...restOfOptions }) => restOfOptions)(options),
-            ...this.pageInfoArray[greatestColumnTotalItems],
-            total_pages: Math.ceil(
-              this.pageInfoArray[greatestColumnTotalItems].total_items /
-                options.per_page
-            ),
-          };
+          (key) => File.decodeFileName(parse(key).name)
+        );
         RETURN = Object.values(
           Utils.deepMerge(
             await getItemsFromSchema(
-              join(this.databasePath, tableName),
+              join(this.folder, this.database, tableName),
               schema.filter(
                 (field) => !alreadyExistsColumns.includes(field.key)
               ),
@@ -1335,15 +1257,18 @@ export default class Inibase {
       (Array.isArray(RETURN) && !RETURN.length)
     )
       return null;
-    return Utils.isArrayOfObjects(RETURN)
-      ? (RETURN as Data[]).map((data: Data) => {
-          data.id = Utils.encodeID(data.id as number, this.salt);
-          return data;
-        })
-      : {
-          ...(RETURN as Data),
-          id: Utils.encodeID((RETURN as Data).id as number, this.salt),
-        };
+
+    const greatestTotalItems = Math.max(
+      ...Object.entries(this.totalItems)
+        .filter(([k]) => k.startsWith(tableName + "-"))
+        .map(([, v]) => v)
+    );
+    this.pageInfo = {
+      ...(({ columns, ...restOfOptions }) => restOfOptions)(options),
+      total_pages: Math.ceil(greatestTotalItems / options.per_page),
+      total: greatestTotalItems,
+    };
+    return RETURN;
   }
 
   public async post(
@@ -1352,14 +1277,19 @@ export default class Inibase {
     options: Options = {
       page: 1,
       per_page: 15,
-    }
-  ): Promise<Data | Data[] | null> {
+    },
+    returnPostedData: boolean = true
+  ): Promise<Data | Data[] | null | void> {
     const schema = await this.getTableSchema(tableName);
     let RETURN: Data | Data[] | null | undefined;
     if (!schema) throw this.throwError("NO_SCHEMA", tableName);
-    const idFilePath = join(this.databasePath, tableName, "id.inib");
+    const idFilePath = join(this.folder, this.database, tableName, "id.inib");
     let last_id = (await File.isExists(idFilePath))
-      ? Number(Object.values(await File.get(idFilePath, -1, "number"))[0])
+      ? Number(
+          Object.values(
+            await File.get(idFilePath, -1, "number", undefined, this.salt)
+          )[0]
+        )
       : 0;
     if (Utils.isArrayOfObjects(data))
       (data as Data[]).forEach((single_data, index) => {
@@ -1379,7 +1309,7 @@ export default class Inibase {
     if (!RETURN) throw this.throwError("NO_DATA");
     RETURN = this.formatData(RETURN, schema);
     const pathesContents = this.joinPathesContents(
-      join(this.databasePath, tableName),
+      join(this.folder, this.database, tableName),
       RETURN
     );
     for await (const [path, content] of Object.entries(pathesContents))
@@ -1388,13 +1318,14 @@ export default class Inibase {
         (Array.isArray(content) ? content.join("\n") : content ?? "") + "\n"
       );
 
-    return this.get(
-      tableName,
-      Utils.isArrayOfObjects(RETURN)
-        ? RETURN.map((data: Data) => data.id)
-        : ((RETURN as Data).id as number),
-      options
-    );
+    if (returnPostedData)
+      return this.get(
+        tableName,
+        Utils.isArrayOfObjects(RETURN)
+          ? RETURN.map((data: Data) => data.id)
+          : ((RETURN as Data).id as number),
+        options
+      );
   }
 
   public async put(
@@ -1404,11 +1335,12 @@ export default class Inibase {
     options: Options = {
       page: 1,
       per_page: 15,
-    }
-  ): Promise<Data | Data[] | null> {
+    },
+    returnPostedData: boolean = true
+  ): Promise<Data | Data[] | null | void> {
     const schema = await this.getTableSchema(tableName);
     if (!schema) throw this.throwError("NO_SCHEMA", tableName);
-    const idFilePath = join(this.databasePath, tableName, "id.inib");
+    const idFilePath = join(this.folder, this.database, tableName, "id.inib");
     if (!(await File.isExists(idFilePath)))
       throw this.throwError("NO_ITEMS", tableName);
     data = this.formatData(data, schema, true);
@@ -1431,11 +1363,11 @@ export default class Inibase {
         return this.put(
           tableName,
           data,
-          Utils.decodeID((data as Data).id as string, this.salt)
+          UtilsServer.decodeID((data as Data).id as string, this.salt)
         );
       } else {
         const pathesContents = this.joinPathesContents(
-          join(this.databasePath, tableName),
+          join(this.folder, this.database, tableName),
           Utils.isArrayOfObjects(data)
             ? (data as Data[]).map((item) => ({
                 ...(({ id, ...restOfData }) => restOfData)(item),
@@ -1448,7 +1380,7 @@ export default class Inibase {
         );
         for (const [path, content] of Object.entries(pathesContents))
           await File.replace(path, content);
-        return this.get(tableName, where, options);
+        if (returnPostedData) return this.get(tableName, where, options);
       }
     } else if (Utils.isValidID(where)) {
       let Ids = where as string | string[];
@@ -1456,14 +1388,14 @@ export default class Inibase {
       const [lineNumbers, countItems] = await File.search(
         idFilePath,
         "[]",
-        Ids.map((id) => Utils.decodeID(id, this.salt)),
+        Ids.map((id) => UtilsServer.decodeID(id, this.salt)),
         undefined,
         "number",
         undefined,
         Ids.length,
         0,
         false,
-        this.databasePath
+        this.salt
       );
       if (!lineNumbers || !Object.keys(lineNumbers).length)
         throw this.throwError("INVALID_ID");
@@ -1473,7 +1405,7 @@ export default class Inibase {
       const pathesContents = Object.fromEntries(
         Object.entries(
           this.joinPathesContents(
-            join(this.databasePath, tableName),
+            join(this.folder, this.database, tableName),
             Utils.isArrayOfObjects(data)
               ? (data as Data[]).map((item) => ({
                   ...item,
@@ -1494,7 +1426,7 @@ export default class Inibase {
       );
       for (const [path, content] of Object.entries(pathesContents))
         await File.replace(path, content);
-      return this.get(tableName, where, options);
+      if (returnPostedData) return this.get(tableName, where, options);
     } else if (typeof where === "object" && !Array.isArray(where)) {
       const lineNumbers = this.get(tableName, where, undefined, true);
       if (!lineNumbers || !Array.isArray(lineNumbers) || !lineNumbers.length)
@@ -1510,16 +1442,16 @@ export default class Inibase {
   ): Promise<string | string[] | null> {
     const schema = await this.getTableSchema(tableName);
     if (!schema) throw this.throwError("NO_SCHEMA", tableName);
-    const idFilePath = join(this.databasePath, tableName, "id.inib");
+    const idFilePath = join(this.folder, this.database, tableName, "id.inib");
     if (!(await File.isExists(idFilePath)))
       throw this.throwError("NO_ITEMS", tableName);
     if (!where) {
-      const files = await readdir(join(this.databasePath, tableName));
+      const files = await readdir(join(this.folder, this.database, tableName));
       if (files.length) {
         for (const file in files.filter(
-          (fileName: string) => fileName !== "schema.inib"
+          (fileName: string) => fileName !== "schema"
         ))
-          await unlink(join(this.databasePath, tableName, file));
+          await unlink(join(this.folder, this.database, tableName, file));
       }
       return "*";
     } else if (Utils.isValidID(where)) {
@@ -1528,14 +1460,14 @@ export default class Inibase {
       const [lineNumbers, countItems] = await File.search(
         idFilePath,
         "[]",
-        Ids.map((id) => Utils.decodeID(id, this.salt)),
+        Ids.map((id) => UtilsServer.decodeID(id, this.salt)),
         undefined,
         "number",
         undefined,
         Ids.length,
         0,
         false,
-        this.databasePath
+        this.salt
       );
       if (!lineNumbers || !Object.keys(lineNumbers).length)
         throw this.throwError("INVALID_ID");
@@ -1545,24 +1477,26 @@ export default class Inibase {
         where as string | string[]
       );
     } else if (Utils.isNumber(where)) {
-      const files = await readdir(join(this.databasePath, tableName));
+      const files = await readdir(join(this.folder, this.database, tableName));
       if (files.length) {
         if (!_id)
           _id = Object.values(
             await File.get(
-              join(this.databasePath, tableName, "id.inib"),
+              join(this.folder, this.database, tableName, "id.inib"),
               where as number | number[],
-              "number"
+              "number",
+              undefined,
+              this.salt
             )
           )
             .map(Number)
-            .map((id) => Utils.encodeID(id, this.salt));
+            .map((id) => UtilsServer.encodeID(id, this.salt));
         for (const file of files.filter(
           (fileName: string) =>
-            fileName.endsWith(".inib") && fileName !== "schema.inib"
+            fileName.endsWith(".inib") && fileName !== "schema"
         ))
           await File.remove(
-            join(this.databasePath, tableName, file),
+            join(this.folder, this.database, tableName, file),
             where as number | number[]
           );
         return Array.isArray(_id) && _id.length === 1 ? _id[0] : _id;