inibase 1.0.0-rc.5 → 1.0.0-rc.6

package/index.ts

@@ -1,16 +1,16 @@
 import {
-  readFileSync,
-  writeFileSync,
-  mkdirSync,
-  existsSync,
-  appendFileSync,
-  readdirSync,
-  unlinkSync,
-  renameSync,
-} from "fs";
-import { join, parse } from "path";
+  unlink,
+  rename,
+  readFile,
+  writeFile,
+  appendFile,
+  mkdir,
+  readdir,
+} from "node:fs/promises";
+import { join, parse } from "node:path";
 import Utils from "./utils";
 import File from "./file";
+import { scryptSync } from "node:crypto";
 
 export type Data = {
   id?: number | string;
@@ -29,11 +29,15 @@ export type FieldType =
   | "table"
   | "object"
   | "array"
-  | "password";
+  | "password"
+  | "html"
+  | "ip"
+  | "id";
 type FieldDefault = {
   id?: string | number | null | undefined;
   key: string;
   required?: boolean;
+  children?: any;
 };
 type FieldStringType = {
   type: Exclude<FieldType, "array" | "object">;
@@ -54,7 +58,7 @@ type FieldObjectType = {
   children: Schema;
 };
 // if "type" is array, make "array" at first place, and "number" & "string" at last place of the array
-type Field = FieldDefault &
+export type Field = FieldDefault &
   (
     | FieldStringType
     | FieldStringArrayType
@@ -113,6 +117,7 @@ export default class Inibase {
   public cache: Map<string, string>;
   public pageInfoArray: Record<string, Record<string, number>>;
   public pageInfo: pageInfo;
+  private salt: Buffer;
 
   constructor(databaseName: string, mainFolder: string = ".") {
     this.database = databaseName;
@@ -120,6 +125,7 @@ export default class Inibase {
     this.cache = new Map<string, any>();
     this.pageInfoArray = {};
     this.pageInfo = { page: 1, per_page: 15 };
+    this.salt = scryptSync(this.databasePath, "salt", 32);
   }
 
   private throwError(
@@ -168,25 +174,40 @@ export default class Inibase {
     return new Error(errorMessage);
   }
 
-  public setTableSchema(tableName: string, schema: Schema): void {
+  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 Utils.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
-              ? Utils.decodeID(field.id as string, this.databasePath)
-              : null
+            field.id ? Utils.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++;
@@ -203,44 +224,33 @@ export default class Inibase {
               oldIndex++;
               field = {
                 ...field,
-                id: Utils.encodeID(oldIndex, this.databasePath),
+                id: Utils.encodeID(oldIndex, this.salt),
               };
-            } else
-              oldIndex = Utils.decodeID(field.id as string, this.databasePath);
+            } else oldIndex = Utils.decodeID(field.id as string, this.salt);
             field.children = addIdToSchema(field.children as Schema, oldIndex);
             oldIndex += field.children.length;
           } else if (field.id)
-            oldIndex = Utils.decodeID(field.id as string, this.databasePath);
+            oldIndex = Utils.decodeID(field.id as string, this.salt);
           else {
             oldIndex++;
             field = {
               ...field,
-              id: Utils.encodeID(oldIndex, this.databasePath),
+              id: Utils.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 if (lastField.id && Utils.isValidID(lastField.id))
-            return Utils.decodeID(lastField.id as string, this.databasePath);
-        }
-        return 0;
-      };
+        });
 
     // remove id from schema
-    schema = schema.filter((field) => field.key !== "id");
-    schema = addIdToSchema(schema, findLastIdNumber(schema));
+    schema = schema.filter(
+      (field) => !["id", "created_at", "updated_at"].includes(field.key)
+    );
+    schema = addIdToSchema(schema, this.findLastIdNumber(schema));
     const TablePath = join(this.databasePath, tableName),
       TableSchemaPath = join(TablePath, "schema.inib");
-    if (!existsSync(TablePath)) mkdirSync(TablePath, { recursive: true });
-    if (existsSync(TableSchemaPath)) {
+    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 = {};
@@ -256,35 +266,37 @@ export default class Inibase {
                 )
               );
             } else if (Utils.isValidID(field.id))
-              RETURN[Utils.decodeID(field.id, this.databasePath)] =
-                File.encodeFileName((prefix ?? "") + field.key, "inib");
+              RETURN[Utils.decodeID(field.id, this.salt)] = File.encodeFileName(
+                (prefix ?? "") + field.key,
+                "inib"
+              );
 
           return RETURN;
         },
         replaceOldPathes = Utils.findChangedProperties(
-          schemaToIdsPath(this.getTableSchema(tableName)),
+          schemaToIdsPath(await this.getTableSchema(tableName)),
           schemaToIdsPath(schema)
         );
       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(
+    await writeFile(
       join(TablePath, "schema.inib"),
       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: Utils.encodeID(field[0], this.databasePath),
+                  id: Utils.encodeID(field[0], this.salt),
                   key: field[1],
                   required: field[2],
                   type: field[3],
@@ -298,9 +310,11 @@ export default class Inibase {
         );
       },
       TableSchemaPath = join(this.databasePath, tableName, "schema.inib");
-    if (!existsSync(TableSchemaPath)) return undefined;
+    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
@@ -308,14 +322,28 @@ export default class Inibase {
           : ""
       );
     }
+    const schema = this.cache.get(TableSchemaPath) as unknown as Schema,
+      lastIdNumber = this.findLastIdNumber(schema);
     return [
       {
-        id: Utils.encodeID(0, this.databasePath),
+        id: Utils.encodeID(0, this.salt),
         key: "id",
         type: "number",
         required: true,
       },
-      ...(this.cache.get(TableSchemaPath) as unknown as Schema),
+      ...schema,
+      {
+        id: Utils.encodeID(lastIdNumber, this.salt),
+        key: "created_at",
+        type: "date",
+        required: true,
+      },
+      {
+        id: Utils.encodeID(lastIdNumber + 1, this.salt),
+        key: "updated_at",
+        type: "date",
+        required: false,
+      },
     ];
   }
 
