inibase 1.0.0-rc.57 → 1.0.0-rc.59

package/dist/file.js

@@ -1,11 +1,11 @@
-import { open, access, writeFile, readFile, constants as fsConstants, unlink, copyFile, appendFile, } from "node:fs/promises";
+import { open, access, writeFile, readFile, constants as fsConstants, unlink, copyFile, appendFile, mkdir, } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createGzip, createGunzip, gunzipSync, gzipSync } from "node:zlib";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { detectFieldType, isArrayOfObjects, isJSON, isNumber, isObject, } from "./utils.js";
-import { encodeID, compare } from "./utils.server.js";
+import { encodeID, compare, exec } from "./utils.server.js";
 import * as Config from "./config.js";
 import Inison from "inison";
 export const lock = async (folderPath, prefix) => {
@@ -30,6 +30,7 @@ export const unlock = async (folderPath, prefix) => {
     catch { }
 };
 export const write = async (filePath, data, disableCompression = false) => {
+    await mkdir(dirname(filePath), { recursive: true });
     await writeFile(filePath, Config.isCompressionEnabled && !disableCompression
         ? gzipSync(String(data))
         : String(data));
@@ -203,18 +204,28 @@ export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, s
                 lines[linesCount] = decode(lastLine, fieldType, fieldChildrenType, secretKey);
         }
         else {
-            const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-            for await (const line of rl) {
-                linesCount++;
-                if (!lineNumbersArray.has(linesCount))
-                    continue;
-                lines[linesCount] = decode(line, fieldType, fieldChildrenType, secretKey);
-                lineNumbersArray.delete(linesCount);
-                if (!lineNumbersArray.size && !readWholeFile)
-                    break;
+            lineNumbers = Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers];
+            if (readWholeFile) {
+                const lineNumbersArray = new Set(lineNumbers);
+                for await (const line of rl) {
+                    linesCount++;
+                    if (!lineNumbersArray.has(linesCount))
+                        continue;
+                    lines[linesCount] = decode(line, fieldType, fieldChildrenType, secretKey);
+                    lineNumbersArray.delete(linesCount);
+                }
+                return [lines, linesCount];
+            }
+            const command = Config.isCompressionEnabled
+                ? `zcat ${filePath} | sed -n '${lineNumbers.join("p;")}p'`
+                : `sed -n '${lineNumbers.join("p;")}p' ${filePath}`, foundedLines = (await exec(command)).stdout.trim().split(/\r?\n/);
+            let index = 0;
+            for (const line of foundedLines) {
+                lines[lineNumbers[index]] = decode(line, fieldType, fieldChildrenType, secretKey);
+                index++;
             }
         }
-        return readWholeFile ? [lines, linesCount] : lines;
+        return lines;
     }
     finally {
         // Ensure that file handles are closed, even if an error occurred
@@ -334,32 +345,41 @@ export const append = async (filePath, data) => {
  * Note: Creates a temporary file during the process and replaces the original file with it after removing lines.
  */
 export const remove = async (filePath, linesToDelete) => {
-    let linesCount = 0;
-    let deletedCount = 0;
-    const fileHandle = await open(filePath, "r");
-    const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
-    const fileTempHandle = await open(fileTempPath, "w");
-    const linesToDeleteArray = new Set(Array.isArray(linesToDelete)
+    linesToDelete = Array.isArray(linesToDelete)
         ? linesToDelete.map(Number)
-        : [Number(linesToDelete)]);
-    const rl = readLineInternface(fileHandle);
-    await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
-        transform(line, encoding, callback) {
-            linesCount++;
-            if (linesToDeleteArray.has(linesCount)) {
-                deletedCount++;
+        : [Number(linesToDelete)];
+    const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
+    if (linesToDelete.length < 1000) {
+        const command = Config.isCompressionEnabled
+            ? `zcat ${filePath} | sed "${linesToDelete.join("d;")}d" | gzip > ${fileTempPath}`
+            : `sed "${linesToDelete.join("d;")}d" ${filePath} > ${fileTempPath}`;
+        await exec(command);
+    }
+    else {
+        let linesCount = 0;
+        let deletedCount = 0;
+        const fileHandle = await open(filePath, "r");
+        const fileTempHandle = await open(fileTempPath, "w");
+        const linesToDeleteArray = new Set(linesToDelete);
+        const rl = readLineInternface(fileHandle);
+        await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
+            transform(line, _, callback) {
+                linesCount++;
+                if (linesToDeleteArray.has(linesCount)) {
+                    deletedCount++;
+                    return callback();
+                }
+                return callback(null, `${line}\n`);
+            },
+            final(callback) {
+                if (deletedCount === linesCount)
+                    this.push("\n");
                 return callback();
-            }
-            return callback(null, `${line}\n`);
-        },
-        final(callback) {
-            if (deletedCount === linesCount)
-                this.push("\n");
-            return callback();
-        },
-    }));
-    await fileTempHandle.close();
-    await fileHandle.close();
+            },
+        }));
+        await fileTempHandle.close();
+        await fileHandle.close();
+    }
     return [fileTempPath, filePath];
 };
 /**
@@ -447,7 +467,7 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
  * Note: Reads through the file line by line to count the total number of lines.
  */
 export const count = async (filePath) => {
-    // return Number((await exec(`wc -l < ${filePath}`)).stdout.trim());
+    // Number((await exec(`wc -l < ${filePath}`)).stdout.trim());
     let linesCount = 0;
     if (await isExists(filePath)) {
         let fileHandle = null;

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" resolution-mode="require"/>
+import "dotenv/config";
 export interface Data {
     id?: number | string;
     [key: string]: any;
@@ -47,12 +48,13 @@ export default class Inibase {
     database: string;
     table: string | null;
     pageInfo: Record<string, pageInfo>;
+    private fileExtension;
     private checkIFunique;
-    private isThreadEnabled;
     private totalItems;
     salt: Buffer;
     constructor(database: string, mainFolder?: string, _table?: string | null, _totalItems?: Record<string, number>, _pageInfo?: Record<string, pageInfo>, _isThreadEnabled?: boolean);
     private throwError;
+    private getFileExtension;
     private _schemaToIdsPath;
     setTableSchema(tableName: string, schema: Schema): Promise<void>;
     getTableSchema(tableName: string, encodeIDs?: boolean): Promise<Schema | undefined>;
@@ -81,6 +83,8 @@ export default class Inibase {
     put(tableName: string, data: Data[], where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: true): Promise<Data[] | null>;
     delete(tableName: string, where?: number | string, _id?: string | string[]): Promise<string | null>;
     delete(tableName: string, where?: (number | string)[] | Criteria, _id?: string | string[]): Promise<string[] | null>;
+    delete(tableName: string, where?: number, _id?: string | string[]): Promise<number | null>;
+    delete(tableName: string, where?: number[], _id?: string | string[]): Promise<number[] | 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, where?: number | string | (number | string)[] | Criteria): Promise<number>;