inibase 1.0.0-rc.0 → 1.0.0-rc.11

package/index.ts

@@ -1,24 +1,21 @@
 import {
-  readFileSync,
-  writeFileSync,
-  mkdirSync,
-  existsSync,
-  appendFileSync,
-  readdirSync,
-  unlinkSync,
-  renameSync,
-} from "fs";
-import { join, parse } from "path";
-import { createDecipheriv, createCipheriv, scryptSync } from "crypto";
-import Utils from "./utils";
+  unlink,
+  rename,
+  readFile,
+  writeFile,
+  appendFile,
+  mkdir,
+  readdir,
+} from "node:fs/promises";
+import { join, parse } from "node:path";
+import { scryptSync } from "node:crypto";
 import File from "./file";
-
-export { File, Utils };
+import Utils from "./utils";
+import UtilsServer from "./utils.server";
 
 export type Data = {
   id?: number | string;
   [key: string]: any;
-  [id: number]: any;
   created_at?: Date;
   updated_at?: Date;
 };
@@ -32,36 +29,51 @@ export type FieldType =
   | "url"
   | "table"
   | "object"
+  | "array"
   | "password"
-  | "array";
-type Field =
-  | {
-      id?: string | number | null | undefined;
-      key: string;
-      type: Exclude<FieldType, "array" | "object">;
-      required?: boolean;
-    }
-  | {
-      id?: string | number | null | undefined;
-      key: string;
-      type: "array";
-      required?: boolean;
-      children: FieldType | FieldType[] | Schema;
-    }
-  | {
-      id?: string | number | null | undefined;
-      key: string;
-      type: "object";
-      required?: boolean;
-      children: Schema;
-    };
+  | "html"
+  | "ip"
+  | "id";
+type FieldDefault = {
+  id?: string | number | null | undefined;
+  key: string;
+  required?: boolean;
+  children?: any;
+};
+type FieldStringType = {
+  type: Exclude<FieldType, "array" | "object">;
+};
+type FieldStringArrayType = {
+  type: Exclude<FieldType, "array" | "object">[];
+};
+type FieldArrayType = {
+  type: "array";
+  children: FieldType | FieldType[] | Schema;
+};
+type FieldArrayArrayType = {
+  type: ["array", ...FieldType[]];
+  children: FieldType | FieldType[];
+};
+type FieldObjectType = {
+  type: "object";
+  children: Schema;
+};
+// if "type" is array, make "array" at first place, and "number" & "string" at last place of the array
+export type Field = FieldDefault &
+  (
+    | FieldStringType
+    | FieldStringArrayType
+    | FieldObjectType
+    | FieldArrayType
+    | FieldArrayArrayType
+  );
 
 export type Schema = Field[];
 
 export interface Options {
   page?: number;
   per_page?: number;
-  columns?: string[];
+  columns?: string[] | string;
 }
 
 export type ComparisonOperator =
@@ -77,32 +89,46 @@ export type ComparisonOperator =
   | "![]";
 
 type pageInfo = {
-  total_items?: number;
+  total?: number;
   total_pages?: number;
 } & Options;
 
 export type Criteria =
   | {
-      [logic in "and" | "or"]?: Criteria;
+      [logic in "and" | "or"]?: Criteria | (string | number | boolean | null)[];
     }
   | {
       [key: string]: string | number | boolean | Criteria;
     }
   | null;
 
