inibase 1.0.0-rc.10 → 1.0.0-rc.12

package/index.ts

@@ -3,7 +3,6 @@ import {
   rename,
   readFile,
   writeFile,
-  appendFile,
   mkdir,
   readdir,
 } from "node:fs/promises";
@@ -11,14 +10,13 @@ import { join, parse } from "node:path";
 import { scryptSync } from "node:crypto";
 import File from "./file";
 import Utils from "./utils";
-import UtilsServer from "./utils.server";
 
-export type Data = {
+export interface Data {
   id?: number | string;
   [key: string]: any;
-  created_at?: Date;
-  updated_at?: Date;
-};
+  createdAt?: Date;
+  updatedAt?: Date;
+}
 
 export type FieldType =
   | "string"
@@ -74,6 +72,7 @@ export interface Options {
   page?: number;
   per_page?: number;
   columns?: string[] | string;
+  order?: Record<string, "asc" | "desc">;
 }
 
 export type ComparisonOperator =
@@ -94,12 +93,11 @@ type pageInfo = {
 } & Options;
 
 export type Criteria =
-  | {
+  | ({
       [logic in "and" | "or"]?: Criteria | (string | number | boolean | null)[];
-    }
-  | {
+    } & {
       [key: string]: string | number | boolean | Criteria;
-    }
+    })
   | null;
 
 declare global {
@@ -119,7 +117,7 @@ export default class Inibase {
   public pageInfo: pageInfo;
   private cache: Map<string, string>;
   private totalItems: Record<string, number>;
-  private salt: Buffer;
+  public salt: Buffer;
 
   constructor(database: string, mainFolder: string = ".") {
     this.database = database;
@@ -128,7 +126,11 @@ export default class Inibase {
     this.cache = new Map<string, any>();
     this.totalItems = {};
     this.pageInfo = { page: 1, per_page: 15 };
-    this.salt = scryptSync(database, "salt", 32);
+    this.salt = scryptSync(
+      process.env.INIBASE_SECRET ?? "inibase",
+      (process.env.INIBASE_SECRET ?? "inibase") + "_salt",
+      32
+    );
   }
 
   private throwError(
@@ -177,100 +179,46 @@ export default class Inibase {
     return new Error(errorMessage);
   }
 
-  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 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
-              ? 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 as any).children
-              ? Utils.isArrayOfObjects((field as any).children)
-                ? encodeSchema((field as any).children as Schema) ?? null
-                : (field as any).children
-              : null
-          );
-          index++;
-        }
-        return RETURN;
-      },
-      addIdToSchema = (schema: Schema, oldIndex: number = 0) =>
-        schema.map((field) => {
-          if (
-            (field.type === "array" || field.type === "object") &&
-            Utils.isArrayOfObjects(field.children)
-          ) {
-            if (!field.id) {
-              oldIndex++;
-              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 = UtilsServer.decodeID(field.id as string, this.salt);
-          else {
-            oldIndex++;
-            field = {
-              ...field,
-              id: UtilsServer.encodeID(oldIndex, this.salt),
-            };
-          }
-          return field;
-        });
-
+    const decodeIdFromSchema = (schema: Schema) =>
+      schema.map((field) => {
+        if (field.children && Utils.isArrayOfObjects(field.children))
+          field.children = decodeIdFromSchema(field.children as Schema);
+        if (!Utils.isNumber(field.id))
+          field.id = Utils.decodeID(field.id, this.salt);
+        return field;
+      });
     // remove id from schema
     schema = schema.filter(
-      (field) => !["id", "created_at", "updated_at"].includes(field.key)
+      ({ key }) => !["id", "createdAt", "updatedAt"].includes(key)
+    );
+    schema = Utils.addIdToSchema(
+      schema,
+      Utils.findLastIdNumber(schema, this.salt),
+      this.salt
     );
-    schema = addIdToSchema(schema, this.findLastIdNumber(schema));
     const TablePath = join(this.folder, this.database, tableName),
-      TableSchemaPath = join(TablePath, "schema");
+      TableSchemaPath = join(TablePath, "schema.json");
     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 = "") => {
+      const schemaToIdsPath = (schema: Schema, prefix = "") => {
           let RETURN: any = {};
           for (const field of schema)
             if (field.children && Utils.isArrayOfObjects(field.children)) {
               Utils.deepMerge(
                 RETURN,
                 schemaToIdsPath(
-                  field.children,
+                  field.children as Schema,
                   (prefix ?? "") + field.key + "."
                 )
               );
             } else if (Utils.isValidID(field.id))
-              RETURN[UtilsServer.decodeID(field.id, this.salt)] =
+              RETURN[Utils.decodeID(field.id, this.salt)] =
                 (prefix ?? "") + field.key + ".inib";
 
           return RETURN;
@@ -286,63 +234,44 @@ export default class Inibase {
     }
 
     await writeFile(
-      join(TablePath, "schema"),
-      JSON.stringify(encodeSchema(schema))
+      join(TablePath, "schema.json"),
+      JSON.stringify(decodeIdFromSchema(schema))
     );
   }
 
   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: UtilsServer.encodeID(field[0], this.salt),
-                  key: field[1],
-                  required: field[2],
-                  type: field[3],
-                  children: field[4]
-                    ? Array.isArray(field[4])
-                      ? decodeSchema(field[4])
-                      : field[4]
-                    : null,
-                }).filter(([_, v]) => v != null)
-              )
-        );
-      },
-      TableSchemaPath = join(this.folder, this.database, tableName, "schema");
+    const TableSchemaPath = join(
+      this.folder,
+      this.database,
+      tableName,
+      "schema.json"
+    );
     if (!(await File.isExists(TableSchemaPath))) return undefined;
