inibase 1.0.0-rc.19 → 1.0.0-rc.21

package/README.md

@@ -57,6 +57,19 @@ Become a sponsor and have your company logo here 👉 [GitHub Sponsors](https://
 
 To semplify the idea, each database has tables, each table has columns, each column will be stored in a seperated file. When POSTing new data, it will be appended to each columns file as new line. When GETing data, the file will be readed line-by-line so it can handle large data (without consuming a lot of resources)
 
+## Benchmark
+```js
+Bulk
+            ┌─────────┬─────────┬─────────┐
+            │ 10      │ 100     │ 1000    │
+  ┌─────────┼─────────┼─────────┼─────────┤
+  │ POST    │ '23 ms' │ '20 ms' │ '83 ms' │
+  │ GET     │ '12 ms' │ '16 ms' │ '45 ms' │
+  │ PUT     │ '6 ms'  │ '4 ms'  │ '11 ms' │
+  │ DELETE  │ '18 ms' │ '21 ms' │ '27 ms' │
+  └─────────┴─────────┴─────────┴─────────┘
+```
+
 ## Examples
 
 <details>

package/dist/file.js

@@ -118,73 +118,85 @@ export const decode = (input, fieldType, fieldChildrenType, secretKey) => {
         : input, fieldType, fieldChildrenType, secretKey);
 };
 export const get = async (filePath, lineNumbers, fieldType, fieldChildrenType, secretKey) => {
-    const fileHandle = await open(filePath, "r"), rl = doesSupportReadLines()
-        ? fileHandle.readLines({ autoClose: false })
-        : createInterface({
-            input: fileHandle.createReadStream({ autoClose: false }),
-            crlfDelay: Infinity,
-        });
-    let lines = new Map(), lineCount = 0;
-    if (!lineNumbers) {
-        for await (const line of rl)
-            lineCount++,
+    let fileHandle;
+    try {
+        fileHandle = await open(filePath, "r");
+        const rl = doesSupportReadLines()
+            ? fileHandle.readLines()
+            : createInterface({
+                input: fileHandle.createReadStream(),
+                crlfDelay: Infinity,
+            });
+        let lines = new Map(), lineCount = 0;
+        if (!lineNumbers) {
+            for await (const line of rl)
+                lineCount++,
+                    lines.set(lineCount, decode(line, fieldType, fieldChildrenType, secretKey));
+        }
+        else if (lineNumbers === -1) {
+            let lastLine;
+            for await (const line of rl)
+                lineCount++, (lastLine = line);
+            if (lastLine)
+                lines.set(lineCount, decode(lastLine, fieldType, fieldChildrenType, secretKey));
+        }
+        else {
+            let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+            for await (const line of rl) {
+                lineCount++;
+                if (!lineNumbersArray.has(lineCount))
+                    continue;
                 lines.set(lineCount, decode(line, fieldType, fieldChildrenType, secretKey));
-    }
-    else if (lineNumbers === -1) {
-        let lastLine;
-        for await (const line of rl)
-            lineCount++, (lastLine = line);
-        if (lastLine)
-            lines.set(lineCount, decode(lastLine, fieldType, fieldChildrenType, secretKey));
-    }
-    else {
-        let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-        for await (const line of rl) {
-            lineCount++;
-            if (!lineNumbersArray.has(lineCount))
-                continue;
-            lines.set(lineCount, decode(line, fieldType, fieldChildrenType, secretKey));
-            lineNumbersArray.delete(lineCount);
-            if (!lineNumbersArray.size)
-                break;
+                lineNumbersArray.delete(lineCount);
+                if (!lineNumbersArray.size)
+                    break;
+            }
         }
+        return [lines.size ? Object.fromEntries(lines) : null, lineCount];
+    }
+    finally {
+        await fileHandle?.close();
     }
-    await fileHandle.close();
-    return [lines.size ? Object.fromEntries(lines) : null, lineCount];
 };
 export const replace = async (filePath, replacements) => {
     if (await isExists(filePath)) {
-        const fileHandle = await open(filePath, "r"), rl = doesSupportReadLines()
-            ? fileHandle.readLines({ autoClose: false })
-            : createInterface({
-                input: fileHandle.createReadStream({ autoClose: false }),
-                crlfDelay: Infinity,
-            }), fileTempPath = `${filePath.replace(".inib", "")}-${Date.now()}.tmp`, fileTempHandle = await open(fileTempPath, "w+"), writeStream = fileTempHandle.createWriteStream({ autoClose: false });
-        if (typeof replacements === "object" && !Array.isArray(replacements)) {
-            if (!(replacements instanceof Map))
-                replacements = new Map(Object.entries(replacements));
-            let lineCount = 0;
-            for await (const line of rl) {
-                lineCount++;
-                writeStream.write((replacements.has(lineCount.toString())
-                    ? replacements.get(lineCount.toString())
-                    : line) + "\n");
-            }
-            const newLinesNumbers = new Set([...replacements.keys()].filter((num) => num > lineCount));
-            if (newLinesNumbers.size) {
-                if (Math.min(...newLinesNumbers) - lineCount - 1 > 1)
-                    writeStream.write("\n".repeat(Math.min(...newLinesNumbers) - lineCount - 1));
-                for (const newLineNumber of newLinesNumbers)
-                    writeStream.write(replacements.get(newLineNumber.toString()) + "\n");
+        const fileTempPath = `${filePath.replace(".inib", "")}-${Date.now()}.tmp`;
+        let fileHandle, fileTempHandle, lineCount = 0;
+        try {
+            fileHandle = await open(filePath, "r");
+            fileTempHandle = await open(fileTempPath, "w+");
+            const rl = doesSupportReadLines()
+                ? fileHandle.readLines()
+                : createInterface({
+                    input: fileHandle.createReadStream(),
+                    crlfDelay: Infinity,
+                }), writeStream = fileTempHandle.createWriteStream();
+            if (typeof replacements === "object" && !Array.isArray(replacements)) {
+                if (!(replacements instanceof Map))
+                    replacements = new Map(Object.entries(replacements));
+                for await (const line of rl) {
+                    lineCount++;
+                    writeStream.write((replacements.has(lineCount.toString())
+                        ? replacements.get(lineCount.toString())
+                        : line) + "\n");
+                }
+                const newLinesNumbers = new Set([...replacements.keys()].filter((num) => num > lineCount));
+                if (newLinesNumbers.size) {
+                    if (Math.min(...newLinesNumbers) - lineCount - 1 > 1)
+                        writeStream.write("\n".repeat(Math.min(...newLinesNumbers) - lineCount - 1));
+                    for (const newLineNumber of newLinesNumbers)
+                        writeStream.write(replacements.get(newLineNumber.toString()) + "\n");
+                }
             }
+            else
+                for await (const _line of rl)
+                    writeStream.write(replacements + "\n");
+            await rename(fileTempPath, filePath);
+        }
+        finally {
+            await fileHandle?.close();
+            await fileTempHandle?.close();
         }
-        else
-            for await (const _line of rl)
-                writeStream.write(replacements + "\n");
-        // writeStream.end(async () => await rename(fileTempPath, filePath));
-        await fileHandle.close();
-        await fileTempHandle.close();
-        await rename(fileTempPath, filePath);
     }
     else if (typeof replacements === "object" && !Array.isArray(replacements)) {
         if (!(replacements instanceof Map))
@@ -197,61 +209,78 @@ export const replace = async (filePath, replacements) => {
     }
 };
 export const append = async (filePath, data, startsAt = 1) => {
-    const doesFileExists = await isExists(filePath);
-    const fileHandle = await open(filePath, "a"), writeStream = fileHandle.createWriteStream({ autoClose: false });
-    if (doesFileExists) {
-        const currentNumberOfLines = await count(filePath);
-        if (startsAt - currentNumberOfLines - 1 > 0)
-            writeStream.write("\n".repeat(startsAt - currentNumberOfLines - 1));
-        if (Array.isArray(data)) {
-            for (const input of data)
-                writeStream.write(input + "\n");
+    let fileHandle;
+    try {
+        fileHandle = await open(filePath, "a");
+        const doesFileExists = await isExists(filePath);
+        const writeStream = fileHandle.createWriteStream();
+        if (doesFileExists) {
+            const currentNumberOfLines = await count(filePath);
+            if (startsAt - currentNumberOfLines - 1 > 0)
+                writeStream.write("\n".repeat(startsAt - currentNumberOfLines - 1));
+            if (Array.isArray(data)) {
+                for (const input of data)
+                    writeStream.write(input + "\n");
+            }
+            else
+                writeStream.write(data + "\n");
         }
-        else
-            writeStream.write(data + "\n");
-    }
-    else {
-        if (startsAt - 1 > 0)
-            writeStream.write("\n".repeat(startsAt - 1));
-        if (Array.isArray(data)) {
-            for (const input of data)
-                writeStream.write(input + "\n");
+        else {
+            if (startsAt - 1 > 0)
+                writeStream.write("\n".repeat(startsAt - 1));
+            if (Array.isArray(data)) {
+                for (const input of data)
+                    writeStream.write(input + "\n");
+            }
+            else
+                writeStream.write(data + "\n");
         }
-        else
-            writeStream.write(data + "\n");
     }
-    await fileHandle.close();
+    finally {
+        await fileHandle?.close();
+    }
 };
 export const remove = async (filePath, linesToDelete) => {
-    let lineCount = 0;
-    const linesToDeleteArray = new Set(Array.isArray(linesToDelete) ? linesToDelete : [linesToDelete]), fileHandle = await open(filePath, "r"), rl = doesSupportReadLines()
-        ? fileHandle.readLines({ autoClose: false })
-        : createInterface({
-            input: fileHandle.createReadStream({ autoClose: false }),
-            crlfDelay: Infinity,
-        }), fileTempPath = `${filePath.replace(".inib", "")}-${Date.now()}.tmp`, fileTempHandle = await open(fileTempPath, "w+"), writeStream = fileTempHandle.createWriteStream({ autoClose: false });
-    for await (const line of rl) {
-        lineCount++;
-        if (!linesToDeleteArray.has(lineCount))
-            writeStream.write(`${line}\n`);
+    const fileTempPath = `${filePath.replace(".inib", "")}-${Date.now()}.tmp`;
+    let fileHandle, fileTempHandle, lineCount = 0;
+    try {
+        fileHandle = await open(filePath, "r");
+        fileTempHandle = await open(fileTempPath, "w+");
+        const linesToDeleteArray = new Set(Array.isArray(linesToDelete) ? linesToDelete : [linesToDelete]), rl = doesSupportReadLines()
+            ? fileHandle.readLines()
+            : createInterface({
+                input: fileHandle.createReadStream(),
+                crlfDelay: Infinity,
+            }), writeStream = fileTempHandle.createWriteStream();
+        for await (const line of rl) {
+            lineCount++;
+            if (!linesToDeleteArray.has(lineCount))
+                writeStream.write(`${line}\n`);
+        }
+        await rename(fileTempPath, filePath);
+    }
+    finally {
+        await fileTempHandle?.close();
+        await fileHandle?.close();
     }
-    // writeStream.end(async () => await rename(fileTempPath, filePath));
-    await fileHandle.close();
-    await fileTempHandle.close();
-    await rename(fileTempPath, filePath);
 };
 export const count = async (filePath) => {
-    let lineCount = 0;
-    const fileHandle = await open(filePath, "r"), rl = doesSupportReadLines()
-        ? fileHandle.readLines({ autoClose: false })
-        : createInterface({
-            input: fileHandle.createReadStream({ autoClose: false }),
-            crlfDelay: Infinity,
-        });
-    for await (const line of rl)
-        lineCount++;
-    await fileHandle.close();
-    return lineCount;
+    let fileHandle, lineCount = 0;
+    try {
+        fileHandle = await open(filePath, "r");
+        const rl = doesSupportReadLines()
+            ? fileHandle.readLines()
+            : createInterface({
+                input: fileHandle.createReadStream(),
+                crlfDelay: Infinity,
+            });
+        for await (const line of rl)
+            lineCount++;
+        return lineCount;
+    }
+    finally {
+        await fileHandle.close();
+    }
 };
 const handleComparisonOperator = (operator, originalValue, comparedAtValue, fieldType, fieldChildrenType) => {
     if (Array.isArray(fieldType))
@@ -305,139 +334,155 @@ const handleComparisonOperator = (operator, originalValue, comparedAtValue, fiel
     }
 };
 export const search = async (filePath, operator, comparedAtValue, logicalOperator, fieldType, fieldChildrenType, limit, offset, readWholeFile, secretKey) => {
-    let RETURN = new Map(), lineCount = 0, foundItems = 0;
-    const fileHandle = await open(filePath, "r"), rl = doesSupportReadLines()
-        ? fileHandle.readLines({ autoClose: false })
-        : createInterface({
-            input: fileHandle.createReadStream({ autoClose: false }),
-            crlfDelay: Infinity,
-        });
-    for await (const line of rl) {
-        lineCount++;
-        const decodedLine = decode(line, fieldType, fieldChildrenType, secretKey);
-        if ((Array.isArray(operator) &&
-            Array.isArray(comparedAtValue) &&
-            ((logicalOperator &&
-                logicalOperator === "or" &&
-                operator.some((single_operator, index) => handleComparisonOperator(single_operator, decodedLine, comparedAtValue[index], fieldType))) ||
-                operator.every((single_operator, index) => handleComparisonOperator(single_operator, decodedLine, comparedAtValue[index], fieldType)))) ||
-            (!Array.isArray(operator) &&
-                handleComparisonOperator(operator, decodedLine, comparedAtValue, fieldType))) {
-            foundItems++;
-            if (offset && foundItems < offset)
-                continue;
-            if (limit && foundItems > limit)
-                if (readWholeFile)
+    let fileHandle, RETURN = new Map(), lineCount = 0, foundItems = 0;
+    try {
+        fileHandle = await open(filePath, "r");
+        const rl = doesSupportReadLines()
+            ? fileHandle.readLines()
+            : createInterface({
+                input: fileHandle.createReadStream(),
+                crlfDelay: Infinity,
+            });
+        for await (const line of rl) {
+            lineCount++;
+            const decodedLine = decode(line, fieldType, fieldChildrenType, secretKey);
+            if ((Array.isArray(operator) &&
+                Array.isArray(comparedAtValue) &&
+                ((logicalOperator &&
+                    logicalOperator === "or" &&
+                    operator.some((single_operator, index) => handleComparisonOperator(single_operator, decodedLine, comparedAtValue[index], fieldType))) ||
+                    operator.every((single_operator, index) => handleComparisonOperator(single_operator, decodedLine, comparedAtValue[index], fieldType)))) ||
+                (!Array.isArray(operator) &&
+                    handleComparisonOperator(operator, decodedLine, comparedAtValue, fieldType))) {
+                foundItems++;
+                if (offset && foundItems < offset)
                     continue;
-                else
-                    break;
-            RETURN.set(lineCount, decodedLine);
+                if (limit && foundItems > limit)
+                    if (readWholeFile)
+                        continue;
+                    else
+                        break;
+                RETURN.set(lineCount, decodedLine);
+            }
         }
+        return foundItems
+            ? [
+                Object.fromEntries(RETURN),
+                readWholeFile ? foundItems : foundItems - 1,
+            ]
+            : [null, 0];
+    }
+    finally {
+        await fileHandle?.close();
     }
-    await fileHandle.close();
-    return foundItems
-        ? [Object.fromEntries(RETURN), readWholeFile ? foundItems : foundItems - 1]
-        : [null, 0];
 };
 export const sum = async (filePath, lineNumbers) => {
-    const fileHandle = await open(filePath, "r"), rl = doesSupportReadLines()
-        ? fileHandle.readLines({ autoClose: false })
-        : createInterface({
-            input: fileHandle.createReadStream({ autoClose: false }),
-            crlfDelay: Infinity,
-        });
-    let sum = 0;
-    if (lineNumbers) {
-        let lineCount = 0;
-        let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-        for await (const line of rl) {
-            lineCount++;
-            if (!lineNumbersArray.has(lineCount))
-                continue;
-            sum += +decode(line, "number");
-            lineNumbersArray.delete(lineCount);
-            if (!lineNumbersArray.size)
-                break;
+    let fileHandle, sum = 0;
+    try {
+        fileHandle = await open(filePath, "r");
+        const rl = doesSupportReadLines()
+            ? fileHandle.readLines()
+            : createInterface({
+                input: fileHandle.createReadStream(),
+                crlfDelay: Infinity,
+            });
+        if (lineNumbers) {
+            let lineCount = 0;
+            let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+            for await (const line of rl) {
+                lineCount++;
+                if (!lineNumbersArray.has(lineCount))
+                    continue;
+                sum += +decode(line, "number");
+                lineNumbersArray.delete(lineCount);
+                if (!lineNumbersArray.size)
+                    break;
+            }
         }
+        else
+            for await (const line of rl)
+                sum += +decode(line, "number");
+        return sum;
+    }
+    finally {
+        await fileHandle?.close();
     }
-    else
-        for await (const line of rl)
-            sum += +decode(line, "number");
-    return sum;
 };
 export const max = async (filePath, lineNumbers) => {
-    const fileHandle = await open(filePath, "r"), rl = doesSupportReadLines()
-        ? fileHandle.readLines({ autoClose: false })
-        : createInterface({
-            input: fileHandle.createReadStream({ autoClose: false }),
-            crlfDelay: Infinity,
-        });
-    let max = 0;
-    if (lineNumbers) {
-        let lineCount = 0;
-        let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-        for await (const line of rl) {
-            lineCount++;
-            if (!lineNumbersArray.has(lineCount))
-                continue;
-            const lineContentNum = +decode(line, "number");
-            if (lineContentNum > max)
-                max = lineContentNum;
-            lineNumbersArray.delete(lineCount);
-            if (!lineNumbersArray.size)
-                break;
+    let fileHandle, max = 0;
+    try {
+        fileHandle = await open(filePath, "r");
+        const rl = doesSupportReadLines()
+            ? fileHandle.readLines()
+            : createInterface({
+                input: fileHandle.createReadStream(),
+                crlfDelay: Infinity,
+            });
+        if (lineNumbers) {
+            let lineCount = 0;
+            let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+            for await (const line of rl) {
+                lineCount++;
+                if (!lineNumbersArray.has(lineCount))
+                    continue;
+                const lineContentNum = +decode(line, "number");
+                if (lineContentNum > max)
+                    max = lineContentNum;
+                lineNumbersArray.delete(lineCount);
+                if (!lineNumbersArray.size)
+                    break;
+            }
         }
+        else
+            for await (const line of rl) {
+                const lineContentNum = +decode(line, "number");
+                if (lineContentNum > max)
+                    max = lineContentNum;
+            }
+        return max;
+    }
+    finally {
+        await fileHandle?.close();
     }
-    else
-        for await (const line of rl) {
-            const lineContentNum = +decode(line, "number");
-            if (lineContentNum > max)
-                max = lineContentNum;
-        }
-    return max;
 };
 export const min = async (filePath, lineNumbers) => {
-    const fileHandle = await open(filePath, "r"), rl = doesSupportReadLines()
-        ? fileHandle.readLines({ autoClose: false })
-        : createInterface({
-            input: fileHandle.createReadStream({ autoClose: false }),
-            crlfDelay: Infinity,
-        });
-    let min = 0;
-    if (lineNumbers) {
-        let lineCount = 0;
-        let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-        for await (const line of rl) {
-            lineCount++;
-            if (!lineNumbersArray.has(lineCount))
-                continue;
-            const lineContentNum = +decode(line, "number");
-            if (lineContentNum < min)
-                min = lineContentNum;
-            lineNumbersArray.delete(lineCount);
-            if (!lineNumbersArray.size)
-                break;
+    let fileHandle, min = 0;
+    try {
+        fileHandle = await open(filePath, "r");
+        const rl = doesSupportReadLines()
+            ? fileHandle.readLines()
+            : createInterface({
+                input: fileHandle.createReadStream(),
+                crlfDelay: Infinity,
+            });
+        if (lineNumbers) {
+            let lineCount = 0;
+            let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+            for await (const line of rl) {
+                lineCount++;
+                if (!lineNumbersArray.has(lineCount))
+                    continue;
+                const lineContentNum = +decode(line, "number");
+                if (lineContentNum < min)
+                    min = lineContentNum;
+                lineNumbersArray.delete(lineCount);
+                if (!lineNumbersArray.size)
+                    break;
+            }
         }
+        else
+            for await (const line of rl) {
+                const lineContentNum = +decode(line, "number");
+                if (lineContentNum < min)
+                    min = lineContentNum;
+            }
+        return min;
+    }
+    finally {
+        await fileHandle?.close();
     }
-    else
-        for await (const line of rl) {
-            const lineContentNum = +decode(line, "number");
-            if (lineContentNum < min)
-                min = lineContentNum;
-        }
-    return min;
-};
-export const sort = async (filePath, sortDirection, lineNumbers, _lineNumbersPerChunk = 100000) => {
-    const fileHandle = await open(filePath, "r"), rl = doesSupportReadLines()
-        ? fileHandle.readLines({ autoClose: false })
-        : createInterface({
-            input: fileHandle.createReadStream({ autoClose: false }),
-            crlfDelay: Infinity,
-        });
-    let lineCount = 0;
-    for await (const line of rl)
-        lineCount++;
 };
+export const sort = async (filePath, sortDirection, lineNumbers, _lineNumbersPerChunk = 100000) => { };
 export default class File {
     static get = get;
     static remove = remove;

package/dist/index.d.ts

@@ -84,10 +84,13 @@ export default class Inibase {
     put(tableName: string, data: Data | Data[], where?: number | string | (number | string)[] | Criteria | undefined, options?: Options | undefined, returnPostedData?: false): Promise<void | null>;
     put(tableName: string, data: Data, where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnPostedData: true): Promise<Data | null>;
     put(tableName: string, data: Data[], where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnPostedData: true): Promise<Data[] | null>;
-    delete(tableName: string, where?: number | string | (number | string)[] | Criteria, _id?: string | string[]): Promise<string | string[] | null>;
+    delete(tableName: string, where?: number | string, _id?: string | string[]): Promise<string | null>;
+    delete(tableName: string, where?: (number | string)[], _id?: string | string[]): Promise<string[] | null>;
     sum(tableName: string, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;
     sum(tableName: string, columns: string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
-    max(tableName: string, columns: string | string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
-    min(tableName: string, columns: string | string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
+    max(tableName: string, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;
+    max(tableName: string, columns: string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
+    min(tableName: string, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;
+    min(tableName: string, columns: string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
 }
 export {};

package/dist/index.js

@@ -74,7 +74,7 @@ export default class Inibase {
                 return RETURN;
             }, replaceOldPathes = Utils.findChangedProperties(schemaToIdsPath(await this.getTableSchema(tableName)), schemaToIdsPath(schema));
             if (replaceOldPathes)
-                for (const [oldPath, newPath] of Object.entries(replaceOldPathes))
+                for await (const [oldPath, newPath] of Object.entries(replaceOldPathes))
                     if (await File.isExists(join(TablePath, oldPath)))
                         await rename(join(TablePath, oldPath), join(TablePath, newPath));
         }
@@ -294,7 +294,7 @@ export default class Inibase {
     async getItemsFromSchema(tableName, schema, linesNumber, options, prefix) {
         const path = join(this.folder, this.database, tableName);
         let RETURN = {};
-        for (const field of schema) {
+        for await (const field of schema) {
             if ((field.type === "array" ||
                 (Array.isArray(field.type) &&
                     field.type.includes("array"))) &&
@@ -382,7 +382,7 @@ export default class Inibase {
                             .map((column) => column.replace(`${field.key}.`, ""));
                     const [items, total_lines] = await File.get(join(path, (prefix ?? "") + field.key + ".inib"), linesNumber, field.type, field.children, this.salt);
                     this.totalItems[tableName + "-" + field.key] = total_lines;
-                    for (const [index, item] of Object.entries(items)) {
+                    for await (const [index, item] of Object.entries(items)) {
                         if (!RETURN[index])
                             RETURN[index] = {};
                         RETURN[index][field.key] = item
@@ -401,7 +401,7 @@ export default class Inibase {
                 }
             }
             else if (field.type === "object") {
-                for (const [index, item] of Object.entries((await this.getItemsFromSchema(tableName, field.children, linesNumber, options, (prefix ?? "") + field.key + ".")) ?? {})) {
+                for await (const [index, item] of Object.entries((await this.getItemsFromSchema(tableName, field.children, linesNumber, options, (prefix ?? "") + field.key + ".")) ?? {})) {
                     if (!RETURN[index])
                         RETURN[index] = {};
                     if (Utils.isObject(item)) {
@@ -424,7 +424,7 @@ export default class Inibase {
                             .map((column) => column.replace(`${field.key}.`, ""));
                     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)) {
+                    for await (const [index, item] of Object.entries(items)) {
                         if (!RETURN[index])
                             RETURN[index] = {};
                         RETURN[index][field.key] = item
@@ -516,7 +516,7 @@ export default class Inibase {
             if (allTrue === undefined)
                 allTrue = true;
             let index = -1;
-            for (const [key, value] of Object.entries(criteria)) {
+            for await (const [key, value] of Object.entries(criteria)) {
                 const field = this.getField(key, schema);
                 index++;
                 let searchOperator = undefined, searchComparedAtValue = undefined, searchLogicalOperator = undefined;
@@ -689,19 +689,20 @@ export default class Inibase {
             throw this.throwError("NO_SCHEMA", tableName);
         const idFilePath = join(this.folder, this.database, tableName, "id.inib");
         let [last_line_number, last_id] = (await File.isExists(idFilePath))
-            ? Object.entries((await File.get(idFilePath, -1, "number", undefined, this.salt))[0])[0]?.map(Number) ?? [0, 0]
+            ? Object.entries((await File.get(idFilePath, -1, "number", undefined, this.salt))[0] ??
+                {})[0]?.map(Number) ?? [0, 0]
             : [0, 0];
         if (Utils.isArrayOfObjects(data))
             RETURN = data.map(({ id, updatedAt, createdAt, ...rest }) => ({
                 id: ++last_id,
                 ...rest,
-                createdAt: new Date().getTime(),
+                createdAt: Date.now(),
             }));
         else
             RETURN = (({ id, updatedAt, createdAt, ...rest }) => ({
                 id: ++last_id,
                 ...rest,
-                createdAt: new Date().getTime(),
+                createdAt: Date.now(),
             }))(data);
         if (!RETURN)
             throw this.throwError("NO_DATA");
@@ -742,11 +743,11 @@ export default class Inibase {
                 const pathesContents = this.joinPathesContents(join(this.folder, this.database, tableName), Utils.isArrayOfObjects(data)
                     ? data.map((item) => ({
                         ...(({ id, ...restOfData }) => restOfData)(item),
-                        updatedAt: new Date().getTime(),
+                        updatedAt: Date.now(),
                     }))
                     : {
                         ...(({ id, ...restOfData }) => restOfData)(data),
-                        updatedAt: new Date().getTime(),
+                        updatedAt: Date.now(),
                     });
                 for await (const [path, content] of Object.entries(pathesContents))
                     await File.replace(path, content);
@@ -769,9 +770,9 @@ export default class Inibase {
                 const pathesContents = Object.fromEntries(Object.entries(this.joinPathesContents(join(this.folder, this.database, tableName), Utils.isArrayOfObjects(data)
                     ? data.map((item) => ({
                         ...item,
-                        updatedAt: new Date().getTime(),
+                        updatedAt: Date.now(),
                     }))
-                    : { ...data, updatedAt: new Date().getTime() })).map(([path, content]) => [
+                    : { ...data, updatedAt: Date.now() })).map(([path, content]) => [
                     path,
                     [...(Array.isArray(where) ? where : [where])].reduce((obj, lineNum, index) => ({
                         ...obj,
@@ -801,11 +802,10 @@ export default class Inibase {
         if (!(await File.isExists(idFilePath)))
             throw this.throwError("NO_ITEMS", tableName);
         if (!where) {
-            const files = await readdir(join(this.folder, this.database, tableName));
-            if (files.length) {
-                for (const file in files.filter((fileName) => fileName !== "schema.json"))
+            const files = (await readdir(join(this.folder, this.database, tableName)))?.filter((fileName) => fileName.endsWith(".inib"));
+            if (files.length)
+                for await (const file of files)
                     await unlink(join(this.folder, this.database, tableName, file));
-            }
             return "*";
         }
         else if ((Array.isArray(where) &&
@@ -820,13 +820,13 @@ export default class Inibase {
             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));
+                const files = (await readdir(join(this.folder, this.database, tableName)))?.filter((fileName) => fileName.endsWith(".inib"));
                 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) => UtilsServer.encodeID(Number(id), this.salt));
                     if (!_id.length)
                         throw this.throwError("NO_ITEMS", tableName);
-                    for (const file of files.filter((fileName) => fileName.endsWith(".inib")))
+                    for await (const file of files)
                         await File.remove(join(this.folder, this.database, tableName, file), where);
                     return Array.isArray(_id) && _id.length === 1 ? _id[0] : _id;
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.19",
+  "version": "1.0.0-rc.21",
   "description": "File-based Relational Database for large data",
   "main": "./dist/index.js",
   "types": "./dist",