+declare global {
+  type Entries<T> = {
+    [K in keyof T]: [K, T[K]];
+  }[keyof T][];
+
+  interface ObjectConstructor {
+    entries<T extends object>(o: T): Entries<T>;
+  }
+}
+
 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(database, "salt", 32);
   }
 
   private throwError(
@@ -116,14 +142,14 @@ export default class Inibase {
   ): Error {
     const errorMessages: Record<string, Record<string, string>> = {
       en: {
+        FIELD_REQUIRED: "REQUIRED: {variable}",
         NO_SCHEMA: "NO_SCHEMA: {variable}",
         NO_ITEMS: "NO_ITEMS: {variable}",
+        NO_DATA: "NO_DATA: {variable}",
         INVALID_ID: "INVALID_ID: {variable}",
         INVALID_TYPE: "INVALID_TYPE: {variable}",
-        REQUIRED: "REQUIRED: {variable}",
-        NO_DATA: "NO_DATA: {variable}",
         INVALID_OPERATOR: "INVALID_OPERATOR: {variable}",
-        PARAMETERS: "PARAMETERS: {variable}",
+        INVALID_PARAMETERS: "PARAMETERS: {variable}",
       },
       // Add more languages and error messages as needed
     };
@@ -151,148 +177,42 @@ export default class Inibase {
     return new Error(errorMessage);
   }
 
-  public encodeID(id: number, secretKey?: string | number): string {
-    if (!secretKey) secretKey = this.databasePath;
-
-    const salt = scryptSync(secretKey.toString(), "salt", 32),
-      cipher = createCipheriv("aes-256-cbc", salt, salt.subarray(0, 16));
-
-    return cipher.update(id.toString(), "utf8", "hex") + cipher.final("hex");
-  }
-
-  public decodeID(input: string, secretKey?: string | number): number {
-    if (!secretKey) secretKey = this.databasePath;
-    const salt = scryptSync(secretKey.toString(), "salt", 32),
-      decipher = createDecipheriv("aes-256-cbc", salt, salt.subarray(0, 16));
-    return Number(
-      decipher.update(input as string, "hex", "utf8") + decipher.final("utf8")
-    );
-  }
-
-  public isValidID(input: any): boolean {
-    return Array.isArray(input)
-      ? input.every(this.isValidID)
-      : typeof input === "string" && input.length === 32;
-  }
-
-  public validateData(
-    data: Data | Data[],
-    schema: Schema,
-    skipRequiredField: boolean = false
-  ): void {
-    if (Utils.isArrayOfObjects(data))
-      for (const single_data of data as Data[])
-        this.validateData(single_data, schema, skipRequiredField);
-    else if (!Array.isArray(data)) {
-      const validateFieldType = (
-        value: any,
-        field: Field | FieldType | FieldType[]
-      ): boolean => {
-        if (Array.isArray(field))
-          return field.some((item) => validateFieldType(value, item));
-        switch (typeof field === "string" ? field : field.type) {
-          case "string":
-            return value === null || typeof value === "string";
-          case "number":
-            return value === null || typeof value === "number";
-          case "boolean":
-            return (
-              value === null ||
-              typeof value === "boolean" ||
-              value === "true" ||
-              value === "false"
-            );
-          case "date":
-            return value === null || value instanceof Date;
-          case "object":
-            return (
-              value === null ||
-              (typeof value === "object" &&
-                !Array.isArray(value) &&
-                value !== null)
-            );
-          case "array":
-            return (
-              value === null ||
-              (Array.isArray(value) &&
-                value.every((item) => validateFieldType(item, field)))
-            );
-          case "email":
-            return (
-              value === null ||
-              (typeof value === "string" &&
-                /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value))
-            );
-          case "url":
-            return (
-              value === null ||
-              (typeof value === "string" &&
-                (value[0] === "#" ||
-                  /^((https?|www):\/\/)?[a-z0-9-]+(\.[a-z0-9-]+)*\.[a-z]+(\/[^\s]*)?$/.test(
-                    value
-                  )))
-            );
-          case "table":
-            // feat: check if id exists
-            if (Array.isArray(value))
-              return (
-                typeof field !== "string" &&
-                field.type === "table" &&
-                ((Utils.isArrayOfObjects(value) &&
-                  value.every(
-                    (element) =>
-                      element.hasOwnProperty("id") &&
-                      this.isValidID((element as Data).id)
-                  )) ||
-                  value.every(Utils.isNumber) ||
-                  this.isValidID(value))
-              );
-            else if (Utils.isObject(value))
-              return (
-                value.hasOwnProperty("id") && this.isValidID((value as Data).id)
-              );
-            else return Utils.isNumber(value) || this.isValidID(value);
-          default:
-            return true;
-        }
-      };
-      for (const field of schema) {
-        if (data.hasOwnProperty(field.key)) {
-          if (!validateFieldType(data[field.key], field))
-            throw this.throwError("INVALID_TYPE", field.key);
-          if (
-            (field.type === "array" || field.type === "object") &&
-            field.children &&
-            Utils.isArrayOfObjects(field.children)
-          )
-            this.validateData(
-              data[field.key],
-              field.children as Schema,
-              skipRequiredField
-            );
-        } else if (field.required && !skipRequiredField)
-          throw this.throwError("REQUIRED", field.key);
-      }
+  private findLastIdNumber(schema: Schema): number {
+    const lastField = schema[schema.length - 1];
+    if (lastField) {
+      if (
+        (lastField.type === "array" || lastField.type === "object") &&
+        Utils.isArrayOfObjects(lastField.children)
+      )
+        return this.findLastIdNumber(lastField.children as Schema);
+      else if (lastField.id && Utils.isValidID(lastField.id))
+        return UtilsServer.decodeID(lastField.id as string, this.salt);
     }
+    return 0;
   }
 
-  public setTableSchema(tableName: string, schema: Schema): void {
+  public async setTableSchema(
+    tableName: string,
+    schema: Schema
+  ): Promise<void> {
     const encodeSchema = (schema: Schema) => {
         let RETURN: any[][] = [],
           index = 0;
         for (const field of schema) {
           if (!RETURN[index]) RETURN[index] = [];
           RETURN[index].push(
-            field.id ? this.decodeID(field.id as string) : null
+            field.id
+              ? UtilsServer.decodeID(field.id as string, this.salt)
+              : null
           );
           RETURN[index].push(field.key ?? null);
           RETURN[index].push(field.required ?? null);
           RETURN[index].push(field.type ?? null);
           RETURN[index].push(
-            (field.type === "array" || field.type === "object") &&
-              field.children &&
-              Utils.isArrayOfObjects(field.children)
-              ? encodeSchema(field.children as Schema) ?? null
+            (field as any).children
+              ? Utils.isArrayOfObjects((field as any).children)
+                ? encodeSchema((field as any).children as Schema) ?? null
+                : (field as any).children
               : null
           );
           index++;
@@ -307,97 +227,78 @@ export default class Inibase {
           ) {
             if (!field.id) {
               oldIndex++;
-              field = { ...field, id: this.encodeID(oldIndex) };
-            } else oldIndex = this.decodeID(field.id as string);
+              field = {
+                ...field,
+                id: UtilsServer.encodeID(oldIndex, 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 = this.decodeID(field.id as string);
+          } else if (field.id)
+            oldIndex = UtilsServer.decodeID(field.id as string, this.salt);
           else {
             oldIndex++;
-            field = { ...field, id: this.encodeID(oldIndex) };
+            field = {
+              ...field,
+              id: UtilsServer.encodeID(oldIndex, this.salt),
+            };
           }
           return field;
-        }),
-      findLastIdNumber = (schema: Schema): number => {
-        const lastField = schema[schema.length - 1];
-        if (lastField) {
-          if (
-            (lastField.type === "array" || lastField.type === "object") &&
-            Utils.isArrayOfObjects(lastField.children)
-          )
-            return findLastIdNumber(lastField.children as Schema);
-          else return this.decodeID(lastField.id as string);
-        } else return 0;
-      };
+        });
 
     // remove id from schema
-    schema = schema.filter((field) => field.key !== "id");
-    schema = addIdToSchema(schema, findLastIdNumber(schema));
-    const TablePath = join(this.databasePath, tableName),
-      TableSchemaPath = join(TablePath, "schema.inib");
-    if (!existsSync(TablePath)) mkdirSync(TablePath, { recursive: true });
-    if (existsSync(TableSchemaPath)) {
+    schema = schema.filter(
+      (field) => !["id", "created_at", "updated_at"].includes(field.key)
+    );
+    schema = addIdToSchema(schema, this.findLastIdNumber(schema));
+    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)) {
       // update columns files names based on field id
       const schemaToIdsPath = (schema: any, prefix = "") => {
           let RETURN: any = {};
-          for (const field of schema) {
+          for (const field of schema)
             if (field.children && Utils.isArrayOfObjects(field.children)) {
               Utils.deepMerge(
                 RETURN,
                 schemaToIdsPath(
                   field.children,
-                  (prefix ?? "") +
-                    field.key +
-                    (field.type === "array" ? ".*." : ".")
+                  (prefix ?? "") + field.key + "."
                 )
               );
-            } else if (this.isValidID(field.id))
-              RETURN[this.decodeID(field.id)] = File.encodeFileName(
-                (prefix ?? "") + field.key,
-                "inib"
-              );
-          }
-          return RETURN;
-        },
-        findChangedProperties = (
-          obj1: Record<string, string>,
-          obj2: Record<string, string>
-        ): Record<string, string> | null => {
-          const result: Record<string, string> = {};
+            } else if (Utils.isValidID(field.id))
+              RETURN[UtilsServer.decodeID(field.id, this.salt)] =
+                (prefix ?? "") + field.key + ".inib";
 
-          for (const key1 in obj1) {
-            if (obj2.hasOwnProperty(key1) && obj1[key1] !== obj2[key1]) {
-              result[obj1[key1]] = obj2[key1];
-            }
-          }
-
-          return Object.keys(result).length ? result : null;
+          return RETURN;
         },
-        replaceOldPathes = findChangedProperties(
-          schemaToIdsPath(this.getTableSchema(tableName)),
+        replaceOldPathes = Utils.findChangedProperties(
+          schemaToIdsPath(await this.getTableSchema(tableName)),
           schemaToIdsPath(schema)
         );
-      if (replaceOldPathes) {
+      if (replaceOldPathes)
         for (const [oldPath, newPath] of Object.entries(replaceOldPathes))
-          if (existsSync(join(TablePath, oldPath)))
-            renameSync(join(TablePath, oldPath), join(TablePath, newPath));
-      }
+          if (await File.isExists(join(TablePath, oldPath)))
+            await rename(join(TablePath, oldPath), join(TablePath, newPath));
     }
 
-    writeFileSync(
-      join(TablePath, "schema.inib"),
+    await writeFile(
+      join(TablePath, "schema"),
       JSON.stringify(encodeSchema(schema))
     );
   }
 
-  public getTableSchema(tableName: string): Schema | undefined {
+  public async getTableSchema(tableName: string): Promise<Schema | undefined> {
     const decodeSchema = (encodedSchema: any) => {
         return encodedSchema.map((field: any) =>
           Array.isArray(field[0])
             ? decodeSchema(field)
             : Object.fromEntries(
                 Object.entries({
-                  id: this.encodeID(field[0]),
+                  id: UtilsServer.encodeID(field[0], this.salt),
                   key: field[1],
                   required: field[2],
                   type: field[3],
@@ -410,10 +311,12 @@ export default class Inibase {
               )
         );
       },
-      TableSchemaPath = join(this.databasePath, tableName, "schema.inib");
-    if (!existsSync(TableSchemaPath)) return undefined;
+      TableSchemaPath = join(this.folder, this.database, tableName, "schema");
+    if (!(await File.isExists(TableSchemaPath))) return undefined;
     if (!this.cache.has(TableSchemaPath)) {
-      const TableSchemaPathContent = readFileSync(TableSchemaPath);
+      const TableSchemaPathContent = await readFile(TableSchemaPath, {
+        encoding: "utf8",
+      });
       this.cache.set(
         TableSchemaPath,
         TableSchemaPathContent
@@ -421,25 +324,107 @@ export default class Inibase {
           : ""
       );
     }
+    const schema = this.cache.get(TableSchemaPath) as unknown as Schema,
+      lastIdNumber = this.findLastIdNumber(schema);
     return [
-      { id: this.encodeID(0), key: "id", type: "number", required: true },
-      ...(this.cache.get(TableSchemaPath) as unknown as Schema),
+      {
+        id: UtilsServer.encodeID(0, this.salt),
+        key: "id",
+        type: "id",
+        required: true,
+      },
+      ...schema,
+      {
+        id: UtilsServer.encodeID(lastIdNumber + 1, this.salt),
+        key: "created_at",
+        type: "date",
+        required: true,
+      },
+      {
+        id: UtilsServer.encodeID(lastIdNumber + 2, this.salt),
+        key: "updated_at",
+        type: "date",
+        required: false,
+      },
     ];
   }
 
-  public getField(keyPath: string, schema: Schema | Field): Field | null {
-    for (const key of keyPath.split(".")) {
+  public getField<Property extends keyof Field | "children">(
+    keyPath: string,
+    schema: Schema | Field,
+    property?: Property
+  ) {
+    const keyPathSplited = keyPath.split(".");
+    for (const [index, key] of keyPathSplited.entries()) {
       if (key === "*") continue;
       const foundItem = (schema as Schema).find((item) => item.key === key);
       if (!foundItem) return null;
-      schema =
+      if (index === keyPathSplited.length - 1) schema = foundItem;
+      if (
         (foundItem.type === "array" || foundItem.type === "object") &&
         foundItem.children &&
         Utils.isArrayOfObjects(foundItem.children)
-          ? (foundItem.children as Schema)
-          : foundItem;
+      )
+        schema = foundItem.children as Schema;
+    }
+    if (property) {
+      switch (property) {
+        case "type":
+          return (schema as Field).type;
+        case "children":
+          return (
+            schema as
+              | (Field & FieldObjectType)
+              | FieldArrayType
+              | FieldArrayArrayType
+          ).children;
+
+        default:
+          return (schema as Field)[property as keyof Field];
+      }
+    } else return schema as Field;
+  }
+
+  public validateData(
+    data: Data | Data[],
+    schema: Schema,
+    skipRequiredField: boolean = false
+  ): void {
+    if (Utils.isArrayOfObjects(data))
+      for (const single_data of data as 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) &&
+          !Utils.validateFieldType(
+            data[field.key],
+            field.type,
+            (field as any)?.children &&
+              !Utils.isArrayOfObjects((field as any)?.children)
+              ? (field as any)?.children
+              : undefined
+          )
+        )
+          throw this.throwError("INVALID_TYPE", field.key);
+        if (
+          (field.type === "array" || field.type === "object") &&
+          field.children &&
+          Utils.isArrayOfObjects(field.children)
+        )
+          this.validateData(
+            data[field.key],
+            field.children as Schema,
+            skipRequiredField
+          );
+      }
     }
-    return schema as Field;
   }
 
   public formatData(
@@ -447,89 +432,117 @@ export default class Inibase {
     schema: Schema,
     formatOnlyAvailiableKeys?: boolean
   ): Data | Data[] {
-    if (Utils.isArrayOfObjects(data)) {
+    const formatField = (
+      value: any,
+      field: Field
+    ): Data | Data[] | number | string => {
+      if (Array.isArray(field.type))
+        field.type = Utils.detectFieldType(value, field.type);
+      switch (field.type) {
+        case "array":
+          if (typeof field.children === "string") {
+            if (field.type === "array" && field.children === "table") {
+              if (Array.isArray(data[field.key])) {
+                if (Utils.isArrayOfObjects(data[field.key])) {
+                  if (
+                    value.every(
+                      (item: any) =>
+                        item.hasOwnProperty("id") &&
+                        (Utils.isValidID(item.id) || Utils.isNumber(item.id))
+                    )
+                  )
+                    value.map((item: any) =>
+                      Utils.isNumber(item.id)
+                        ? Number(item.id)
+                        : 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)
+                      : UtilsServer.decodeID(item as string, this.salt)
+                  );
+              } else if (Utils.isValidID(value))
+                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))
+            return this.formatData(
+              value,
+              field.children as Schema,
+              formatOnlyAvailiableKeys
+            );
+          else if (Array.isArray(field.children))
+            return Array.isArray(value) ? value : [value];
+          break;
+        case "object":
+          if (Utils.isArrayOfObjects(field.children))
+            return this.formatData(
+              value,
+              field.children,
+              formatOnlyAvailiableKeys
+            );
+          break;
+        case "table":
+          if (Utils.isObject(value)) {
+            if (
+              value.hasOwnProperty("id") &&
+              (Utils.isValidID(value.id) || Utils.isNumber(value))
+            )
+              return Utils.isNumber(value.id)
+                ? Number(value.id)
+                : UtilsServer.decodeID(value.id, this.salt);
+          } else if (Utils.isValidID(value) || Utils.isNumber(value))
+            return Utils.isNumber(value)
+              ? Number(value)
+              : UtilsServer.decodeID(value, this.salt);
+          break;
+        case "password":
+          return value.length === 161 ? value : UtilsServer.hashPassword(value);
+        case "number":
+          return Utils.isNumber(value) ? Number(value) : null;
+        case "id":
+          return Utils.isNumber(value)
+            ? value
+            : UtilsServer.decodeID(value, this.salt);
+        default:
+          return value;
+      }
+      return null;
+    };
+
+    this.validateData(data, schema, formatOnlyAvailiableKeys);
+
+    if (Utils.isArrayOfObjects(data))
       return data.map((single_data: Data) =>
-        this.formatData(single_data, schema)
+        this.formatData(single_data, schema, formatOnlyAvailiableKeys)
       );
-    } else if (!Array.isArray(data)) {
+    else if (Utils.isObject(data)) {
       let RETURN: Data = {};
       for (const field of schema) {
         if (!data.hasOwnProperty(field.key)) {
+          if (formatOnlyAvailiableKeys || !field.required) continue;
           RETURN[field.key] = this.getDefaultValue(field);
           continue;
         }
-        if (formatOnlyAvailiableKeys && !data.hasOwnProperty(field.key))
-          continue;
-
-        if (field.type === "array" || field.type === "object") {
-          if (field.children)
-            if (typeof field.children === "string") {
-              if (field.type === "array" && field.children === "table") {
-                if (Array.isArray(data[field.key])) {
-                  if (Utils.isArrayOfObjects(data[field.key])) {
-                    if (
-                      data[field.key].every(
-                        (item: any) =>
-                          item.hasOwnProperty("id") &&
-                          (this.isValidID(item.id) || Utils.isNumber(item.id))
-                      )
-                    )
-                      data[field.key].map((item: any) =>
-                        Utils.isNumber(item.id)
-                          ? parseFloat(item.id)
-                          : this.decodeID(item.id)
-                      );
-                  } else if (
-                    this.isValidID(data[field.key]) ||
-                    Utils.isNumber(data[field.key])
-                  )
-                    RETURN[field.key] = data[field.key].map(
-                      (item: number | string) =>
-                        Utils.isNumber(item)
-                          ? parseFloat(item as string)
-                          : this.decodeID(item as string)
-                    );
-                } else if (this.isValidID(data[field.key]))
-                  RETURN[field.key] = [this.decodeID(data[field.key])];
-                else if (Utils.isNumber(data[field.key]))
-                  RETURN[field.key] = [parseFloat(data[field.key])];
-              } else if (data.hasOwnProperty(field.key))
-                RETURN[field.key] = data[field.key];
-            } else if (Utils.isArrayOfObjects(field.children))
-              RETURN[field.key] = this.formatData(
-                data[field.key],
-                field.children as Schema,
-                formatOnlyAvailiableKeys
-              );
-        } else if (field.type === "table") {
-          if (Utils.isObject(data[field.key])) {
-            if (
-              data[field.key].hasOwnProperty("id") &&
-              (this.isValidID(data[field.key].id) ||
-                Utils.isNumber(data[field.key]))
-            )
-              RETURN[field.key] = Utils.isNumber(data[field.key].id)
-                ? parseFloat(data[field.key].id)
-                : this.decodeID(data[field.key].id);
-          } else if (
-            this.isValidID(data[field.key]) ||
-            Utils.isNumber(data[field.key])
-          )
-            RETURN[field.key] = Utils.isNumber(data[field.key])
-              ? parseFloat(data[field.key])
-              : this.decodeID(data[field.key]);
-        } else if (field.type === "password")
-          RETURN[field.key] =
-            data[field.key].length === 161
-              ? data[field.key]
-              : Utils.hashPassword(data[field.key]);
-        else RETURN[field.key] = data[field.key];
+        RETURN[field.key] = formatField(data[field.key], field);
       }
       return RETURN;
     } else return [];
   }
 
   private getDefaultValue(field: Field): any {
+    if (Array.isArray(field.type))
+      return this.getDefaultValue({
+        ...field,
+        type: field.type.sort(
+          (a: FieldType, b: FieldType) =>
+            Number(b === "array") - Number(a === "array") ||
+            Number(a === "string") - Number(b === "string") ||
+            Number(a === "number") - Number(b === "number")
+        )[0],
+      } as Field);
+
     switch (field.type) {
       case "array":
         return Utils.isArrayOfObjects(field.children)
@@ -556,37 +569,55 @@ export default class Inibase {
     mainPath: string,
     data: Data | Data[]
   ): { [key: string]: string[] } {
-    const CombineData = (data: Data | Data[], prefix?: string) => {
+    const CombineData = (_data: Data | Data[], prefix?: string) => {
       let RETURN: Record<
         string,
         string | boolean | number | null | (string | boolean | number | null)[]
       > = {};
-
-      if (Utils.isArrayOfObjects(data))
-        RETURN = Utils.combineObjects(
-          (data as Data[]).map((single_data) => CombineData(single_data))
+      const combineObjectsToArray = (input: any[]) =>
+        input.reduce(
+          (r, c) => (
+            Object.keys(c).map((k) => (r[k] = [...(r[k] || []), c[k]])), r
+          ),
+          {}
+        );
+      if (Utils.isArrayOfObjects(_data))
+        RETURN = combineObjectsToArray(
+          (_data as Data[]).map((single_data) => CombineData(single_data))
         );
       else {
-        for (const [key, value] of Object.entries(data)) {
+        for (const [key, value] of Object.entries(_data as Data)) {
           if (Utils.isObject(value))
             Object.assign(RETURN, CombineData(value, `${key}.`));
           else if (Array.isArray(value)) {
-            if (Utils.isArrayOfObjects(value))
+            if (Utils.isArrayOfObjects(value)) {
+              Object.assign(
+                RETURN,
+                CombineData(
+                  combineObjectsToArray(value),
+                  (prefix ?? "") + key + "."
+                )
+              );
+            } else if (
+              Utils.isArrayOfArrays(value) &&
+              value.every(Utils.isArrayOfObjects)
+            )
               Object.assign(
                 RETURN,
                 CombineData(
-                  Utils.combineObjects(value),
-                  (prefix ?? "") + key + ".*."
+                  combineObjectsToArray(value.map(combineObjectsToArray)),
+                  (prefix ?? "") + key + "."
                 )
               );
-            else
-              RETURN[(prefix ?? "") + key] = Utils.encode(value) as
+            else {
+              RETURN[(prefix ?? "") + key] = File.encode(value) as
                 | boolean
                 | number
                 | string
                 | null;
+            }
           } else
-            RETURN[(prefix ?? "") + key] = Utils.encode(value) as
+            RETURN[(prefix ?? "") + key] = File.encode(value) as
               | boolean
               | number
               | string
@@ -598,14 +629,27 @@ export default class Inibase {
     const addPathToKeys = (obj: Record<string, any>, path: string) => {
       const newObject: Record<string, any> = {};
 
-      for (const key in obj)
-        newObject[join(path, File.encodeFileName(key, "inib"))] = obj[key];
+      for (const key in obj) newObject[join(path, key + ".inib")] = obj[key];
 
       return newObject;
     };
     return addPathToKeys(CombineData(data), mainPath);
   }
 
+  public async getOne(
+    tableName: string,
+    where?: string | number | (string | number)[] | Criteria,
+    options: Options = {
+      page: 1,
+      per_page: 15,
+    }
+  ): Promise<Data | null> {
+    const _get = await this.get(tableName, where, options);
+    if (!_get) return null;
+    else if (Array.isArray(_get)) return (_get as Data)[0];
+    else return _get;
+  }
+
   public async get(
     tableName: string,
     where?: string | number | (string | number)[] | Criteria,
@@ -616,43 +660,43 @@ export default class Inibase {
     onlyLinesNumbers?: boolean
   ): Promise<Data | Data[] | number[] | null> {
     if (!options.columns) options.columns = [];
-    else if (
-      options.columns.length &&
-      !(options.columns as string[]).includes("id")
-    )
+    else if (!Array.isArray(options.columns))
+      options.columns = [options.columns];
+    if (options.columns.length && !(options.columns as string[]).includes("id"))
       options.columns.push("id");
     if (!options.page) options.page = 1;
     if (!options.per_page) options.per_page = 15;
     let RETURN!: Data | Data[] | null;
-    let schema = this.getTableSchema(tableName);
+    let schema = await this.getTableSchema(tableName);
     if (!schema) throw this.throwError("NO_SCHEMA", tableName);
+    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
         .map((field) => {
-          if (columns.includes(field.key)) return field;
+          if (columns.some((column) => column.startsWith("!")))
+            return columns.includes("!" + field.key) ? null : field;
+          if (columns.includes(field.key) || columns.includes("*"))
+            return field;
+
           if (
             (field.type === "array" || field.type === "object") &&
             Utils.isArrayOfObjects(field.children) &&
-            columns.filter((column) =>
-              column.startsWith(
-                field.key + (field.type === "array" ? ".*." : ".")
-              )
+            columns.filter(
+              (column) =>
+                column.startsWith(field.key + ".") ||
+                column.startsWith("!" + field.key + ".")
             ).length
           ) {
             field.children = filterSchemaByColumns(
               field.children as Schema,
               columns
-                .filter((column) =>
-                  column.startsWith(
-                    field.key + (field.type === "array" ? ".*." : ".")
-                  )
-                )
-                .map((column) =>
-                  column.replace(
-                    field.key + (field.type === "array" ? ".*." : "."),
-                    ""
-                  )
+                .filter(
+                  (column) =>
+                    column.startsWith(field.key + ".") ||
+                    column.startsWith("!" + field.key + ".")
                 )
+                .map((column) => column.replace(field.key + ".", ""))
             );
             return field;
           }
@@ -667,100 +711,251 @@ export default class Inibase {
       schema: Schema,
       linesNumber: number[],
       prefix?: string
-    ): Promise<Data> => {
-      let RETURN: Data = {};
+    ) => {
+      let RETURN: Record<number, Data> = {};
       for (const field of schema) {
         if (
-          (field.type === "array" || field.type === "object") &&
-          field.children
+          (field.type === "array" ||
+            (Array.isArray(field.type) &&
+              (field.type as any).includes("array"))) &&
+          (field as FieldDefault & (FieldArrayType | FieldArrayArrayType))
+            .children
         ) {
-          if (field.children === "table") {
-            if (options.columns)
-              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(
+          if (
+            Utils.isArrayOfObjects(
+              (field as FieldDefault & (FieldArrayType | FieldArrayArrayType))
+                .children
+            )
+          ) {
+            if (
+              (
+                (field as FieldDefault & (FieldArrayType | FieldArrayArrayType))
+                  .children as Schema
+              ).filter(
+                (children) =>
+                  children.type === "array" &&
+                  Utils.isArrayOfObjects(children.children)
+              ).length
+            ) {
+              // one of children has array field type and has children array of object = Schema
+              Object.entries(
+                (await getItemsFromSchema(
                   path,
-                  File.encodeFileName((prefix ?? "") + field.key, "inib")
-                ),
-                field.type,
-                linesNumber
-              )) ?? {}
-            )) {
-              if (!RETURN[index]) RETURN[index] = {};
-              RETURN[index][field.key] = value
-                ? await this.get(field.key, value as number, options)
-                : this.getDefaultValue(field);
+                  (
+                    (
+                      field as FieldDefault &
+                        (FieldArrayType | FieldArrayArrayType)
+                    ).children as Schema
+                  ).filter(
+                    (children) =>
+                      children.type === "array" &&
+                      Utils.isArrayOfObjects(children.children)
+                  ),
+                  linesNumber,
+                  (prefix ?? "") + field.key + "."
+                )) ?? {}
+              ).forEach(([index, item]) => {
+                if (Utils.isObject(item)) {
+                  if (!RETURN[index]) RETURN[index] = {};
+                  if (!RETURN[index][field.key]) RETURN[index][field.key] = [];
+                  for (const child_field of (
+                    (
+                      field as FieldDefault &
+                        (FieldArrayType | FieldArrayArrayType)
+                    ).children as Schema
+                  ).filter(
+                    (children) =>
+                      children.type === "array" &&
+                      Utils.isArrayOfObjects(children.children)
+                  )) {
+                    if (Utils.isObject(item[child_field.key])) {
+                      Object.entries(item[child_field.key]).forEach(
+                        ([key, value]) => {
+                          for (let _i = 0; _i < value.length; _i++) {
+                            if (!RETURN[index][field.key][_i])
+                              RETURN[index][field.key][_i] = {};
+                            if (!RETURN[index][field.key][_i][child_field.key])
+                              RETURN[index][field.key][_i][child_field.key] =
+                                [];
+                            value[_i].forEach((_element, _index) => {
+                              if (
+                                !RETURN[index][field.key][_i][child_field.key][
+                                  _index
+                                ]
+                              )
+                                RETURN[index][field.key][_i][child_field.key][
+                                  _index
+                                ] = {};
+                              RETURN[index][field.key][_i][child_field.key][
+                                _index
+                              ][key] = _element;
+                            });
+                          }
+                        }
+                      );
+                    }
+                  }
+                }
+              });
+              (
+                field as FieldDefault & (FieldArrayType | FieldArrayArrayType)
+              ).children = (
+                (field as FieldDefault & (FieldArrayType | FieldArrayArrayType))
+                  .children as Schema
+              ).filter(
+                (children) =>
+                  children.type !== "array" ||
+                  !Utils.isArrayOfObjects(children.children)
+              );
             }
-          } else if (Utils.isArrayOfObjects(field.children)) {
             Object.entries(
               (await getItemsFromSchema(
                 path,
-                field.children as Schema,
+                (field as FieldDefault & (FieldArrayType | FieldArrayArrayType))
+                  .children as Schema,
                 linesNumber,
-                (prefix ?? "") +
-                  field.key +
-                  (field.type === "array" ? ".*." : ".")
+                (prefix ?? "") + field.key + "."
               )) ?? {}
             ).forEach(([index, item]) => {
               if (!RETURN[index]) RETURN[index] = {};
-              RETURN[index][field.key] = item;
+              if (Utils.isObject(item)) {
+                if (!Object.values(item).every((i) => i === null)) {
+                  if (RETURN[index][field.key])
+                    Object.entries(item).forEach(([key, value], _index) => {
+                      RETURN[index][field.key] = RETURN[index][field.key].map(
+                        (_obj, _i) => ({ ..._obj, [key]: value[_i] })
+                      );
+                    });
+                  else if (Object.values(item).every(Utils.isArrayOfArrays))
+                    RETURN[index][field.key] = item;
+                  else {
+                    RETURN[index][field.key] = [];
+                    Object.entries(item).forEach(([key, value]) => {
+                      for (let _i = 0; _i < value.length; _i++) {
+                        if (!RETURN[index][field.key][_i])
+                          RETURN[index][field.key][_i] = {};
+                        RETURN[index][field.key][_i][key] = value[_i];
+                      }
+                    });
+                  }
+                } else RETURN[index][field.key] = null;
+              } else RETURN[index][field.key] = item;
             });
+          } else if (
+            (field as FieldDefault & (FieldArrayType | FieldArrayArrayType))
+              .children === "table" ||
+            (Array.isArray(
+              (field as FieldDefault & (FieldArrayType | FieldArrayArrayType))
+                .children
+            ) &&
+              (
+                (field as FieldDefault & (FieldArrayType | FieldArrayArrayType))
+                  .children as FieldType[]
+              ).includes("table"))
+          ) {
+            if (options.columns)
+              options.columns = (options.columns as string[])
+                .filter((column) => column.includes(`${field.key}.`))
+                .map((column) => column.replace(`${field.key}.`, ""));
+            const [items, total_lines] = await File.get(
+              join(path, (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] = item
+                ? await this.get(field.key, item as number, options)
+                : this.getDefaultValue(field);
+            }
+          } else if (
+            await File.isExists(
+              join(path, (prefix ?? "") + field.key + ".inib")
+            )
+          ) {
+            const [items, total_lines] = await File.get(
+              join(path, (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") {
+          for (const [index, item] of Object.entries(
+            (await getItemsFromSchema(
+              path,
+              field.children as Schema,
+              linesNumber,
+              (prefix ?? "") + field.key + "."
+            )) ?? {}
+          )) {
+            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 (
-            existsSync(join(this.databasePath, field.key)) &&
-            existsSync(
-              join(
-                path,
-                File.encodeFileName((prefix ?? "") + field.key, "inib")
-              )
-            )
+            (await File.isExists(
+              join(this.folder, this.database, field.key)
+            )) &&
+            (await File.isExists(
+              join(path, (prefix ?? "") + field.key + ".inib")
+            ))
           ) {
             if (options.columns)
               options.columns = (options.columns as string[])
                 .filter(
                   (column) =>
                     column.includes(`${field.key}.`) &&
-                    !column.includes(`${field.key}.*.`)
+                    !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")
-                ),
-                "number",
-                linesNumber
-              )) ?? {}
-            )) {
+            const [items, total_lines] = await File.get(
+              join(path, (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);
             }
           }
         } else if (
-          existsSync(
-            join(path, File.encodeFileName((prefix ?? "") + field.key, "inib"))
-          )
+          await File.isExists(join(path, (prefix ?? "") + field.key + ".inib"))
         ) {
-          Object.entries(
-            (await File.get(
-              join(
-                path,
-                File.encodeFileName((prefix ?? "") + field.key, "inib")
-              ),
-              field.type,
-              linesNumber
-            )) ?? {}
-          ).forEach(([index, item]) => {
+          const [items, total_lines] = await File.get(
+            join(path, (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;
@@ -769,7 +964,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 },
@@ -780,20 +975,22 @@ export default class Inibase {
           )
         )
       );
-    } else if (this.isValidID(where) || Utils.isNumber(where)) {
+    } else if (Utils.isValidID(where) || Utils.isNumber(where)) {
       let Ids = where as string | number | (string | number)[];
       if (!Array.isArray(Ids)) Ids = [Ids];
-      const idFilePath = join(this.databasePath, tableName, "id.inib");
-      if (!existsSync(idFilePath)) throw this.throwError("NO_ITEMS", tableName);
       const [lineNumbers, countItems] = await File.search(
         idFilePath,
-        "number",
         "[]",
         Utils.isNumber(Ids)
-          ? Ids.map((id) => parseFloat(id as string))
-          : Ids.map((id) => this.decodeID(id as string)),
+          ? Ids.map((id) => Number(id as string))
+          : Ids.map((id) => UtilsServer.decodeID(id as string, this.salt)),
         undefined,
-        Ids.length
+        "number",
+        undefined,
+        Ids.length,
+        0,
+        false,
+        this.salt
       );
       if (!lineNumbers || !Object.keys(lineNumbers).length)
         throw this.throwError(
@@ -802,16 +999,17 @@ 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)
         )) ?? {}
       );
       if (RETURN.length && !Array.isArray(where)) RETURN = RETURN[0];
-    } else if (typeof where === "object" && !Array.isArray(where)) {
+    } else if (Utils.isObject(where)) {
       // Criteria
       const FormatObjectCriteriaValue = (
-        value: string
+        value: string,
+        isParentArray: boolean = false
       ): [ComparisonOperator, string | number | boolean | null] => {
         switch (value[0]) {
           case ">":
@@ -838,10 +1036,19 @@ export default class Inibase {
                   value.slice(3) as string | number,
                 ]
               : [
-                  value.slice(0, 1) as ComparisonOperator,
+                  (value.slice(0, 1) + "=") as ComparisonOperator,
                   value.slice(1) as string | number,
                 ];
           case "=":
+            return isParentArray
+              ? [
+                  value.slice(0, 1) as ComparisonOperator,
+                  value.slice(1) as string | number,
+                ]
+              : [
+                  value.slice(0, 1) as ComparisonOperator,
+                  (value.slice(1) + ",") as string,
+                ];
           case "*":
             return [
               value.slice(0, 1) as ComparisonOperator,
@@ -855,11 +1062,14 @@ export default class Inibase {
       const applyCriteria = async (
         criteria?: Criteria,
         allTrue?: boolean
-      ): Promise<Data | null> => {
-        let RETURN: Data = {};
+      ): Promise<Record<number, Data> | null> => {
+        let RETURN: Record<number, Data> = {};
         if (!criteria) return null;
-        if (criteria.and && typeof criteria.and === "object") {
-          const searchResult = await applyCriteria(criteria.and, true);
+        if (criteria.and && Utils.isObject(criteria.and)) {
+          const searchResult = await applyCriteria(
+            criteria.and as Criteria,
+            true
+          );
           if (searchResult) {
             RETURN = Utils.deepMerge(
               RETURN,
@@ -875,160 +1085,159 @@ export default class Inibase {
           } else return null;
         }
 
-        if (criteria.or && typeof criteria.or === "object") {
-          const searchResult = await applyCriteria(criteria.or);
+        if (criteria.or && Utils.isObject(criteria.or)) {
+          const searchResult = await applyCriteria(
+            criteria.or as Criteria,
+            false
+          );
           delete criteria.or;
           if (searchResult) RETURN = Utils.deepMerge(RETURN, searchResult);
         }
 
-        let index = -1;
-        for (const [key, value] of Object.entries(criteria)) {
-          index++;
-          if (
-            allTrue &&
-            index > 0 &&
-            (!Object.keys(RETURN).length ||
-              Object.values(RETURN).every(
-                (item) => Object.keys(item).length >= index
-              ))
-          )
-            break;
-          let searchOperator:
-              | ComparisonOperator
-              | ComparisonOperator[]
-              | undefined = undefined,
-            searchComparedAtValue:
-              | string
-              | number
-              | boolean
-              | null
-              | (string | number | boolean | null)[]
-              | undefined = undefined,
-            searchLogicalOperator: "and" | "or" | undefined = undefined;
-          if (typeof value === "object") {
-            if (value?.or && Array.isArray(value.or)) {
-              const searchCriteria = value.or
-                .map(
-                  (
-                    single_or
-                  ): [ComparisonOperator, string | number | boolean | null] =>
-                    typeof single_or === "string"
-                      ? FormatObjectCriteriaValue(single_or)
-                      : ["=", single_or]
+        if (Object.keys(criteria).length > 0) {
+          if (allTrue === undefined) allTrue = true;
+
+          let index = -1;
+          for (const [key, value] of Object.entries(criteria)) {
+            const field = this.getField(key, schema as Schema) as Field;
+            index++;
+            let searchOperator:
+                | ComparisonOperator
+                | ComparisonOperator[]
+                | undefined = undefined,
+              searchComparedAtValue:
+                | string
+                | number
+                | boolean
+                | null
+                | (string | number | boolean | null)[]
+                | undefined = undefined,
+              searchLogicalOperator: "and" | "or" | undefined = undefined;
+            if (Utils.isObject(value)) {
+              if (
+                (value as Criteria)?.or &&
+                Array.isArray((value as Criteria).or)
+              ) {
+                const searchCriteria = (
+                  (value as Criteria).or as (string | number | boolean)[]
                 )
-                .filter((a) => a) as [ComparisonOperator, string | number][];
-              if (searchCriteria.length > 0) {
-                searchOperator = searchCriteria.map(
-                  (single_or) => single_or[0]
-                );
-                searchComparedAtValue = searchCriteria.map(
-                  (single_or) => single_or[1]
-                );
-                searchLogicalOperator = "or";
+                  .map(
+                    (
+                      single_or
+                    ): [ComparisonOperator, string | number | boolean | null] =>
+                      typeof single_or === "string"
+                        ? FormatObjectCriteriaValue(single_or)
+                        : ["=", single_or]
+                  )
+                  .filter((a) => a) as [ComparisonOperator, string | number][];
+                if (searchCriteria.length > 0) {
+                  searchOperator = searchCriteria.map(
+                    (single_or) => single_or[0]
+                  );
+                  searchComparedAtValue = searchCriteria.map(
+                    (single_or) => single_or[1]
+                  );
+                  searchLogicalOperator = "or";
+                }
+                delete (value as Criteria).or;
               }
-              delete value.or;
-            }
-            if (value?.and && Array.isArray(value.and)) {
-              const searchCriteria = value.and
+              if (
+                (value as Criteria)?.and &&
+                Array.isArray((value as Criteria).and)
+              ) {
+                const searchCriteria = (
+                  (value as Criteria).and as (string | number | boolean)[]
+                )
+                  .map(
+                    (
+                      single_and
+                    ): [ComparisonOperator, string | number | boolean | null] =>
+                      typeof single_and === "string"
+                        ? FormatObjectCriteriaValue(single_and)
+                        : ["=", single_and]
+                  )
+                  .filter((a) => a) as [ComparisonOperator, string | number][];
+                if (searchCriteria.length > 0) {
+                  searchOperator = searchCriteria.map(
+                    (single_and) => single_and[0]
+                  );
+                  searchComparedAtValue = searchCriteria.map(
+                    (single_and) => single_and[1]
+                  );
+                  searchLogicalOperator = "and";
+                }
+                delete (value as Criteria).and;
+              }
+            } else if (Array.isArray(value)) {
+              const searchCriteria = value
                 .map(
                   (
-                    single_and
+                    single
                   ): [ComparisonOperator, string | number | boolean | null] =>
-                    typeof single_and === "string"
-                      ? FormatObjectCriteriaValue(single_and)
-                      : ["=", single_and]
+                    typeof single === "string"
+                      ? FormatObjectCriteriaValue(single)
+                      : ["=", single]
                 )
                 .filter((a) => a) as [ComparisonOperator, string | number][];
               if (searchCriteria.length > 0) {
-                searchOperator = searchCriteria.map(
-                  (single_and) => single_and[0]
-                );
+                searchOperator = searchCriteria.map((single) => single[0]);
                 searchComparedAtValue = searchCriteria.map(
-                  (single_and) => single_and[1]
+                  (single) => single[1]
                 );
                 searchLogicalOperator = "and";
               }
-              delete value.and;
-            }
-          } else if (Array.isArray(value)) {
-            const searchCriteria = value
-              .map(
-                (
-                  single
-                ): [ComparisonOperator, string | number | boolean | null] =>
-                  typeof single === "string"
-                    ? FormatObjectCriteriaValue(single)
-                    : ["=", single]
-              )
-              .filter((a) => a) as [ComparisonOperator, string | number][];
-            if (searchCriteria.length > 0) {
-              searchOperator = searchCriteria.map((single) => single[0]);
-              searchComparedAtValue = searchCriteria.map((single) => single[1]);
-              searchLogicalOperator = "and";
-            }
-          } else if (typeof value === "string") {
-            const ComparisonOperatorValue = FormatObjectCriteriaValue(value);
-            if (ComparisonOperatorValue) {
-              searchOperator = ComparisonOperatorValue[0];
-              searchComparedAtValue = ComparisonOperatorValue[1];
+            } else if (typeof value === "string") {
+              const ComparisonOperatorValue = FormatObjectCriteriaValue(value);
+              if (ComparisonOperatorValue) {
+                searchOperator = ComparisonOperatorValue[0];
+                searchComparedAtValue = ComparisonOperatorValue[1];
+              }
+            } else {
+              searchOperator = "=";
+              searchComparedAtValue = value as number | boolean;
             }
-          } else {
-            searchOperator = "=";
-            searchComparedAtValue = value;
-          }
-          if (searchOperator && searchComparedAtValue) {
-            const [searchResult, totlaItems] = await File.search(
-              join(
-                this.databasePath,
-                tableName,
-                File.encodeFileName(key, "inib")
-              ),
-              this.getField(key, schema as Schema)?.type ?? "string",
+            const [searchResult, total_lines] = await File.search(
+              join(this.folder, this.database, tableName, key + ".inib"),
               searchOperator,
               searchComparedAtValue,
               searchLogicalOperator,
+              field?.type,
+              (field as any)?.children,
               options.per_page,
               (options.page as number) - 1 * (options.per_page as number) + 1,
-              true
+              true,
+              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 = {};
+              RETURN = Object.fromEntries(
+                Object.entries(RETURN).filter(
+                  ([_index, item]) => Object.keys(item).length > index
+                )
+              );
+              if (!Object.keys(RETURN).length) RETURN = {};
             }
           }
         }
-        return Object.keys(RETURN).length > 0 ? RETURN : null;
+
+        return Object.keys(RETURN).length ? RETURN : null;
       };
 
-      RETURN = await applyCriteria(where);
+      RETURN = await applyCriteria(where as Criteria);
       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) => 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)
               ),
@@ -1039,132 +1248,162 @@ export default class Inibase {
         );
       }
     }
-    return RETURN
-      ? Utils.isArrayOfObjects(RETURN)
-        ? (RETURN as Data[]).map((data: Data) => {
-            data.id = this.encodeID(data.id as number);
-            return data;
-          })
-        : {
-            ...(RETURN as Data),
-            id: this.encodeID((RETURN as Data).id as number),
-          }
-      : null;
+    if (
+      !RETURN ||
+      (Utils.isObject(RETURN) && !Object.keys(RETURN).length) ||
+      (Array.isArray(RETURN) && !RETURN.length)
+    )
+      return null;
+
+    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(
     tableName: string,
-    data: Data | Data[]
-  ): Promise<Data | Data[] | null> {
-    const schema = this.getTableSchema(tableName);
+    data: Data | Data[],
+    options: Options = {
+      page: 1,
+      per_page: 15,
+    },
+    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");
-    let last_id = existsSync(idFilePath)
-      ? Number(Object.values(await File.get(idFilePath, "number", -1))[0])
+    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", undefined, this.salt))[0]
+          )[0]
+        )
       : 0;
     if (Utils.isArrayOfObjects(data))
       (data as Data[]).forEach((single_data, index) => {
         if (!RETURN) RETURN = [];
-        RETURN[index] = (({ id, updated_at, created_at, ...rest }) => rest)(
-          single_data
-        );
-        RETURN[index].id = ++last_id;
-        RETURN[index].created_at = new Date();
+        RETURN[index] = (({ id, updated_at, created_at, ...rest }) => ({
+          id: ++last_id,
+          ...rest,
+          created_at: new Date(),
+        }))(single_data);
       });
-    else {
-      RETURN = (({ id, updated_at, created_at, ...rest }) => rest)(
-        data as Data
-      );
-      RETURN.id = ++last_id;
-      RETURN.created_at = new Date();
-    }
+    else
+      RETURN = (({ id, updated_at, created_at, ...rest }) => ({
+        id: ++last_id,
+        ...rest,
+        created_at: new Date(),
+      }))(data as Data);
     if (!RETURN) throw this.throwError("NO_DATA");
-    this.validateData(RETURN, schema);
+
     RETURN = this.formatData(RETURN, schema);
     const pathesContents = this.joinPathesContents(
-      join(this.databasePath, tableName),
+      join(this.folder, this.database, tableName),
       RETURN
     );
-    for (const [path, content] of Object.entries(pathesContents))
-      appendFileSync(
+    for await (const [path, content] of Object.entries(pathesContents))
+      await appendFile(
         path,
-        (Array.isArray(content) ? content.join("\n") : content ?? "") + "\n",
-        "utf8"
+        (Array.isArray(content) ? content.join("\n") : content ?? "") + "\n"
+      );
+
+    if (returnPostedData)
+      return this.get(
+        tableName,
+        Utils.isArrayOfObjects(RETURN)
+          ? RETURN.map((data: Data) => data.id)
+          : ((RETURN as Data).id as number),
+        options
       );
-    return Utils.isArrayOfObjects(RETURN)
-      ? RETURN.map((data: Data) => {
-          data.id = this.encodeID(data.id as number);
-          return data;
-        })
-      : { ...RETURN, id: this.encodeID((RETURN as Data).id as number) };
   }
 
   public async put(
     tableName: string,
     data: Data | Data[],
-    where?: number | string | (number | string)[] | Criteria
-  ) {
-    const schema = this.getTableSchema(tableName);
+    where?: number | string | (number | string)[] | Criteria,
+    options: Options = {
+      page: 1,
+      per_page: 15,
+    },
+    returnPostedData: boolean = true
+  ): Promise<Data | Data[] | null | void> {
+    const schema = await this.getTableSchema(tableName);
     if (!schema) throw this.throwError("NO_SCHEMA", tableName);
-    this.validateData(data, schema, true);
+    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);
     if (!where) {
       if (Utils.isArrayOfObjects(data)) {
         if (
           !(data as Data[]).every(
-            (item) => item.hasOwnProperty("id") && this.isValidID(item.id)
+            (item) => item.hasOwnProperty("id") && Utils.isValidID(item.id)
           )
         )
           throw this.throwError("INVALID_ID");
-        await this.put(
+        return this.put(
           tableName,
           data,
           (data as Data[]).map((item) => item.id)
         );
       } else if (data.hasOwnProperty("id")) {
-        if (!this.isValidID((data as Data).id))
+        if (!Utils.isValidID((data as Data).id))
           throw this.throwError("INVALID_ID", (data as Data).id);
-        await this.put(
+        return this.put(
           tableName,
           data,
-          this.decodeID((data as Data).id as string)
+          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) => ({
-                ...item,
+                ...(({ id, ...restOfData }) => restOfData)(item),
                 updated_at: new Date(),
               }))
-            : { ...data, updated_at: new Date() }
+            : {
+                ...(({ id, ...restOfData }) => restOfData)(data as Data),
+                updated_at: new Date(),
+              }
         );
         for (const [path, content] of Object.entries(pathesContents))
           await File.replace(path, content);
+        if (returnPostedData) return this.get(tableName, where, options);
       }
-    } else if (this.isValidID(where)) {
+    } else if (Utils.isValidID(where)) {
       let Ids = where as string | string[];
       if (!Array.isArray(Ids)) Ids = [Ids];
-      const idFilePath = join(this.databasePath, tableName, "id.inib");
-      if (!existsSync(idFilePath)) throw this.throwError("NO_ITEMS", tableName);
       const [lineNumbers, countItems] = await File.search(
         idFilePath,
-        "number",
         "[]",
-        Ids.map((id) => this.decodeID(id)),
+        Ids.map((id) => UtilsServer.decodeID(id, this.salt)),
+        undefined,
+        "number",
         undefined,
-        Ids.length
+        Ids.length,
+        0,
+        false,
+        this.salt
       );
       if (!lineNumbers || !Object.keys(lineNumbers).length)
         throw this.throwError("INVALID_ID");
-      await this.put(tableName, data, Object.keys(lineNumbers).map(Number));
+      return this.put(tableName, data, Object.keys(lineNumbers).map(Number));
     } else if (Utils.isNumber(where)) {
-      // where in this case, is the line(s) number(s) and not id(s)
+      // "where" in this case, is the line(s) number(s) and not id(s)
       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,
@@ -1185,60 +1424,87 @@ export default class Inibase {
       );
       for (const [path, content] of Object.entries(pathesContents))
         await File.replace(path, content);
+      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)
         throw this.throwError("NO_ITEMS", tableName);
-      await this.put(tableName, data, lineNumbers);
-    } else throw this.throwError("PARAMETERS", tableName);
+      return this.put(tableName, data, lineNumbers);
+    } else throw this.throwError("INVALID_PARAMETERS", tableName);
   }
 
   public async delete(
     tableName: string,
-    where?: number | string | (number | string)[] | Criteria
-  ) {
-    const schema = this.getTableSchema(tableName);
+    where?: number | string | (number | string)[] | Criteria,
+    _id?: string | string[]
+  ): Promise<string | string[] | null> {
+    const schema = await this.getTableSchema(tableName);
     if (!schema) throw this.throwError("NO_SCHEMA", tableName);
+    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 = readdirSync(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"
         ))
-          unlinkSync(join(this.databasePath, tableName, file));
+          await unlink(join(this.folder, this.database, tableName, file));
       }
-    } else if (this.isValidID(where)) {
+      return "*";
+    } else if (Utils.isValidID(where)) {
       let Ids = where as string | string[];
       if (!Array.isArray(Ids)) Ids = [Ids];
-      const idFilePath = join(this.databasePath, tableName, "id.inib");
-      if (!existsSync(idFilePath)) throw this.throwError("NO_ITEMS", tableName);
       const [lineNumbers, countItems] = await File.search(
         idFilePath,
-        "number",
         "[]",
-        Ids.map((id) => this.decodeID(id)),
+        Ids.map((id) => UtilsServer.decodeID(id, this.salt)),
+        undefined,
+        "number",
         undefined,
-        Ids.length
+        Ids.length,
+        0,
+        false,
+        this.salt
       );
       if (!lineNumbers || !Object.keys(lineNumbers).length)
         throw this.throwError("INVALID_ID");
-      await this.delete(tableName, Object.keys(lineNumbers).map(Number));
+      return this.delete(
+        tableName,
+        Object.keys(lineNumbers).map(Number),
+        where as string | string[]
+      );
     } else if (Utils.isNumber(where)) {
-      const files = readdirSync(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"
+        if (!_id)
+          _id = Object.values(
+            (
+              await File.get(
+                join(this.folder, this.database, tableName, "id.inib"),
+                where as number | number[],
+                "number",
+                undefined,
+                this.salt
+              )
+            )[0]
+          ).map((id) => UtilsServer.encodeID(Number(id), this.salt));
+        for (const file of files.filter(
+          (fileName: string) =>
+            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;
       }
     } else if (typeof where === "object" && !Array.isArray(where)) {
       const lineNumbers = this.get(tableName, where, undefined, true);
       if (!lineNumbers || !Array.isArray(lineNumbers) || !lineNumbers.length)
         throw this.throwError("NO_ITEMS", tableName);
-      await this.delete(tableName, lineNumbers);
-    } else throw this.throwError("PARAMETERS", tableName);
+      return this.delete(tableName, lineNumbers);
+    } else throw this.throwError("INVALID_PARAMETERS", tableName);
+    return null;
   }
 }