inibase 1.0.0-rc.60 → 1.0.0-rc.62

package/dist/file.js

@@ -1,13 +1,12 @@
-import { open, access, writeFile, readFile, constants as fsConstants, unlink, copyFile, appendFile, mkdir, } from "node:fs/promises";
+import { open, access, writeFile, readFile, constants as fsConstants, unlink, copyFile, appendFile, } 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 { dirname, join } from "node:path";
-import { detectFieldType, isArrayOfObjects, isJSON, isNumber, isObject, } from "./utils.js";
-import { encodeID, compare, exec } from "./utils.server.js";
-import * as Config from "./config.js";
+import { createGzip, createGunzip } from "node:zlib";
+import { join } from "node:path";
 import Inison from "inison";
+import { detectFieldType, isArrayOfObjects, isJSON, isNumber, isObject, } from "./utils.js";
+import { encodeID, compare, exec, gzip, gunzip } from "./utils.server.js";
 export const lock = async (folderPath, prefix) => {
     let lockFile = null;
     const lockFilePath = join(folderPath, `${prefix ?? ""}.locked`);
@@ -29,17 +28,14 @@ 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));
+export const write = async (filePath, data) => {
+    await writeFile(filePath, filePath.endsWith(".gz") ? await gzip(data) : data);
 };