@@ -381,16 +409,21 @@ export default class Inibase {
 
       switch (fieldType) {
         case "string":
-          // TO-DO: and not email, url, password ...
-          return !Utils.isNumber(value);
+          return Utils.isString(value);
         case "password":
-          return !Utils.isNumber(value) && Utils.isPassword(value);
+          return (
+            Utils.isNumber(value) ||
+            Utils.isString(value) ||
+            Utils.isPassword(value)
+          );
         case "number":
           return Utils.isNumber(value);
+        case "html":
+          return Utils.isHTML(value);
+        case "ip":
+          return Utils.isIP(value);
         case "boolean":
-          return (
-            typeof value === "boolean" || value === "true" || value === "false"
-          );
+          return Utils.isBoolean(value);
         case "date":
           return Utils.isDate(value);
         case "object":
@@ -421,10 +454,13 @@ export default class Inibase {
                 Utils.isNumber((value as Data).id))
             );
           else return Utils.isNumber(value) || Utils.isValidID(value);
+        case "id":
+          return Utils.isNumber(value) || Utils.isValidID(value);
         default:
           return false;
       }
     };
+
     if (Utils.isArrayOfObjects(data))
       for (const single_data of data as Data[])
         this.validateData(single_data, schema, skipRequiredField);
@@ -437,6 +473,7 @@ export default class Inibase {
         )
           throw this.throwError("FIELD_REQUIRED", field.key);
         if (
+          data.hasOwnProperty(field.key) &&
           !validateFieldType(
             data[field.key],
             field.type,
@@ -472,7 +509,6 @@ export default class Inibase {
     ): 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") {
@@ -489,16 +525,16 @@ export default class Inibase {
                     value.map((item: any) =>
                       Utils.isNumber(item.id)
                         ? Number(item.id)
-                        : Utils.decodeID(item.id, this.databasePath)
+                        : Utils.decodeID(item.id, this.salt)
                     );
                 } else if (Utils.isValidID(value) || Utils.isNumber(value))
                   return value.map((item: number | string) =>
                     Utils.isNumber(item)
                       ? Number(item as string)
-                      : Utils.decodeID(item as string, this.databasePath)
+                      : Utils.decodeID(item as string, this.salt)
                   );
               } else if (Utils.isValidID(value))
-                return [Utils.decodeID(value, this.databasePath)];
+                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))
@@ -526,21 +562,28 @@ export default class Inibase {
             )
               return Utils.isNumber(value.id)
                 ? Number(value.id)
-                : Utils.decodeID(value.id, this.databasePath);
+                : Utils.decodeID(value.id, this.salt);
           } else if (Utils.isValidID(value) || Utils.isNumber(value))
             return Utils.isNumber(value)
               ? Number(value)
-              : Utils.decodeID(value, this.databasePath);
+              : Utils.decodeID(value, this.salt);
           break;
         case "password":
           return value.length === 161 ? value : Utils.hashPassword(value);
         case "number":
           return Utils.isNumber(value) ? Number(value) : null;
