inibase 1.0.0-rc.50 → 1.0.0-rc.51

package/dist/config.d.ts

@@ -1,5 +1,3 @@
-export default class Config {
-    static isCompressionEnabled: boolean;
-    static isCacheEnabled: boolean;
-    static isReverseEnabled: boolean;
-}
+export declare const isCompressionEnabled: boolean;
+export declare const isCacheEnabled: boolean;
+export declare const isReverseEnabled: boolean;

package/dist/config.js

@@ -1,5 +1,3 @@
-export default class Config {
-    static isCompressionEnabled = process.env.INIBASE_COMPRESSION === "true";
-    static isCacheEnabled = process.env.INIBASE_CACHE === "true";
-    static isReverseEnabled = process.env.INIBASE_REVERSE === "true";
-}
+export const isCompressionEnabled = process.env.INIBASE_COMPRESSION === "true";
+export const isCacheEnabled = process.env.INIBASE_CACHE === "true";
+export const isReverseEnabled = process.env.INIBASE_REVERSE === "true";

package/dist/file.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" resolution-mode="require"/>
-import { ComparisonOperator, FieldType, Schema } from "./index.js";
+import type { ComparisonOperator, FieldType, Schema } from "./index.js";
 export declare const lock: (folderPath: string, prefix?: string) => Promise<void>;
 export declare const unlock: (folderPath: string, prefix?: string) => Promise<void>;
 export declare const write: (filePath: string, data: any, disableCompression?: boolean) => Promise<void>;
@@ -143,34 +143,3 @@ export declare const max: (filePath: string, lineNumbers?: number | number[]) =>
  */
 export declare const min: (filePath: string, lineNumbers?: number | number[]) => Promise<number>;
 export declare function createWorker(functionName: "get" | "remove" | "search" | "replace" | "sum" | "min" | "max" | "append" | "count", arg: any[]): Promise<any>;
-/**
- * Asynchronously sorts the lines in a file in the specified direction.
- *
- * @param filePath - Path of the file to be sorted.
- * @param sortDirection - Direction for sorting: 1 or 'asc' for ascending, -1 or 'desc' for descending.
- * @param lineNumbers - Optional specific line numbers to sort. If not provided, sorts all lines.
- * @param _lineNumbersPerChunk - Optional parameter for handling large files, specifying the number of lines per chunk.
- * @returns Promise<void>. Modifies the file by sorting specified lines.
- *
- * Note: The sorting is applied either to the entire file or to the specified lines. Large files are handled in chunks.
- */
-export declare const sort: (filePath: string, sortDirection: 1 | -1 | "asc" | "desc", lineNumbers?: number | number[], _lineNumbersPerChunk?: number) => Promise<void>;
-export default class File {
-    static get: typeof get;
-    static remove: (filePath: string, linesToDelete: number | number[]) => Promise<string[]>;
-    static search: (filePath: string, operator: ComparisonOperator | ComparisonOperator[], comparedAtValue: string | number | boolean | (string | number | boolean | null)[] | null, logicalOperator?: "and" | "or" | undefined, fieldType?: FieldType | FieldType[] | undefined, fieldChildrenType?: FieldType | FieldType[] | Schema | undefined, limit?: number | undefined, offset?: number | undefined, readWholeFile?: boolean | undefined, secretKey?: string | Buffer | undefined) => Promise<[Record<number, string | number | boolean | (string | number | boolean | null)[] | null> | null, number, Set<number> | null]>;
-    static replace: (filePath: string, replacements: string | number | boolean | (string | number | boolean | null)[] | Record<number, string | number | boolean | (string | number | boolean | null)[] | null> | null) => Promise<string[]>;
-    static encode: (input: string | number | boolean | (string | number | boolean | null)[] | null) => string | number | boolean | null;
-    static decode: (input: string | number | null, fieldType?: FieldType | FieldType[] | undefined, fieldChildrenType?: FieldType | FieldType[] | Schema | undefined, secretKey?: string | Buffer | undefined) => string | number | boolean | (string | number | boolean | null)[] | null;
-    static isExists: (path: string) => Promise<boolean>;
-    static sum: (filePath: string, lineNumbers?: number | number[] | undefined) => Promise<number>;
-    static min: (filePath: string, lineNumbers?: number | number[] | undefined) => Promise<number>;
-    static max: (filePath: string, lineNumbers?: number | number[] | undefined) => Promise<number>;
-    static append: (filePath: string, data: string | number | (string | number)[]) => Promise<string[]>;
-    static count: (filePath: string) => Promise<number>;
-    static write: (filePath: string, data: any, disableCompression?: boolean) => Promise<void>;
-    static read: (filePath: string, disableCompression?: boolean) => Promise<string>;
-    static lock: (folderPath: string, prefix?: string | undefined) => Promise<void>;
-    static unlock: (folderPath: string, prefix?: string | undefined) => Promise<void>;
-    static createWorker: typeof createWorker;
-}