-    if (!this.cache.has(TableSchemaPath)) {
-      const TableSchemaPathContent = await readFile(TableSchemaPath, {
-        encoding: "utf8",
-      });
-      this.cache.set(
-        TableSchemaPath,
-        TableSchemaPathContent
-          ? decodeSchema(JSON.parse(TableSchemaPathContent.toString()))
-          : ""
-      );
-    }
-    const schema = this.cache.get(TableSchemaPath) as unknown as Schema,
-      lastIdNumber = this.findLastIdNumber(schema);
+
+    if (!this.cache.has(TableSchemaPath))
+      this.cache.set(TableSchemaPath, await readFile(TableSchemaPath, "utf8"));
+
+    if (!this.cache.get(TableSchemaPath)) return undefined;
+    const schema = JSON.parse(this.cache.get(TableSchemaPath)),
+      lastIdNumber = Utils.findLastIdNumber(schema, this.salt);
+
     return [
       {
-        id: UtilsServer.encodeID(0, this.salt),
+        id: Utils.encodeID(0, this.salt),
         key: "id",
         type: "id",
         required: true,
       },
-      ...schema,
+      ...Utils.addIdToSchema(schema, lastIdNumber, this.salt),
       {
-        id: UtilsServer.encodeID(lastIdNumber + 1, this.salt),
-        key: "created_at",
+        id: Utils.encodeID(lastIdNumber + 1, this.salt),
+        key: "createdAt",
         type: "date",
         required: true,
       },
       {
-        id: UtilsServer.encodeID(lastIdNumber + 2, this.salt),
-        key: "updated_at",
+        id: Utils.encodeID(lastIdNumber + 2, this.salt),
+        key: "updatedAt",
         type: "date",
         required: false,
       },
@@ -394,81 +323,76 @@ export default class Inibase {
       for (const single_data of data as Data[])
         this.validateData(single_data, schema, skipRequiredField);
     else if (Utils.isObject(data)) {
-      for (const field of schema) {
+      for (const { key, type, required, children } of schema) {
+        if (!data.hasOwnProperty(key) && required && !skipRequiredField)
+          throw this.throwError("FIELD_REQUIRED", key);
         if (
-          !data.hasOwnProperty(field.key) &&
-          field.required &&
-          !skipRequiredField
-        )
-          throw this.throwError("FIELD_REQUIRED", field.key);
-        if (
-          data.hasOwnProperty(field.key) &&
+          data.hasOwnProperty(key) &&
           !Utils.validateFieldType(
-            data[field.key],
-            field.type,
-            (field as any)?.children &&
-              !Utils.isArrayOfObjects((field as any)?.children)
-              ? (field as any)?.children
-              : undefined
+            data[key],
+            type,
+            children && !Utils.isArrayOfObjects(children) ? children : undefined
           )
         )
-          throw this.throwError("INVALID_TYPE", field.key);
+          throw this.throwError("INVALID_TYPE", key);
         if (
-          (field.type === "array" || field.type === "object") &&
-          field.children &&
-          Utils.isArrayOfObjects(field.children)
+          (type === "array" || type === "object") &&
+          children &&
+          Utils.isArrayOfObjects(children)
         )
-          this.validateData(
-            data[field.key],
-            field.children as Schema,
-            skipRequiredField
-          );
+          this.validateData(data[key], children as Schema, skipRequiredField);
       }
     }
   }
 
-  public formatData(
-    data: Data | Data[],
+  public formatData<dataType extends Data | Data[]>(
+    data: dataType,
     schema: Schema,
     formatOnlyAvailiableKeys?: boolean
-  ): Data | Data[] {
+  ): dataType extends Data ? Data : Data[] {
+    this.validateData(data, schema, formatOnlyAvailiableKeys);
+
     const formatField = (
-      value: any,
+      value: Data | number | string | (number | string | Data)[],
       field: Field
     ): Data | Data[] | number | string => {
       if (Array.isArray(field.type))
         field.type = Utils.detectFieldType(value, field.type);
       switch (field.type) {
         case "array":
+          if (!Array.isArray(value)) value = [value];
           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 (Array.isArray(value)) {
+                if (Utils.isArrayOfObjects(value)) {
                   if (
                     value.every(
-                      (item: any) =>
+                      (item: any): item is Data =>
                         item.hasOwnProperty("id") &&
                         (Utils.isValidID(item.id) || Utils.isNumber(item.id))
                     )
                   )
-                    value.map((item: any) =>
+                    value.map((item) =>
                       Utils.isNumber(item.id)
                         ? Number(item.id)
-                        : UtilsServer.decodeID(item.id, this.salt)
+                        : Utils.decodeID(item.id, this.salt)
                     );
-                } else if (Utils.isValidID(value) || Utils.isNumber(value))
-                  return value.map((item: number | string) =>
+                } else if (
+                  (value as (number | string)[]).every(Utils.isValidID) ||
+                  (value as (number | string)[]).every(Utils.isNumber)
+                )
+                  return (value as (number | string)[]).map((item) =>
                     Utils.isNumber(item)
-                      ? Number(item as string)
-                      : UtilsServer.decodeID(item as string, this.salt)
+                      ? Number(item)
+                      : Utils.decodeID(item, this.salt)
                   );
               } else if (Utils.isValidID(value))
-                return [UtilsServer.decodeID(value, this.salt)];
+                return [Utils.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,
+              value as Data[],
               field.children as Schema,
               formatOnlyAvailiableKeys
             );
@@ -478,41 +402,46 @@ export default class Inibase {
         case "object":
           if (Utils.isArrayOfObjects(field.children))
             return this.formatData(
-              value,
-              field.children,
+              value as Data,
+              field.children as Schema,
               formatOnlyAvailiableKeys
             );
           break;
         case "table":
+          if (Array.isArray(value)) value = value[0];
           if (Utils.isObject(value)) {
             if (
-              value.hasOwnProperty("id") &&
-              (Utils.isValidID(value.id) || Utils.isNumber(value))
+              (value as Data).hasOwnProperty("id") &&
+              (Utils.isValidID((value as Data).id) ||
+                Utils.isNumber((value as Data).id))
             )
-              return Utils.isNumber(value.id)
-                ? Number(value.id)
-                : UtilsServer.decodeID(value.id, this.salt);
+              return Utils.isNumber((value as Data).id)
+                ? Number((value as Data).id)
+                : Utils.decodeID((value as Data).id as string, this.salt);
           } else if (Utils.isValidID(value) || Utils.isNumber(value))
             return Utils.isNumber(value)
               ? Number(value)
-              : UtilsServer.decodeID(value, this.salt);
+              : Utils.decodeID(value, this.salt);
           break;
         case "password":
-          return value.length === 161 ? value : UtilsServer.hashPassword(value);
+          if (Array.isArray(value)) value = value[0];
+          return typeof value === "string" && value.length === 161
+            ? value
+            : Utils.hashPassword(String(value));
         case "number":
+          if (Array.isArray(value)) value = value[0];
           return Utils.isNumber(value) ? Number(value) : null;
         case "id":
+          if (Array.isArray(value)) value = value[0];
           return Utils.isNumber(value)
             ? value
-            : UtilsServer.decodeID(value, this.salt);
+            : Utils.decodeID(value as string, 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, formatOnlyAvailiableKeys)
@@ -556,7 +485,9 @@ export default class Inibase {
           : [];
       case "object":
         return Utils.combineObjects(
-          field.children.map((f) => ({ [f.key]: this.getDefaultValue(f) }))
+          field.children.map((f: Field) => ({
+            [f.key]: this.getDefaultValue(f),
+          }))
         );
       case "boolean":
         return false;
@@ -589,33 +520,26 @@ export default class Inibase {
         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)) {
-              Object.assign(
-                RETURN,
-                CombineData(
-                  combineObjectsToArray(value),
-                  (prefix ?? "") + key + "."
-                )
-              );
-            } else if (
-              Utils.isArrayOfArrays(value) &&
-              value.every(Utils.isArrayOfObjects)
-            )
-              Object.assign(
-                RETURN,
-                CombineData(
-                  combineObjectsToArray(value.map(combineObjectsToArray)),
-                  (prefix ?? "") + key + "."
-                )
-              );
-            else
-              RETURN[(prefix ?? "") + key] = File.encode(value) as
-                | boolean
-                | number
-                | string
-                | null;
-          } else
+          else 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(
+                combineObjectsToArray(value.map(combineObjectsToArray)),
+                (prefix ?? "") + key + "."
+              )
+            );
+          else
             RETURN[(prefix ?? "") + key] = File.encode(value) as
               | boolean
               | number
@@ -635,15 +559,18 @@ export default class Inibase {
     return addPathToKeys(CombineData(data), mainPath);
   }
 
-  public async get(
+  public async get<O extends boolean = false, N extends boolean = false>(
     tableName: string,
     where?: string | number | (string | number)[] | Criteria,
     options: Options = {
       page: 1,
       per_page: 15,
     },
-    onlyLinesNumbers?: boolean
-  ): Promise<Data | Data[] | number[] | null> {
+    onlyOne?: O,
+    onlyLinesNumbers?: N
+  ): Promise<
+    (N extends true ? number[] : O extends true ? Data : Data[]) | null
+  > {
     if (!options.columns) options.columns = [];
     else if (!Array.isArray(options.columns))
       options.columns = [options.columns];
@@ -762,19 +689,21 @@ export default class Inibase {
                             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
-                                ]
-                              )
+                            value[_i].forEach(
+                              (_element: any, _index: string | number) => {
+                                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
-                                ] = {};
-                              RETURN[index][field.key][_i][child_field.key][
-                                _index
-                              ][key] = _element;
-                            });
+                                ][key] = _element;
+                              }
+                            );
                           }
                         }
                       );