+        case "id":
+          return Utils.isNumber(value)
+            ? Utils.encodeID(value, this.salt)
+            : value;
         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)
@@ -549,7 +592,7 @@ export default class Inibase {
       let RETURN: Data = {};
       for (const field of schema) {
         if (!data.hasOwnProperty(field.key)) {
-          if (formatOnlyAvailiableKeys) continue;
+          if (formatOnlyAvailiableKeys || !field.required) continue;
           RETURN[field.key] = this.getDefaultValue(field);
           continue;
         }
@@ -676,16 +719,15 @@ export default class Inibase {
     if (!options.columns) options.columns = [];
     else if (!Array.isArray(options.columns))
       options.columns = [options.columns];
-    else if (
-      options.columns.length &&
-      !(options.columns as string[]).includes("id")
-    )
+    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.databasePath, tableName, "id.inib");
+    if (!(await File.isExists(idFilePath))) return null;
     const filterSchemaByColumns = (schema: Schema, columns: string[]): Schema =>
       schema
         .map((field) => {
@@ -699,12 +741,8 @@ export default class Inibase {
             Utils.isArrayOfObjects(field.children) &&
             columns.filter(
               (column) =>
-                column.startsWith(
-                  field.key + (field.type === "array" ? ".*." : ".")
-                ) ||
-                column.startsWith(
-                  "!" + field.key + (field.type === "array" ? ".*." : ".")
-                )
+                column.startsWith(field.key + ".") ||
+                column.startsWith("!" + field.key + ".")
             ).length
           ) {
             field.children = filterSchemaByColumns(
@@ -712,19 +750,10 @@ export default class Inibase {
               columns
                 .filter(
                   (column) =>
-                    column.startsWith(
-                      field.key + (field.type === "array" ? ".*." : ".")
-                    ) ||
-                    column.startsWith(
-                      "!" + field.key + (field.type === "array" ? ".*." : ".")
-                    )
-                )
-                .map((column) =>
-                  column.replace(
-                    field.key + (field.type === "array" ? ".*." : "."),
-                    ""
-                  )
+                    column.startsWith(field.key + ".") ||
+                    column.startsWith("!" + field.key + ".")
                 )
+                .map((column) => column.replace(field.key + ".", ""))
             );
             return field;
           }
@@ -851,7 +880,7 @@ 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[_index] })
+                        (_obj, _i) => ({ ..._obj, [key]: value[_i] })
                       );
                     });
                   else if (Object.values(item).every(Utils.isArrayOfArrays))