package/dist/file.js

@@ -7,10 +7,11 @@ import { join } from "node:path";
 import { Worker } from "node:worker_threads";
 import { detectFieldType, isArrayOfObjects, isJSON, isNumber, isObject, } from "./utils.js";
 import { encodeID, compare } from "./utils.server.js";
-import Config from "./config.js";
+import * as Config from "./config.js";
 import Inison from "inison";
 export const lock = async (folderPath, prefix) => {
-    let lockFile, lockFilePath = join(folderPath, `${prefix ?? ""}.locked`);
+    let lockFile = null;
+    const lockFilePath = join(folderPath, `${prefix ?? ""}.locked`);
     try {
         lockFile = await open(lockFilePath, "wx");
         return;
@@ -60,7 +61,7 @@ const readLineInternface = (fileHandle) => {
             input: Config.isCompressionEnabled
                 ? fileHandle.createReadStream().pipe(createGunzip())
                 : fileHandle.createReadStream(),
-            crlfDelay: Infinity,
+            crlfDelay: Number.POSITIVE_INFINITY,
         });
 };
 /**
@@ -152,6 +153,7 @@ const decodeHelper = (value, fieldType, fieldChildrenType, secretKey) => {
                         ? detectFieldType(v, fieldChildrenType)
                         : fieldChildrenType, undefined, secretKey))
                     : value;
+            break;
         case "table":
         case "id":
             return isNumber(value) && secretKey
@@ -187,25 +189,30 @@ export const decode = (input, fieldType, fieldChildrenType, secretKey) => {
         : input, fieldType, fieldChildrenType, secretKey);
 };
 export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, secretKey, readWholeFile = false) {
-    let fileHandle, rl;
+    let fileHandle = null;
+    let rl = null;
     try {
         fileHandle = await open(filePath, "r");
         rl = readLineInternface(fileHandle);
-        let lines = {}, linesCount = 0;
+        const lines = {};
+        let linesCount = 0;
         if (!lineNumbers) {
-            for await (const line of rl)
-                linesCount++,
-                    (lines[linesCount] = decode(line, fieldType, fieldChildrenType, secretKey));
+            for await (const line of rl) {
+                linesCount++;
+                lines[linesCount] = decode(line, fieldType, fieldChildrenType, secretKey);
+            }
         }
         else if (lineNumbers === -1) {
             let lastLine = null;
-            for await (const line of rl)
-                linesCount++, (lastLine = line);
+            for await (const line of rl) {
+                linesCount++;
+                lastLine = line;
+            }
             if (lastLine)
                 lines[linesCount] = decode(lastLine, fieldType, fieldChildrenType, secretKey);
         }
         else {
-            let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+            const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
             for await (const line of rl) {
                 linesCount++;
                 if (!lineNumbersArray.has(linesCount))
@@ -235,9 +242,11 @@ export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, s
  * Note: If the file doesn't exist and replacements is an object, it creates a new file with the specified replacements.
  */
 export const replace = async (filePath, replacements) => {
-    const fileTempPath = filePath.replace(/([^/]+)\/?$/, `.tmp/$1`);
+    const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
     if (await isExists(filePath)) {
-        let fileHandle, fileTempHandle, rl;
+        let fileHandle = null;
+        let fileTempHandle = null;
+        let rl = null;
         try {
             let linesCount = 0;
             fileHandle = await open(filePath, "r");
@@ -247,11 +256,11 @@ export const replace = async (filePath, replacements) => {
                 transform(line, encoding, callback) {
                     linesCount++;
                     const replacement = isObject(replacements)
-                        ? replacements.hasOwnProperty(linesCount)
+                        ? Object.hasOwn(replacements, linesCount)
                             ? replacements[linesCount]
                             : line
                         : replacements;
-                    return callback(null, replacement + "\n");
+                    return callback(null, `${replacement}\n`);
                 },
             }));
             return [fileTempPath, filePath];
@@ -264,17 +273,16 @@ export const replace = async (filePath, replacements) => {
         }
     }
     else if (isObject(replacements)) {
-        let replacementsKeys = Object.keys(replacements)
+        const replacementsKeys = Object.keys(replacements)
             .map(Number)
             .toSorted((a, b) => a - b);
-        await write(fileTempPath, "\n".repeat(replacementsKeys[0] - 1) +
+        await write(fileTempPath, `${"\n".repeat(replacementsKeys[0] - 1) +
             replacementsKeys
                 .map((lineNumber, index) => index === 0 || lineNumber - replacementsKeys[index - 1] - 1 === 0
                 ? replacements[lineNumber]
                 : "\n".repeat(lineNumber - replacementsKeys[index - 1] - 1) +
                     replacements[lineNumber])
-                .join("\n") +
-            "\n");
+                .join("\n")}\n`);
         return [fileTempPath, filePath];
     }
     return [];
@@ -288,14 +296,16 @@ export const replace = async (filePath, replacements) => {
  *
  */
 export const append = async (filePath, data) => {
-    const fileTempPath = filePath.replace(/([^/]+)\/?$/, `.tmp/$1`);
+    const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
     if (await isExists(filePath)) {
         if (!Config.isReverseEnabled && !Config.isCompressionEnabled) {
             await copyFile(filePath, fileTempPath);
             await appendFile(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
         }
         else {
-            let fileHandle, fileTempHandle, rl;
+            let fileHandle = null;
+            let fileTempHandle = null;
+            let rl = null;
             try {
                 fileHandle = await open(filePath, "r");
                 fileTempHandle = await open(fileTempPath, "w");
@@ -305,11 +315,9 @@ export const append = async (filePath, data) => {
                     transform(line, encoding, callback) {
                         if (!isAppended) {
                             isAppended = true;
-                            return callback(null, `${Array.isArray(data) ? data.join("\n") : data}\n` +
-                                (line.length ? `${line}\n` : ""));
+                            return callback(null, `${Array.isArray(data) ? data.join("\n") : data}\n${line.length ? `${line}\n` : ""}`);
                         }
-                        else
-                            return callback(null, `${line}\n`);
+                        return callback(null, `${line}\n`);
                     },
                 }));
             }
@@ -335,10 +343,15 @@ 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, deletedCount = 0;
-    const fileHandle = await open(filePath, "r"), fileTempPath = filePath.replace(/([^/]+)\/?$/, `.tmp/$1`), fileTempHandle = await open(fileTempPath, "w"), linesToDeleteArray = new Set(Array.isArray(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.map(Number)
-        : [Number(linesToDelete)]), rl = readLineInternface(fileHandle);
+        : [Number(linesToDelete)]);
+    const rl = readLineInternface(fileHandle);
     await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
         transform(line, encoding, callback) {
             linesCount++;
@@ -346,8 +359,7 @@ export const remove = async (filePath, linesToDelete) => {
                 deletedCount++;
                 return callback();
             }
-            else
-                return callback(null, `${line}\n`);
+            return callback(null, `${line}\n`);
         },
         final(callback) {
             if (deletedCount === linesCount)
@@ -382,8 +394,11 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
     // Initialize a Map to store the matching lines with their line numbers.
     const matchingLines = {};
     // Initialize counters for line number, found items, and processed items.
-    let linesCount = 0, foundItems = 0, linesNumbers = new Set();
-    let fileHandle, rl;
+    let linesCount = 0;
+    let foundItems = 0;
+    const linesNumbers = new Set();
+    let fileHandle = null;
+    let rl = null;
     try {
         // Open the file for reading.
         fileHandle = await open(filePath, "r");
@@ -412,11 +427,11 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
                 if (offset && foundItems < offset)
                     continue;
                 // Check if the limit has been reached.
-                if (limit && foundItems > limit)
+                if (limit && foundItems > limit) {
                     if (readWholeFile)
                         continue;
-                    else
-                        break;
+                    break;
+                }
                 // Store the decoded line in the result object.
                 matchingLines[linesCount] = decodedLine;
             }
@@ -444,11 +459,12 @@ export const count = async (filePath) => {
     // return Number((await exec(`wc -l < ${filePath}`)).stdout.trim());
     let linesCount = 0;
     if (await isExists(filePath)) {
-        let fileHandle, rl;
+        let fileHandle = null;
+        let rl = null;
         try {
-            (fileHandle = await open(filePath, "r")),
-                (rl = readLineInternface(fileHandle));
-            for await (const line of rl)
+            fileHandle = await open(filePath, "r");
+            rl = readLineInternface(fileHandle);
+            for await (const _ of rl)
                 linesCount++;
         }
         finally {
@@ -469,10 +485,11 @@ export const count = async (filePath) => {
  */
 export const sum = async (filePath, lineNumbers) => {
     let sum = 0;
-    const fileHandle = await open(filePath, "r"), rl = readLineInternface(fileHandle);
+    const fileHandle = await open(filePath, "r");
+    const rl = readLineInternface(fileHandle);
     if (lineNumbers) {
         let linesCount = 0;
-        let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+        const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
         for await (const line of rl) {
             linesCount++;
             if (!lineNumbersArray.has(linesCount))
@@ -500,10 +517,11 @@ export const sum = async (filePath, lineNumbers) => {
  */
 export const max = async (filePath, lineNumbers) => {
     let max = 0;
-    const fileHandle = await open(filePath, "r"), rl = readLineInternface(fileHandle);
+    const fileHandle = await open(filePath, "r");
+    const rl = readLineInternface(fileHandle);
     if (lineNumbers) {
         let linesCount = 0;
-        let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+        const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
         for await (const line of rl) {
             linesCount++;
             if (!lineNumbersArray.has(linesCount))
@@ -536,10 +554,11 @@ export const max = async (filePath, lineNumbers) => {
  */
 export const min = async (filePath, lineNumbers) => {
     let min = 0;
-    const fileHandle = await open(filePath, "r"), rl = readLineInternface(fileHandle);
+    const fileHandle = await open(filePath, "r");
+    const rl = readLineInternface(fileHandle);
     if (lineNumbers) {
         let linesCount = 0;
-        let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+        const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
         for await (const line of rl) {
             linesCount++;
             if (!lineNumbersArray.has(linesCount))
@@ -562,7 +581,7 @@ export const min = async (filePath, lineNumbers) => {
     return min;
 };
 export function createWorker(functionName, arg) {
-    return new Promise(function (resolve, reject) {
+    return new Promise((resolve, reject) => {
         const worker = new Worker("./dist/file.thread.js", {
             workerData: { functionName, arg },
         });
@@ -574,36 +593,3 @@ export function createWorker(functionName, arg) {
         });
     });
 }
-/**
- * Asynchronously sorts the lines in a file in the specified direction.
- *
- * @param filePath - Path of the file to be sorted.
- * @param sortDirection - Direction for sorting: 1 or 'asc' for ascending, -1 or 'desc' for descending.
- * @param lineNumbers - Optional specific line numbers to sort. If not provided, sorts all lines.
- * @param _lineNumbersPerChunk - Optional parameter for handling large files, specifying the number of lines per chunk.
- * @returns Promise<void>. Modifies the file by sorting specified lines.
- *
- * Note: The sorting is applied either to the entire file or to the specified lines. Large files are handled in chunks.
- */
-export const sort = async (filePath, sortDirection, lineNumbers, _lineNumbersPerChunk = 100000) => {
-    // return Number((await exec(`wc -l < ${filePath}`)).stdout.trim());
-};
-export default class File {
-    static get = get;
-    static remove = remove;
-    static search = search;
-    static replace = replace;
-    static encode = encode;
-    static decode = decode;
-    static isExists = isExists;
-    static sum = sum;
-    static min = min;
-    static max = max;
-    static append = append;
-    static count = count;
-    static write = write;
-    static read = read;
-    static lock = lock;
-    static unlock = unlock;
-    static createWorker = createWorker;
-}

package/dist/file.thread.js

@@ -1,5 +1,5 @@
 import { parentPort, workerData } from "node:worker_threads";
-import File from "./file.js";
+import * as File from "./file.js";
 const { functionName, arg } = workerData;
 // @ts-ignore
 File[functionName](...arg).then((res) => parentPort.postMessage(res));

package/dist/index.d.ts

@@ -76,10 +76,10 @@ export default class Inibase {
     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[]>;
-    post(tableName: string, data: Data | Data[], options?: Options, returnPostedData?: boolean): Promise<void | null>;
+    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>;
-    put(tableName: string, data: Data | Data[], where?: number | string | (number | string)[] | Criteria, options?: Options, returnUpdatedData?: false): Promise<void | null>;
+    put(tableName: string, data: Data | Data[], where?: number | string | (number | string)[] | Criteria, options?: Options, returnUpdatedData?: false): Promise<void>;
     put(tableName: string, data: Data, where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: true): Promise<Data | null>;
     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>;