-export const read = async (filePath, disableCompression = false) => Config.isCompressionEnabled && !disableCompression
-    ? gunzipSync(await readFile(filePath)).toString()
-    : (await readFile(filePath)).toString();
-const _pipeline = async (rl, writeStream, transform) => {
-    if (Config.isCompressionEnabled)
+export const read = async (filePath) => filePath.endsWith(".gz")
+    ? (await gunzip(await readFile(filePath, "utf8"))).toString()
+    : await readFile(filePath, "utf8");
+const _pipeline = async (filePath, rl, writeStream, transform) => {
+    if (filePath.endsWith(".gz"))
         await pipeline(rl, transform, createGzip(), writeStream);
     else
         await pipeline(rl, transform, writeStream);
@@ -50,8 +46,8 @@ const _pipeline = async (rl, writeStream, transform) => {
  * @param fileHandle - The file handle from which to create a read stream.
  * @returns A readline.Interface instance configured with the provided file stream.
  */
-const readLineInternface = (fileHandle) => createInterface({
-    input: Config.isCompressionEnabled
+const createReadLineInternface = (filePath, fileHandle) => createInterface({
+    input: filePath.endsWith(".gz")
         ? fileHandle.createReadStream().pipe(createGunzip())
         : fileHandle.createReadStream(),
     crlfDelay: Number.POSITIVE_INFINITY,
@@ -182,11 +178,9 @@ export const decode = (input, fieldType, fieldChildrenType, secretKey) => {
 };
 export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, secretKey, readWholeFile = false) {
     let fileHandle = null;
-    let rl = null;
     try {
         fileHandle = await open(filePath, "r");
-        rl = readLineInternface(fileHandle);
-        const lines = {};
+        const rl = createReadLineInternface(filePath, fileHandle), lines = {};
         let linesCount = 0;
         if (!lineNumbers) {
             for await (const line of rl) {
@@ -194,17 +188,17 @@ export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, s
                 lines[linesCount] = decode(line, fieldType, fieldChildrenType, secretKey);
             }
         }
-        else if (lineNumbers === -1) {
-            let lastLine = null;
-            for await (const line of rl) {
-                linesCount++;
-                lastLine = line;
-            }
-            if (lastLine)
-                lines[linesCount] = decode(lastLine, fieldType, fieldChildrenType, secretKey);
+        else if (lineNumbers == -1) {
+            const command = filePath.endsWith(".gz")
+                ? `zcat ${filePath} | sed -n '$p'`
+                : `sed -n '$p' ${filePath}`, foundedLine = (await exec(command)).stdout.trim();
+            if (foundedLine)
+                lines[linesCount] = decode(foundedLine, fieldType, fieldChildrenType, secretKey);
         }
         else {
             lineNumbers = Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers];
+            if (lineNumbers.some(Number.isNaN))
+                throw new Error("UNVALID_LINE_NUMBERS");
             if (readWholeFile) {
                 const lineNumbersArray = new Set(lineNumbers);
                 for await (const line of rl) {
@@ -216,9 +210,9 @@ export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, s
                 }
                 return [lines, linesCount];
             }
-            const command = Config.isCompressionEnabled
+            const command = filePath.endsWith(".gz")
                 ? `zcat ${filePath} | sed -n '${lineNumbers.join("p;")}p'`
-                : `sed -n '${lineNumbers.join("p;")}p' ${filePath}`, foundedLines = (await exec(command)).stdout.trim().split(/\r?\n/);
+                : `sed -n '${lineNumbers.join("p;")}p' ${filePath}`, foundedLines = (await exec(command)).stdout.trim().split("\n");
             let index = 0;
             for (const line of foundedLines) {
                 lines[lineNumbers[index]] = decode(line, fieldType, fieldChildrenType, secretKey);
@@ -229,7 +223,6 @@ export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, s
     }
     finally {
         // Ensure that file handles are closed, even if an error occurred
-        rl?.close();
         await fileHandle?.close();
     }
 }
@@ -248,13 +241,12 @@ export const replace = async (filePath, replacements) => {
     if (await isExists(filePath)) {
         let fileHandle = null;
         let fileTempHandle = null;
-        let rl = null;
         try {
             let linesCount = 0;
             fileHandle = await open(filePath, "r");
             fileTempHandle = await open(fileTempPath, "w");
-            rl = readLineInternface(fileHandle);
-            await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
+            const rl = createReadLineInternface(filePath, fileHandle);
+            await _pipeline(filePath, rl, fileTempHandle.createWriteStream(), new Transform({
                 transform(line, encoding, callback) {
                     linesCount++;
                     const replacement = isObject(replacements)
@@ -269,7 +261,6 @@ export const replace = async (filePath, replacements) => {
         }
         finally {
             // Ensure that file handles are closed, even if an error occurred
-            rl?.close();
             await fileHandle?.close();
             await fileTempHandle?.close();
         }
@@ -297,23 +288,22 @@ export const replace = async (filePath, replacements) => {
  * @returns Promise<string[]>. Modifies the file by appending data.
  *
  */
-export const append = async (filePath, data) => {
+export const append = async (filePath, data, prepend) => {
     const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
     if (await isExists(filePath)) {
-        if (!Config.isReverseEnabled && !Config.isCompressionEnabled) {
+        if (!prepend && !filePath.endsWith(".gz")) {
             await copyFile(filePath, fileTempPath);
             await appendFile(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
         }
         else {
             let fileHandle = null;
             let fileTempHandle = null;
-            let rl = null;
             try {
                 fileHandle = await open(filePath, "r");
                 fileTempHandle = await open(fileTempPath, "w");
-                rl = readLineInternface(fileHandle);
+                const rl = createReadLineInternface(filePath, fileHandle);
                 let isAppended = false;
-                await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
+                await _pipeline(filePath, rl, fileTempHandle.createWriteStream(), new Transform({
                     transform(line, _, callback) {
                         if (!isAppended) {
                             isAppended = true;
@@ -325,14 +315,13 @@ export const append = async (filePath, data) => {
             }
             finally {
                 // Ensure that file handles are closed, even if an error occurred
-                rl?.close();
                 await fileHandle?.close();
                 await fileTempHandle?.close();
             }
         }
     }
     else
-        await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`, undefined);
+        await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
     return [fileTempPath, filePath];
 };
 /**
@@ -348,38 +337,13 @@ export const remove = async (filePath, linesToDelete) => {
     linesToDelete = Array.isArray(linesToDelete)
         ? linesToDelete.map(Number)
         : [Number(linesToDelete)];
+    if (linesToDelete.some(Number.isNaN))
+        throw new Error("UNVALID_LINE_NUMBERS");
     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();
-            },
-        }));
-        await fileTempHandle.close();
-        await fileHandle.close();
-    }
+    const command = filePath.endsWith(".gz")
+        ? `zcat ${filePath} | sed "${linesToDelete.join("d;")}d" | gzip > ${fileTempPath}`
+        : `sed "${linesToDelete.join("d;")}d" ${filePath} > ${fileTempPath}`;
+    await exec(command);
     return [fileTempPath, filePath];
 };
 /**
@@ -409,12 +373,11 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
     let foundItems = 0;
     const linesNumbers = new Set();
     let fileHandle = null;
-    let rl = null;
     try {
         // Open the file for reading.
         fileHandle = await open(filePath, "r");
         // Create a Readline interface to read the file line by line.
-        rl = readLineInternface(fileHandle);
+        const rl = createReadLineInternface(filePath, fileHandle);
         // Iterate through each line in the file.
         for await (const line of rl) {
             // Increment the line count for each line.
@@ -454,7 +417,6 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
     }
     finally {
         // Close the file handle in the finally block to ensure it is closed even if an error occurs.
-        rl?.close();
         await fileHandle?.close();
     }
 };
@@ -471,15 +433,13 @@ export const count = async (filePath) => {
     let linesCount = 0;
     if (await isExists(filePath)) {
         let fileHandle = null;
-        let rl = null;
         try {
             fileHandle = await open(filePath, "r");
-            rl = readLineInternface(fileHandle);
+            const rl = createReadLineInternface(filePath, fileHandle);
             for await (const _ of rl)
                 linesCount++;
         }
         finally {
-            rl?.close();
             await fileHandle?.close();
         }
     }
@@ -495,27 +455,31 @@ export const count = async (filePath) => {
  * Note: Decodes each line as a number using the 'decode' function. Non-numeric lines contribute 0 to the sum.
  */
 export const sum = async (filePath, lineNumbers) => {
-    let sum = 0;
-    const fileHandle = await open(filePath, "r");
-    const rl = readLineInternface(fileHandle);
-    if (lineNumbers) {
-        let linesCount = 0;
-        const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-        for await (const line of rl) {
-            linesCount++;
-            if (!lineNumbersArray.has(linesCount))
-                continue;
-            sum += +(decode(line, "number") ?? 0);
-            lineNumbersArray.delete(linesCount);
-            if (!lineNumbersArray.size)
-                break;
+    let sum = 0, fileHandle = null;
+    try {
+        fileHandle = await open(filePath, "r");
+        const rl = createReadLineInternface(filePath, fileHandle);
+        if (lineNumbers) {
+            let linesCount = 0;
+            const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+            for await (const line of rl) {
+                linesCount++;
+                if (!lineNumbersArray.has(linesCount))
+                    continue;
+                sum += +(decode(line, "number") ?? 0);
+                lineNumbersArray.delete(linesCount);
+                if (!lineNumbersArray.size)
+                    break;
+            }
         }
+        else
+            for await (const line of rl)
+                sum += +(decode(line, "number") ?? 0);
+        return sum;
+    }
+    finally {
+        await fileHandle?.close();
     }
-    else
-        for await (const line of rl)
-            sum += +(decode(line, "number") ?? 0);
-    await fileHandle.close();
-    return sum;
 };
 /**
  * Asynchronously finds the maximum numerical value from specified lines in a file.
@@ -527,32 +491,36 @@ export const sum = async (filePath, lineNumbers) => {
  * Note: Decodes each line as a number using the 'decode' function. Considers only numerical values for determining the maximum.
  */
 export const max = async (filePath, lineNumbers) => {
-    let max = 0;
-    const fileHandle = await open(filePath, "r");
-    const rl = readLineInternface(fileHandle);
-    if (lineNumbers) {
-        let linesCount = 0;
-        const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-        for await (const line of rl) {
-            linesCount++;
-            if (!lineNumbersArray.has(linesCount))
-                continue;
-            const lineContentNum = +(decode(line, "number") ?? 0);
-            if (lineContentNum > max)
-                max = lineContentNum;
-            lineNumbersArray.delete(linesCount);
-            if (!lineNumbersArray.size)
-                break;
+    let max = 0, fileHandle = null, rl = null;
+    try {
+        fileHandle = await open(filePath, "r");
+        rl = createReadLineInternface(filePath, fileHandle);
+        if (lineNumbers) {
+            let linesCount = 0;
+            const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+            for await (const line of rl) {
+                linesCount++;
+                if (!lineNumbersArray.has(linesCount))
+                    continue;
+                const lineContentNum = +(decode(line, "number") ?? 0);
+                if (lineContentNum > max)
+                    max = lineContentNum;
+                lineNumbersArray.delete(linesCount);
+                if (!lineNumbersArray.size)
+                    break;
+            }
         }
+        else
+            for await (const line of rl) {
+                const lineContentNum = +(decode(line, "number") ?? 0);
+                if (lineContentNum > max)
+                    max = lineContentNum;
+            }
+        return max;
+    }
+    finally {
+        await fileHandle?.close();
     }
-    else
-        for await (const line of rl) {
-            const lineContentNum = +(decode(line, "number") ?? 0);
-            if (lineContentNum > max)
-                max = lineContentNum;
-        }
-    await fileHandle.close();
-    return max;
 };
 /**
  * Asynchronously finds the minimum numerical value from specified lines in a file.
@@ -564,30 +532,34 @@ export const max = async (filePath, lineNumbers) => {
  * Note: Decodes each line as a number using the 'decode' function. Considers only numerical values for determining the minimum.
  */
 export const min = async (filePath, lineNumbers) => {
-    let min = 0;
-    const fileHandle = await open(filePath, "r");
-    const rl = readLineInternface(fileHandle);
-    if (lineNumbers) {
-        let linesCount = 0;
-        const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-        for await (const line of rl) {
-            linesCount++;
-            if (!lineNumbersArray.has(linesCount))
-                continue;
-            const lineContentNum = +(decode(line, "number") ?? 0);
-            if (lineContentNum < min)
-                min = lineContentNum;
-            lineNumbersArray.delete(linesCount);
-            if (!lineNumbersArray.size)
-                break;
+    let min = 0, fileHandle = null;
+    try {
+        fileHandle = await open(filePath, "r");
+        const rl = createReadLineInternface(filePath, fileHandle);
+        if (lineNumbers) {
+            let linesCount = 0;
+            const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+            for await (const line of rl) {
+                linesCount++;
+                if (!lineNumbersArray.has(linesCount))
+                    continue;
+                const lineContentNum = +(decode(line, "number") ?? 0);
+                if (lineContentNum < min)
+                    min = lineContentNum;
+                lineNumbersArray.delete(linesCount);
+                if (!lineNumbersArray.size)
+                    break;
+            }
         }
+        else
+            for await (const line of rl) {
+                const lineContentNum = +(decode(line, "number") ?? 0);
+                if (lineContentNum < min)
+                    min = lineContentNum;
+            }
+        return min;
+    }
+    finally {
+        await fileHandle?.close();
     }
-    else
-        for await (const line of rl) {
-            const lineContentNum = +(decode(line, "number") ?? 0);
-            if (lineContentNum < min)
-                min = lineContentNum;
-        }
-    await fileHandle.close();
-    return min;
 };

package/dist/index.d.ts

@@ -23,6 +23,15 @@ export interface Options {
     columns?: string[] | string;
     order?: Record<string, "asc" | "desc">;
 }
+export interface Config {
+    compression: boolean;
+    cache: boolean;
+    prepend: boolean;
+}
+export interface TableObject {
+    schema?: Schema;
+    config: Config;
+}
 export type ComparisonOperator = "=" | "!=" | ">" | "<" | ">=" | "<=" | "*" | "!*" | "[]" | "![]";
 type pageInfo = {
     total?: number;
@@ -41,24 +50,25 @@ declare global {
         entries<T extends object>(o: T): Entries<T>;
     }
 }
-export type ErrorCodes = "FIELD_UNIQUE" | "FIELD_REQUIRED" | "NO_SCHEMA" | "NO_ITEMS" | "NO_RESULTS" | "INVALID_ID" | "INVALID_TYPE" | "INVALID_PARAMETERS" | "NO_ENV";
+export type ErrorCodes = "FIELD_UNIQUE" | "FIELD_REQUIRED" | "NO_SCHEMA" | "NO_ITEMS" | "NO_RESULTS" | "INVALID_ID" | "INVALID_TYPE" | "INVALID_PARAMETERS" | "NO_ENV" | "TABLE_EXISTS" | "TABLE_NOT_EXISTS";
 export type ErrorLang = "en";
 export default class Inibase {
-    folder: string;
-    database: string;
-    table: string | null;
     pageInfo: Record<string, pageInfo>;
+    salt: Buffer;
+    private databasePath;
+    private tables;
     private fileExtension;
     private checkIFunique;
     private totalItems;
-    salt: Buffer;
-    constructor(database: string, mainFolder?: string, _table?: string | null, _totalItems?: Record<string, number>, _pageInfo?: Record<string, pageInfo>, _isThreadEnabled?: boolean);
+    constructor(database: string, mainFolder?: string);
     private throwError;
     private getFileExtension;
     private _schemaToIdsPath;
-    setTableSchema(tableName: string, schema: Schema): Promise<void>;
+    createTable(tableName: string, schema?: Schema, config?: Config): Promise<void>;
+    updateTable(tableName: string, schema?: Schema, config?: Config): Promise<void>;
+    getTable(tableName: string): Promise<TableObject>;
     getTableSchema(tableName: string, encodeIDs?: boolean): Promise<Schema | undefined>;
-    private getSchemaWhenTableNotEmpty;
+    private throwErrorIfTableEmpty;
     private validateData;
     private formatField;
     private checkUnique;
@@ -66,15 +76,14 @@ export default class Inibase {
     private getDefaultValue;
     private _combineObjectsToArray;
     private _CombineData;
-    private _addPathToKeys;
     private joinPathesContents;
     private _getItemsFromSchemaHelper;
     private getItemsFromSchema;
     private applyCriteria;
     private _filterSchemaByColumns;
     clearCache(tablePath: string): Promise<void>;
-    get(tableName: string, where?: string | number | (string | number)[] | Criteria | undefined, options?: Options | undefined, onlyOne?: true, onlyLinesNumbers?: undefined, tableSchema?: Schema, skipIdColumn?: boolean): Promise<Data | null>;
-    get(tableName: string, where?: string | number | (string | number)[] | Criteria | undefined, options?: Options | undefined, onlyOne?: boolean | undefined, onlyLinesNumbers?: true, tableSchema?: Schema, skipIdColumn?: boolean): Promise<number[]>;
+    get(tableName: string, where?: string | number | (string | number)[] | Criteria | undefined, options?: Options | undefined, onlyOne?: true, onlyLinesNumbers?: undefined, _skipIdColumn?: boolean): Promise<Data | null>;
+    get(tableName: string, where?: string | number | (string | number)[] | Criteria | undefined, options?: Options | undefined, onlyOne?: boolean | undefined, onlyLinesNumbers?: true, _skipIdColumn?: boolean): Promise<number[]>;
     post(tableName: string, data: Data | Data[], options?: Options, returnPostedData?: boolean): Promise<void>;
     post(tableName: string, data: Data, options: Options | undefined, returnPostedData: true): Promise<Data | null>;
     post(tableName: string, data: Data[], options: Options | undefined, returnPostedData: true): Promise<Data[] | null>;