@@ -903,7 +932,7 @@ export default class Inibase {
                 : this.getDefaultValue(field);
             }
           } else if (
-            existsSync(
+            await File.isExists(
               join(
                 path,
                 File.encodeFileName((prefix ?? "") + field.key, "inib")
@@ -942,13 +971,13 @@ export default class Inibase {
           });
         } else if (field.type === "table") {
           if (
-            existsSync(join(this.databasePath, field.key)) &&
-            existsSync(
+            (await File.isExists(join(this.databasePath, field.key))) &&
+            (await File.isExists(
               join(
                 path,
                 File.encodeFileName((prefix ?? "") + field.key, "inib")
               )
-            )
+            ))
           ) {
             if (options.columns)
               options.columns = (options.columns as string[])
@@ -975,7 +1004,7 @@ export default class Inibase {
             }
           }
         } else if (
-          existsSync(
+          await File.isExists(
             join(path, File.encodeFileName((prefix ?? "") + field.key, "inib"))
           )
         )
@@ -1014,18 +1043,19 @@ export default class Inibase {
     } 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,
         "[]",
         Utils.isNumber(Ids)
           ? Ids.map((id) => Number(id as string))
-          : Ids.map((id) => Utils.decodeID(id as string, this.databasePath)),
+          : Ids.map((id) => Utils.decodeID(id as string, this.salt)),
         undefined,
         "number",
         undefined,
-        Ids.length
+        Ids.length,
+        0,
+        false,
+        this.databasePath
       );
       if (!lineNumbers || !Object.keys(lineNumbers).length)
         throw this.throwError(
@@ -1240,7 +1270,8 @@ export default class Inibase {
               (field as any)?.children,
               options.per_page,
               (options.page as number) - 1 * (options.per_page as number) + 1,
-              true
+              true,
+              this.databasePath
             );
             if (searchResult) {
               RETURN = Utils.deepMerge(RETURN, searchResult);
@@ -1306,12 +1337,12 @@ export default class Inibase {
       return null;
     return Utils.isArrayOfObjects(RETURN)
       ? (RETURN as Data[]).map((data: Data) => {
-          data.id = Utils.encodeID(data.id as number, this.databasePath);
+          data.id = Utils.encodeID(data.id as number, this.salt);
           return data;
         })
       : {
           ...(RETURN as Data),
-          id: Utils.encodeID((RETURN as Data).id as number, this.databasePath),
+          id: Utils.encodeID((RETURN as Data).id as number, this.salt),
         };
   }
 
@@ -1323,41 +1354,38 @@ export default class Inibase {
       per_page: 15,
     }
   ): Promise<Data | Data[] | null> {
-    const schema = this.getTableSchema(tableName);
+    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)
+    let last_id = (await File.isExists(idFilePath))
       ? Number(Object.values(await File.get(idFilePath, -1, "number"))[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),
       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"
       );
 
     return this.get(
@@ -1378,9 +1406,11 @@ export default class Inibase {
       per_page: 15,
     }
   ): Promise<Data | Data[] | null> {
-    const schema = this.getTableSchema(tableName);
+    const schema = await this.getTableSchema(tableName);
     if (!schema) throw this.throwError("NO_SCHEMA", tableName);
-    this.validateData(data, schema, true);
+    const idFilePath = join(this.databasePath, 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)) {
@@ -1401,7 +1431,7 @@ export default class Inibase {
         return this.put(
           tableName,
           data,
-          Utils.decodeID((data as Data).id as string, this.databasePath)
+          Utils.decodeID((data as Data).id as string, this.salt)
         );
       } else {
         const pathesContents = this.joinPathesContents(
@@ -1423,16 +1453,17 @@ export default class Inibase {
     } 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,
         "[]",
-        Ids.map((id) => Utils.decodeID(id, this.databasePath)),
+        Ids.map((id) => Utils.decodeID(id, this.salt)),
         undefined,
         "number",
         undefined,
-        Ids.length
+        Ids.length,
+        0,
+        false,
+        this.databasePath
       );
       if (!lineNumbers || !Object.keys(lineNumbers).length)
         throw this.throwError("INVALID_ID");
@@ -1476,31 +1507,35 @@ export default class Inibase {
     tableName: string,
     where?: number | string | (number | string)[] | Criteria,
     _id?: string | string[]
-  ): Promise<string | string[]> {
-    const schema = this.getTableSchema(tableName);
+  ): Promise<string | string[] | null> {
+    const schema = await this.getTableSchema(tableName);
     if (!schema) throw this.throwError("NO_SCHEMA", tableName);
+    const idFilePath = join(this.databasePath, tableName, "id.inib");
+    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.databasePath, tableName));
       if (files.length) {
         for (const file in files.filter(
           (fileName: string) => fileName !== "schema.inib"
         ))
-          unlinkSync(join(this.databasePath, tableName, file));
+          await unlink(join(this.databasePath, tableName, file));
       }
       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,
         "[]",
-        Ids.map((id) => Utils.decodeID(id, this.databasePath)),
+        Ids.map((id) => Utils.decodeID(id, this.salt)),
         undefined,
         "number",
         undefined,
-        Ids.length
+        Ids.length,
+        0,
+        false,
+        this.databasePath
       );
       if (!lineNumbers || !Object.keys(lineNumbers).length)
         throw this.throwError("INVALID_ID");
@@ -1510,7 +1545,7 @@ export default class Inibase {
         where as string | string[]
       );
     } else if (Utils.isNumber(where)) {
-      const files = readdirSync(join(this.databasePath, tableName));
+      const files = await readdir(join(this.databasePath, tableName));
       if (files.length) {
         if (!_id)
           _id = Object.values(
@@ -1521,9 +1556,10 @@ export default class Inibase {
             )
           )
             .map(Number)
-            .map((id) => Utils.encodeID(id, this.databasePath));
-        for (const file in files.filter(
-          (fileName: string) => fileName !== "schema.inib"
+            .map((id) => Utils.encodeID(id, this.salt));
+        for (const file of files.filter(
+          (fileName: string) =>
+            fileName.endsWith(".inib") && fileName !== "schema.inib"
         ))
           await File.remove(
             join(this.databasePath, tableName, file),
@@ -1537,5 +1573,6 @@ export default class Inibase {
         throw this.throwError("NO_ITEMS", tableName);
       return this.delete(tableName, lineNumbers);
     } else throw this.throwError("INVALID_PARAMETERS", tableName);
+    return null;
   }
 }