inibase 1.0.0-rc.36 → 1.0.0-rc.38

package/dist/file.js

@@ -1,11 +1,11 @@
-import { open, access, writeFile, readFile, constants as fsConstants, unlink, stat, } from "node:fs/promises";
+import { open, access, writeFile, readFile, constants as fsConstants, unlink, } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createGzip, createGunzip, gzip as gzipAsync, gunzip as gunzipAsync, } from "node:zlib";
 import { promisify } from "node:util";
 import { join } from "node:path";
-import { detectFieldType, isArrayOfArrays, isNumber, isObject, } from "./utils.js";
+import { detectFieldType, isArrayOfArrays, isNumber, isObject, isPassword, } from "./utils.js";
 import { encodeID, comparePassword } from "./utils.server.js";
 import Config from "./config.js";
 const gzip = promisify(gzipAsync);
@@ -314,7 +314,7 @@ export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, s
  */
 export const replace = async (filePath, replacements) => {
     const fileTempPath = filePath.replace(/([^/]+)\/?$/, `.tmp/$1`);
-    if ((await isExists(filePath)) && (await stat(filePath)).size > 1) {
+    if (await isExists(filePath)) {
         let fileHandle, fileTempHandle, rl;
         try {
             let linesCount = 0;
@@ -367,7 +367,7 @@ export const replace = async (filePath, replacements) => {
  */
 export const append = async (filePath, data) => {
     const fileTempPath = filePath.replace(/([^/]+)\/?$/, `.tmp/$1`);
-    if ((await isExists(filePath)) && (await stat(filePath)).size > 1) {
+    if (await isExists(filePath)) {
         let fileHandle, fileTempHandle, rl;
         try {
             fileHandle = await open(filePath, "r");
@@ -378,7 +378,8 @@ 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}\n`);
+                        return callback(null, `${Array.isArray(data) ? data.join("\n") : data}\n` +
+                            (line.length ? `${line}\n` : ""));
                     }
                     else
                         return callback(null, `${line}\n`);
@@ -406,18 +407,25 @@ 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 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)
         ? linesToDelete.map(Number)
         : [Number(linesToDelete)]), rl = readLineInternface(fileHandle);
     await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
         transform(line, encoding, callback) {
             linesCount++;
-            if (linesToDeleteArray.has(linesCount))
+            if (linesToDeleteArray.has(linesCount)) {
+                deletedCount++;
                 return callback();
+            }
             else
                 return callback(null, `${line}\n`);
         },
+        final(callback) {
+            if (deletedCount === linesCount)
+                this.push("\n");
+            return callback();
+        },
     }));
     await fileTempHandle.close();
     await fileHandle.close();
@@ -502,8 +510,7 @@ const isEqual = (originalValue, comparedAtValue, fieldType) => {
     switch (fieldType) {
         // Password comparison.
         case "password":
-            return typeof originalValue === "string" &&
-                typeof comparedAtValue === "string"
+            return isPassword(originalValue) && typeof comparedAtValue === "string"
                 ? comparePassword(originalValue, comparedAtValue)
                 : false;
         // Boolean comparison.
@@ -636,7 +643,7 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
 export const count = async (filePath) => {
     // return Number((await exec(`wc -l < ${filePath}`)).stdout.trim());
     let linesCount = 0;
-    if ((await isExists(filePath)) && (await stat(filePath)).size > 1) {
+    if (await isExists(filePath)) {
         let fileHandle, rl;
         try {
             (fileHandle = await open(filePath, "r")),

package/dist/index.d.ts

@@ -66,6 +66,8 @@ export default class Inibase {
     salt: Buffer;
     constructor(database: string, mainFolder?: string);
     private throwError;
+    private _decodeIdFromSchema;
+    private _schemaToIdsPath;
     setTableSchema(tableName: string, schema: Schema): Promise<void>;
     getTableSchema(tableName: string): Promise<Schema | undefined>;
     getField(keyPath: string, schema: Schema): (FieldDefault & FieldStringType) | (FieldDefault & FieldObjectType) | (FieldDefault & FieldArrayType) | null;
@@ -73,7 +75,12 @@ export default class Inibase {
     private formatField;
     private formatData;
     private getDefaultValue;
-    private joinPathesContents;
+    private _combineObjectsToArray;
+    private _CombineData;
+    private _addPathToKeys;
+    joinPathesContents(mainPath: string, data: Data | Data[]): {
+        [key: string]: string[];
+    };
     private getItemsFromSchema;
     private applyCriteria;
     private _filterSchemaByColumns;

package/dist/index.js

@@ -23,7 +23,7 @@ export default class Inibase {
         this.pageInfo = {};
         if (!existsSync(".env") || !process.env.INIBASE_SECRET) {
             this.salt = scryptSync(randomBytes(16), randomBytes(16), 32);
-            appendFileSync(".env", `INIBASE_SECRET=${this.salt.toString("hex")}\n`);
+            appendFileSync(".env", `\nINIBASE_SECRET=${this.salt.toString("hex")}\n`);
         }
         else
             this.salt = Buffer.from(process.env.INIBASE_SECRET, "hex");
@@ -53,46 +53,47 @@ export default class Inibase {
         }
         return new Error(errorMessage);
     }
-    async setTableSchema(tableName, schema) {
-        const decodeIdFromSchema = (schema) => schema.map((field) => {
+    _decodeIdFromSchema = (schema) => schema.map((field) => {
+        if ((field.type === "array" || field.type === "object") &&
+            field.children &&
+            Utils.isArrayOfObjects(field.children))
+            field.children = this._decodeIdFromSchema(field.children);
+        if (field.id && !Utils.isNumber(field.id))
+            field.id = UtilsServer.decodeID(field.id, this.salt);
+        return field;
+    });
+    _schemaToIdsPath = (schema, prefix = "") => {
+        let RETURN = {};
+        for (const field of schema)
             if ((field.type === "array" || field.type === "object") &&
                 field.children &&
-                Utils.isArrayOfObjects(field.children))
-                field.children = decodeIdFromSchema(field.children);
-            if (field.id && !Utils.isNumber(field.id))
-                field.id = UtilsServer.decodeID(field.id, this.salt);
-            return field;
-        });
+                Utils.isArrayOfObjects(field.children)) {
+                Utils.deepMerge(RETURN, this._schemaToIdsPath(field.children, (prefix ?? "") + field.key + "."));
+            }
+            else if (Utils.isValidID(field.id))
+                RETURN[UtilsServer.decodeID(field.id, this.salt)] =
+                    (prefix ?? "") + field.key + ".inib";
+        return RETURN;
+    };
+    async setTableSchema(tableName, schema) {
+        const tablePath = join(this.folder, this.database, tableName), tableSchemaPath = join(tablePath, "schema.json"), isTablePathExists = await File.isExists(tablePath);
         // remove id from schema
         schema = schema.filter(({ key }) => !["id", "createdAt", "updatedAt"].includes(key));
-        schema = UtilsServer.addIdToSchema(schema, UtilsServer.findLastIdNumber(schema, this.salt), this.salt);
-        const tablePath = join(this.folder, this.database, tableName), tableSchemaPath = join(tablePath, "schema.json");
-        if (!(await File.isExists(tablePath)))
+        schema = UtilsServer.addIdToSchema(schema, UtilsServer.findLastIdNumber(schema, this.salt), this.salt, isTablePathExists);
+        if (!isTablePathExists)
             await mkdir(tablePath, { recursive: true });
         if (!(await File.isExists(join(tablePath, ".tmp"))))
             await mkdir(join(tablePath, ".tmp"));
         if (await File.isExists(tableSchemaPath)) {
             // update columns files names based on field id
-            const schemaToIdsPath = (schema, prefix = "") => {
-                let RETURN = {};
-                for (const field of schema)
-                    if ((field.type === "array" || field.type === "object") &&
-                        field.children &&
-                        Utils.isArrayOfObjects(field.children)) {
-                        Utils.deepMerge(RETURN, schemaToIdsPath(field.children, (prefix ?? "") + field.key + "."));
-                    }
-                    else if (Utils.isValidID(field.id))
-                        RETURN[UtilsServer.decodeID(field.id, this.salt)] =
-                            (prefix ?? "") + field.key + ".inib";
-                return RETURN;
-            }, replaceOldPathes = Utils.findChangedProperties(schemaToIdsPath((await this.getTableSchema(tableName)) ?? []), schemaToIdsPath(schema));
+            const replaceOldPathes = Utils.findChangedProperties(this._schemaToIdsPath((await this.getTableSchema(tableName)) ?? []), this._schemaToIdsPath(schema));
             if (replaceOldPathes)
                 await Promise.all(Object.entries(replaceOldPathes).map(async ([oldPath, newPath]) => {
                     if (await File.isExists(join(tablePath, oldPath)))
                         await rename(join(tablePath, oldPath), join(tablePath, newPath));
                 }));
         }
-        await File.write(join(tablePath, "schema.json"), JSON.stringify(decodeIdFromSchema(schema), null, 2), true);
+        await File.write(join(tablePath, "schema.json"), JSON.stringify(isTablePathExists ? this._decodeIdFromSchema(schema) : schema, null, 2), true);
     }
     async getTableSchema(tableName) {
         const tableSchemaPath = join(this.folder, this.database, tableName, "schema.json");
@@ -225,7 +226,7 @@ export default class Inibase {
             case "password":
                 if (Array.isArray(value))
                     value = value[0];
-                return typeof value === "string" && value.length === 161
+                return Utils.isPassword(value)
                     ? value
                     : UtilsServer.hashPassword(String(value));
             case "number":
@@ -292,13 +293,41 @@ export default class Inibase {
                 return null;
         }
     }
+    _combineObjectsToArray = (input) => input.reduce((result, current) => {
+        for (const [key, value] of Object.entries(current))
+            if (!result[key])
+                result[key] = [value];
+            else
+                result[key].push(value);
+        return result;
+    }, {});
+    _CombineData = (_data, prefix) => {
+        let RETURN = {};
+        if (Utils.isArrayOfObjects(_data))
+            RETURN = this._combineObjectsToArray(_data.map((single_data) => this._CombineData(single_data)));
+        else
+            for (const [key, value] of Object.entries(_data)) {
+                if (Utils.isObject(value))
+                    Object.assign(RETURN, this._CombineData(value, `${key}.`));
+                else if (Utils.isArrayOfObjects(value)) {
+                    Object.assign(RETURN, this._CombineData(this._combineObjectsToArray(value), (prefix ?? "") + key + "."));
+                }
+                else if (Utils.isArrayOfArrays(value) &&
+                    value.every(Utils.isArrayOfObjects))
+                    Object.assign(RETURN, this._CombineData(this._combineObjectsToArray(value.map(this._combineObjectsToArray)), (prefix ?? "") + key + "."));
+                else
+                    RETURN[(prefix ?? "") + key] = File.encode(value);
+            }
+        return RETURN;
+    };
+    _addPathToKeys = (obj, path) => {
+        const newObject = {};
+        for (const key in obj)
+            newObject[join(path, key + ".inib")] = obj[key];
+        return newObject;
+    };
     joinPathesContents(mainPath, data) {
-        return Utils.isArrayOfObjects(data)
-            ? Utils.combineObjects(data.map((single_data) => this.joinPathesContents(mainPath, single_data)))
-            : Object.fromEntries(Object.entries(Utils.objectToDotNotation(data)).map(([key, value]) => [
-                join(mainPath, key + ".inib"),
-                File.encode(value, this.salt),
-            ]));
+        return this._addPathToKeys(this._CombineData(data), mainPath);
     }
     async getItemsFromSchema(tableName, schema, linesNumber, options, prefix) {
         const tablePath = join(this.folder, this.database, tableName);

package/dist/utils.d.ts

@@ -167,13 +167,6 @@ export declare const detectFieldType: (input: any, availableTypes: FieldType[])
  * @returns A boolean indicating whether the value matches the specified field type(s).
  */
 export declare const validateFieldType: (value: any, fieldType: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[]) => boolean;
-/**
- * Converts a nested object to dot notation, flattening the object's structure.
- *
- * @param input - The input object to be converted.
- * @returns A flattened object using dot notation for keys.
- */
-export declare const objectToDotNotation: (input: Record<string, any>) => Record<string, string | number | (string | number)[]>;
 export declare function FormatObjectCriteriaValue(value: string, isParentArray?: boolean): [
     ComparisonOperator,
     string | number | boolean | null | (string | number | null)[]
@@ -197,7 +190,6 @@ export default class Utils {
     static isHTML: (input: any) => boolean;
     static isIP: (input: any) => boolean;
     static validateFieldType: (value: any, fieldType: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[] | undefined) => boolean;
-    static objectToDotNotation: (input: Record<string, any>) => Record<string, string | number | (string | number)[]>;
     static isArrayOfNulls: (input: any) => input is null[] | null[][];
     static FormatObjectCriteriaValue: typeof FormatObjectCriteriaValue;
 }

package/dist/utils.js

@@ -135,6 +135,7 @@ export const isURL = (input) => {
     else {
         var pattern = new RegExp("^(https?:\\/\\/)?" + // protocol
             "((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|" + // domain name
+            "localhost|" + // OR localhost
             "((\\d{1,3}\\.){3}\\d{1,3}))" + // OR ip (v4) address
             "(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*" + // port and path
             "(\\?[;&a-z\\d%_.~+=-]*)?" + // query string
@@ -192,7 +193,7 @@ export const isBoolean = (input) => typeof input === "boolean" ||
  *
  * Note: Specifically checks for string length to determine if it matches the defined password length criterion.
  */
-export const isPassword = (input) => input.length === 161;
+export const isPassword = (input) => typeof input === "string" && input.length === 97;
 /**
  * Checks if the input can be converted to a valid date.
  *
@@ -288,7 +289,7 @@ export const validateFieldType = (value, fieldType, fieldChildrenType) => {
         case "string":
             return isString(value);
         case "password":
-            return isNumber(value) || isString(value) || isPassword(value);
+            return isNumber(value) || isPassword(value) || isString(value);
         case "number":
             return isNumber(value);
         case "html":
@@ -326,43 +327,6 @@ export const validateFieldType = (value, fieldType, fieldChildrenType) => {
             return false;
     }
 };
-/**
- * Converts a nested object to dot notation, flattening the object's structure.
- *
- * @param input - The input object to be converted.
- * @returns A flattened object using dot notation for keys.
- */
-export const objectToDotNotation = (input) => {
-    const result = {};
-    const stack = [
-        { obj: input },
-    ];
-    while (stack.length > 0) {
-        const { obj, parentKey } = stack.pop();
-        for (const key in obj) {
-            if (obj.hasOwnProperty(key)) {
-                const newKey = parentKey ? `${parentKey}.${key}` : key;
-                const value = obj[key];
-                const isArray = Array.isArray(value);
-                const isStringOrNumberArray = isArray &&
-                    value.every((item) => typeof item === "string" || typeof item === "number");
-                if (isStringOrNumberArray) {
-                    // If the property is an array of strings or numbers, keep the array as is
-                    result[newKey] = value;
-                }
-                else if (isObject(value)) {
-                    // If the property is an object, push it onto the stack for further processing
-                    stack.push({ obj: value, parentKey: newKey });
-                }
-                else {
-                    // Otherwise, assign the value to the dot notation key
-                    result[newKey] = value;
-                }
-            }
-        }
-    }
-    return result;
-};
 export function FormatObjectCriteriaValue(value, isParentArray = false) {
     switch (value[0]) {
         case ">":
@@ -436,7 +400,6 @@ export default class Utils {
     static isHTML = isHTML;
     static isIP = isIP;
     static validateFieldType = validateFieldType;
-    static objectToDotNotation = objectToDotNotation;
     static isArrayOfNulls = isArrayOfNulls;
     static FormatObjectCriteriaValue = FormatObjectCriteriaValue;
 }

package/dist/utils.server.d.ts

@@ -45,9 +45,10 @@ export declare const findLastIdNumber: (schema: Schema, secretKeyOrSalt: string
  * @param schema - The schema to update, defined as an array of schema objects.
  * @param oldIndex - The starting index for generating new IDs, defaults to 0.
  * @param secretKeyOrSalt - The secret key or salt for encoding IDs, can be a string, number, or Buffer.
+ * @param encodeIDs - If true, IDs will be encoded, else they will remain as numbers.
  * @returns The updated schema with encoded IDs.
  */
-export declare const addIdToSchema: (schema: Schema, oldIndex: number | undefined, secretKeyOrSalt: string | number | Buffer) => (({
+export declare const addIdToSchema: (schema: Schema, oldIndex: number | undefined, secretKeyOrSalt: string | number | Buffer, encodeIDs?: boolean) => (({
     id?: string | number | undefined;
     key: string;
     required?: boolean | undefined;
@@ -76,7 +77,7 @@ export default class UtilsServer {
     static hashPassword: (password: string) => string;
     static comparePassword: (hashedPassword: string, inputPassword: string) => boolean;
     static findLastIdNumber: (schema: Schema, secretKeyOrSalt: string | number | Buffer) => number;
-    static addIdToSchema: (schema: Schema, oldIndex: number | undefined, secretKeyOrSalt: string | number | Buffer) => (({
+    static addIdToSchema: (schema: Schema, oldIndex: number | undefined, secretKeyOrSalt: string | number | Buffer, encodeIDs?: boolean | undefined) => (({
         id?: string | number | undefined;
         key: string;
         required?: boolean | undefined;

package/dist/utils.server.js

@@ -87,24 +87,25 @@ export const findLastIdNumber = (schema, secretKeyOrSalt) => {
  * @param schema - The schema to update, defined as an array of schema objects.
  * @param oldIndex - The starting index for generating new IDs, defaults to 0.
  * @param secretKeyOrSalt - The secret key or salt for encoding IDs, can be a string, number, or Buffer.
+ * @param encodeIDs - If true, IDs will be encoded, else they will remain as numbers.
  * @returns The updated schema with encoded IDs.
  */
-export const addIdToSchema = (schema, oldIndex = 0, secretKeyOrSalt) => schema.map((field) => {
+export const addIdToSchema = (schema, oldIndex = 0, secretKeyOrSalt, encodeIDs) => schema.map((field) => {
     if (!field.id) {
         oldIndex++;
-        field.id = encodeID(oldIndex, secretKeyOrSalt);
+        field.id = encodeIDs ? encodeID(oldIndex, secretKeyOrSalt) : oldIndex;
     }
     else {
         if (!isNumber(field.id))
             oldIndex = decodeID(field.id, secretKeyOrSalt);
         else {
             oldIndex = field.id;
-            field.id = encodeID(field.id, secretKeyOrSalt);
+            field.id = encodeIDs ? encodeID(field.id, secretKeyOrSalt) : field.id;
         }
     }
     if ((field.type === "array" || field.type === "object") &&
         isArrayOfObjects(field.children)) {
-        field.children = addIdToSchema(field.children, oldIndex, secretKeyOrSalt);
+        field.children = addIdToSchema(field.children, oldIndex, secretKeyOrSalt, encodeIDs);
         oldIndex += field.children.length;
     }
     return field;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.36",
+  "version": "1.0.0-rc.38",
   "author": {
     "name": "Karim Amahtil",
     "email": "karim.amahtil@gmail.com"