@@ -793,6 +722,7 @@ export default class Inibase {
                   !Utils.isArrayOfObjects(children.children)
               );
             }
+
             Object.entries(
               (await getItemsFromSchema(
                 path,
@@ -808,7 +738,10 @@ export default class Inibase {
                   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] })
+                        (_obj: any, _i: string | number) => ({
+                          ..._obj,
+                          [key]: value[_i],
+                        })
                       );
                     });
                   else if (Object.values(item).every(Utils.isArrayOfArrays))
@@ -960,15 +893,20 @@ export default class Inibase {
           )
         )
       );
-    } else if (Utils.isValidID(where) || Utils.isNumber(where)) {
+    } else if (
+      (Array.isArray(where) &&
+        (where.every(Utils.isValidID) || where.every(Utils.isNumber))) ||
+      Utils.isValidID(where) ||
+      Utils.isNumber(where)
+    ) {
       let Ids = where as string | number | (string | number)[];
       if (!Array.isArray(Ids)) Ids = [Ids];
       const [lineNumbers, countItems] = await File.search(
         idFilePath,
         "[]",
-        Utils.isNumber(Ids)
-          ? Ids.map((id) => Number(id as string))
-          : Ids.map((id) => UtilsServer.decodeID(id as string, this.salt)),
+        Ids.map((id) =>
+          Utils.isNumber(id) ? Number(id) : Utils.decodeID(id, this.salt)
+        ),
         undefined,
         "number",
         undefined,
@@ -982,6 +920,9 @@ export default class Inibase {
           "INVALID_ID",
           where as number | string | (number | string)[]
         );
+
+      if (onlyLinesNumbers) return Object.keys(lineNumbers).map(Number) as any;
+
       RETURN = Object.values(
         (await getItemsFromSchema(
           join(this.folder, this.database, tableName),
@@ -1215,20 +1156,20 @@ export default class Inibase {
 
       RETURN = await applyCriteria(where as Criteria);
       if (RETURN) {
-        if (onlyLinesNumbers) return Object.keys(RETURN).map(Number);
+        if (onlyLinesNumbers) return Object.keys(RETURN).map(Number) as any;
         const alreadyExistsColumns = Object.keys(Object.values(RETURN)[0]).map(
           (key) => parse(key).name
         );
         RETURN = Object.values(
           Utils.deepMerge(
+            RETURN,
             await getItemsFromSchema(
               join(this.folder, this.database, tableName),
               schema.filter(
                 (field) => !alreadyExistsColumns.includes(field.key)
               ),
               Object.keys(RETURN).map(Number)
-            ),
-            RETURN
+            )
           )
         );
       }
@@ -1250,55 +1191,54 @@ export default class Inibase {
       total_pages: Math.ceil(greatestTotalItems / options.per_page),
       total: greatestTotalItems,
     };
-    return RETURN;
+    return onlyOne ? RETURN[0] : RETURN;
   }
 
-  public async post(
+  public async post<DataType extends Data | Data[]>(
     tableName: string,
-    data: Data | Data[],
+    data: DataType,
     options: Options = {
       page: 1,
       per_page: 15,
     },
     returnPostedData: boolean = true
-  ): Promise<Data | Data[] | null | void> {
+  ): Promise<
+    DataType extends Data ? Data | null | void : 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.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;
+
+    let [last_line_number, last_id] = (await File.isExists(idFilePath))
+      ? (Object.entries(
+          (await File.get(idFilePath, -1, "number", undefined, this.salt))[0]
+        )[0] as [number, number] | undefined) ?? [1, 0]
+      : [1, 0];
     if (Utils.isArrayOfObjects(data))
-      (data as Data[]).forEach((single_data, index) => {
+      data.forEach((single_data: any, index: string | number) => {
         if (!RETURN) RETURN = [];
-        RETURN[index] = (({ id, updated_at, created_at, ...rest }) => ({
+        RETURN[index] = (({ id, updatedAt, createdAt, ...rest }) => ({
           id: ++last_id,
           ...rest,
-          created_at: new Date(),
+          createdAt: new Date(),
         }))(single_data);
       });
     else
-      RETURN = (({ id, updated_at, created_at, ...rest }) => ({
+      RETURN = (({ id, updatedAt, createdAt, ...rest }) => ({
         id: ++last_id,
         ...rest,
-        created_at: new Date(),
+        createdAt: new Date(),
       }))(data as Data);
     if (!RETURN) throw this.throwError("NO_DATA");
+
     RETURN = this.formatData(RETURN, schema);
     const pathesContents = this.joinPathesContents(
       join(this.folder, this.database, tableName),
       RETURN
     );
     for await (const [path, content] of Object.entries(pathesContents))
-      await appendFile(
-        path,
-        (Array.isArray(content) ? content.join("\n") : content ?? "") + "\n"
-      );
+      await File.replace(path, { [last_line_number]: content });
 
     if (returnPostedData)
       return this.get(
@@ -1306,11 +1246,12 @@ export default class Inibase {
         Utils.isArrayOfObjects(RETURN)
           ? RETURN.map((data: Data) => data.id)
           : ((RETURN as Data).id as number),
-        options
+        options,
+        !Utils.isArrayOfObjects(data) // return only one item if data is not array of objects
       );
   }
 
-  public async put(
+  public async put<returnPostedDataType extends boolean = true>(
     tableName: string,
     data: Data | Data[],
     where?: number | string | (number | string)[] | Criteria,
@@ -1318,8 +1259,10 @@ export default class Inibase {
       page: 1,
       per_page: 15,
     },
-    returnPostedData: boolean = true
-  ): Promise<Data | Data[] | null | void> {
+    returnPostedData?: returnPostedDataType
+  ): Promise<
+    (returnPostedDataType extends true ? Data | Data[] : void) | 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");
@@ -1329,15 +1272,15 @@ export default class Inibase {
     if (!where) {
       if (Utils.isArrayOfObjects(data)) {
         if (
-          !(data as Data[]).every(
-            (item) => item.hasOwnProperty("id") && Utils.isValidID(item.id)
+          !data.every(
+            (item: any) => item.hasOwnProperty("id") && Utils.isValidID(item.id)
           )
         )
           throw this.throwError("INVALID_ID");
         return this.put(
           tableName,
           data,
-          (data as Data[]).map((item) => item.id)
+          data.map((item: { id: any }) => item.id)
         );
       } else if (data.hasOwnProperty("id")) {
         if (!Utils.isValidID((data as Data).id))
@@ -1345,72 +1288,90 @@ export default class Inibase {
         return this.put(
           tableName,
           data,
-          UtilsServer.decodeID((data as Data).id as string, this.salt)
+          Utils.decodeID((data as Data).id as string, this.salt)
         );
       } else {
         const pathesContents = this.joinPathesContents(
           join(this.folder, this.database, tableName),
           Utils.isArrayOfObjects(data)
-            ? (data as Data[]).map((item) => ({
+            ? data.map((item: any) => ({
                 ...(({ id, ...restOfData }) => restOfData)(item),
-                updated_at: new Date(),
+                updatedAt: new Date(),
               }))
             : {
                 ...(({ id, ...restOfData }) => restOfData)(data as Data),
-                updated_at: new Date(),
+                updatedAt: new Date(),
               }
         );
-        for (const [path, content] of Object.entries(pathesContents))
+        for await (const [path, content] of Object.entries(pathesContents))
           await File.replace(path, content);
-        if (returnPostedData) return this.get(tableName, where, options);
+
+        if (returnPostedData) return this.get(tableName, where, options) as any;
       }
-    } else if (Utils.isValidID(where)) {
-      let Ids = where as string | string[];
-      if (!Array.isArray(Ids)) Ids = [Ids];
-      const [lineNumbers, countItems] = await File.search(
-        idFilePath,
-        "[]",
-        Ids.map((id) => UtilsServer.decodeID(id, this.salt)),
+    } else if (
+      (Array.isArray(where) &&
+        (where.every(Utils.isValidID) || where.every(Utils.isNumber))) ||
+      Utils.isValidID(where) ||
+      Utils.isNumber(where)
+    ) {
+      if (
+        (Array.isArray(where) && where.every(Utils.isValidID)) ||
+        Utils.isValidID(where)
+      ) {
+        const lineNumbers = await this.get(
+          tableName,
+          where,
+          undefined,
+          undefined,
+          true
+        );
+        return this.put(tableName, data, lineNumbers);
+      } else if (
+        (Array.isArray(where) && where.every(Utils.isNumber)) ||
+        Utils.isNumber(where)
+      ) {
+        // "where" in this case, is the line(s) number(s) and not id(s)
+        const pathesContents = Object.fromEntries(
+          Object.entries(
+            this.joinPathesContents(
+              join(this.folder, this.database, tableName),
+              Utils.isArrayOfObjects(data)
+                ? data.map((item: any) => ({
+                    ...item,
+                    updatedAt: new Date(),
+                  }))
+                : { ...data, updatedAt: new Date() }
+            )
+          ).map(([key, value]) => [
+            key,
+            ([...(Array.isArray(where) ? where : [where])] as number[]).reduce(
+              (obj, key, index) => ({
+                ...obj,
+                [key]: Array.isArray(value) ? value[index] : value,
+              }),
+              {}
+            ),
+          ])
+        );
+        for await (const [path, content] of Object.entries(pathesContents))
+          await File.replace(path, content);
+
+        if (returnPostedData)
+          return this.get(
+            tableName,
+            where,
+            options,
+            !Array.isArray(where)
+          ) as any;
+      }
+    } else if (typeof where === "object") {
+      const lineNumbers = this.get(
+        tableName,
+        where,
         undefined,
-        "number",
         undefined,
-        Ids.length,
-        0,
-        false,
-        this.salt
-      );
-      if (!lineNumbers || !Object.keys(lineNumbers).length)
-        throw this.throwError("INVALID_ID");
-      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)
-      const pathesContents = Object.fromEntries(
-        Object.entries(
-          this.joinPathesContents(
-            join(this.folder, this.database, tableName),
-            Utils.isArrayOfObjects(data)
-              ? (data as Data[]).map((item) => ({
-                  ...item,
-                  updated_at: new Date(),
-                }))
-              : { ...data, updated_at: new Date() }
-          )
-        ).map(([key, value]) => [
-          key,
-          ([...(Array.isArray(where) ? where : [where])] as number[]).reduce(
-            (obj, key, index) => ({
-              ...obj,
-              [key]: Array.isArray(value) ? value[index] : value,
-            }),
-            {}
-          ),
-        ])
+        true
       );
-      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);
       return this.put(tableName, data, lineNumbers);
@@ -1431,64 +1392,196 @@ export default class Inibase {
       const files = await readdir(join(this.folder, this.database, tableName));
       if (files.length) {
         for (const file in files.filter(
-          (fileName: string) => fileName !== "schema"
+          (fileName: string) => fileName !== "schema.json"
         ))
           await unlink(join(this.folder, this.database, tableName, file));
       }
       return "*";
-    } else if (Utils.isValidID(where)) {
-      let Ids = where as string | string[];
-      if (!Array.isArray(Ids)) Ids = [Ids];
-      const [lineNumbers, countItems] = await File.search(
-        idFilePath,
-        "[]",
-        Ids.map((id) => UtilsServer.decodeID(id, this.salt)),
+    } else if (
+      (Array.isArray(where) &&
+        (where.every(Utils.isValidID) || where.every(Utils.isNumber))) ||
+      Utils.isValidID(where) ||
+      Utils.isNumber(where)
+    ) {
+      if (
+        (Array.isArray(where) && where.every(Utils.isValidID)) ||
+        Utils.isValidID(where)
+      ) {
+        const lineNumbers = await this.get(
+          tableName,
+          where,
+          undefined,
+          undefined,
+          true
+        );
+        return this.delete(tableName, lineNumbers, where as string | string[]);
+      } else if (
+        (Array.isArray(where) && where.every(Utils.isNumber)) ||
+        Utils.isNumber(where)
+      ) {
+        // "where" in this case, is the line(s) number(s) and not id(s)
+        const files = await readdir(
+          join(this.folder, this.database, tableName)
+        );
+        if (files.length) {
+          if (!_id)
+            _id = Object.values(
+              (
+                await File.get(
+                  join(this.folder, this.database, tableName, "id.inib"),
+                  where,
+                  "number",
+                  undefined,
+                  this.salt
+                )
+              )[0]
+            ).map((id) => Utils.encodeID(Number(id), this.salt));
+          for (const file of files.filter((fileName: string) =>
+            fileName.endsWith(".inib")
+          ))
+            await File.remove(
+              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,
-        "number",
         undefined,
-        Ids.length,
-        0,
-        false,
-        this.salt
-      );
-      if (!lineNumbers || !Object.keys(lineNumbers).length)
-        throw this.throwError("INVALID_ID");
-      return this.delete(
-        tableName,
-        Object.keys(lineNumbers).map(Number),
-        where as string | string[]
+        true
       );
-    } else if (Utils.isNumber(where)) {
-      const files = await readdir(join(this.folder, this.database, tableName));
-      if (files.length) {
-        if (!_id)
-          _id = Object.values(
-            await File.get(
-              join(this.folder, this.database, tableName, "id.inib"),
-              where as number | number[],
-              "number",
-              undefined,
-              this.salt
-            )
-          )
-            .map(Number)
-            .map((id) => UtilsServer.encodeID(id, this.salt));
-        for (const file of files.filter(
-          (fileName: string) =>
-            fileName.endsWith(".inib") && fileName !== "schema"
-        ))
-          await File.remove(
-            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);
       return this.delete(tableName, lineNumbers);
     } else throw this.throwError("INVALID_PARAMETERS", tableName);
     return null;
   }
+
+  public async sum(
+    tableName: string,
+    columns: string,
+    where?: number | string | (number | string)[] | Criteria
+  ): Promise<number>;
+  public async sum(
+    tableName: string,
+    columns: string[],
+    where?: number | string | (number | string)[] | Criteria
+  ): Promise<Record<string, number>>;
+  public async sum(
+    tableName: string,
+    columns: string | string[],
+    where?: number | string | (number | string)[] | Criteria
+  ): Promise<number | Record<string, number>> {
+    let RETURN: Record<string, number>;
+    const schema = await this.getTableSchema(tableName);
+    if (!schema) throw this.throwError("NO_SCHEMA", tableName);
+    if (
+      !(await File.isExists(
+        join(this.folder, this.database, tableName, "id.inib")
+      ))
+    )
+      throw this.throwError("NO_ITEMS", tableName);
+    if (!Array.isArray(columns)) columns = [columns];
+    for await (const column of columns) {
+      const columnPath = join(
+        this.folder,
+        this.database,
+        tableName,
+        column + ".inib"
+      );
+      if (await File.isExists(columnPath)) {
+        if (where) {
+          const lineNumbers = await this.get(
+            tableName,
+            where,
+            undefined,
+            undefined,
+            true
+          );
+          RETURN[column] = await File.sum(columnPath, lineNumbers);
+        } else RETURN[column] = await File.sum(columnPath);
+      }
+    }
+    return Array.isArray(columns) ? RETURN : Object.values(RETURN)[0];
+  }
+
+  public async max(
+    tableName: string,
+    columns: string | string[],
+    where?: number | string | (number | string)[] | Criteria
+  ) {
+    let RETURN: Record<string, number>;
+    const schema = await this.getTableSchema(tableName);
+    if (!schema) throw this.throwError("NO_SCHEMA", tableName);
+    if (
+      !(await File.isExists(
+        join(this.folder, this.database, tableName, "id.inib")
+      ))
+    )
+      throw this.throwError("NO_ITEMS", tableName);
+    if (!Array.isArray(columns)) columns = [columns];
+    for await (const column of columns) {
+      const columnPath = join(
+        this.folder,
+        this.database,
+        tableName,
+        column + ".inib"
+      );
+      if (await File.isExists(columnPath)) {
+        if (where) {
+          const lineNumbers = await this.get(
+            tableName,
+            where,
+            undefined,
+            undefined,
+            true
+          );
+          RETURN[column] = await File.max(columnPath, lineNumbers);
+        } else RETURN[column] = await File.max(columnPath);
+      }
+    }
+    return RETURN;
+  }
+
+  public async min(
+    tableName: string,
+    columns: string | string[],
+    where?: number | string | (number | string)[] | Criteria
+  ) {
+    let RETURN: Record<string, number>;
+    const schema = await this.getTableSchema(tableName);
+    if (!schema) throw this.throwError("NO_SCHEMA", tableName);
+    if (
+      !(await File.isExists(
+        join(this.folder, this.database, tableName, "id.inib")
+      ))
+    )
+      throw this.throwError("NO_ITEMS", tableName);
+    if (!Array.isArray(columns)) columns = [columns];
+    for await (const column of columns) {
+      const columnPath = join(
+        this.folder,
+        this.database,
+        tableName,
+        column + ".inib"
+      );
+      if (await File.isExists(columnPath)) {
+        if (where) {
+          const lineNumbers = await this.get(
+            tableName,
+            where,
+            undefined,
+            undefined,
+            true
+          );
+          RETURN[column] = await File.min(columnPath, lineNumbers);
+        } else RETURN[column] = await File.min(columnPath);
+      }
+    }
+    return RETURN;
+  }
 }