inibase 1.2.20 → 1.4.0

package/dist/index.d.ts

@@ -7,7 +7,7 @@ export interface Data {
 }
 export type FieldType = "string" | "number" | "boolean" | "date" | "email" | "url" | "table" | "object" | "array" | "password" | "html" | "ip" | "json" | "id";
 export type Field = {
-    id?: string | number;
+    id?: number;
     key: string;
     type: FieldType | FieldType[];
     required?: boolean;
@@ -63,18 +63,24 @@ export declare const globalConfig: {
 } & {
     salt?: string | Buffer;
 };
+/**
+ * @param {string} database - Database name
+ * @param {string} [mainFolder="."] - Main folder path
+ * @param {ErrorLang} [language="en"] - Language for error messages
+ */
 export default class Inibase {
     pageInfo: Record<string, pageInfo>;
     language: ErrorLang;
     fileExtension: string;
+    totalItems: Map<string, number>;
     private databasePath;
     private uniqueMap;
-    totalItems: Map<string, number>;
+    private schemaFileExtension;
     constructor(database: string, mainFolder?: string, language?: ErrorLang);
     private static errorMessages;
     createError(name: ErrorCode, variable?: string | number | (string | number)[]): Error;
     private getFileExtension;
-    private _schemaToIdsPath;
+    private schemaToIdsPath;
     /**
      * Create a new table inside database, with predefined schema and config
      *
@@ -100,11 +106,11 @@ export default class Inibase {
      * @param {string} tableName
      * @return {*}  {Promise<TableObject>}
      */
-    getTable(tableName: string, encodeIDs?: boolean): Promise<TableObject>;
-    getTableSchema(tableName: string, encodeIDs?: boolean): Promise<Schema>;
+    getTable(tableName: string): Promise<TableObject>;
+    getTableSchema(tableName: string): Promise<Schema>;
     private throwErrorIfTableEmpty;
-    private _validateData;
-    private validateData;
+    validateData(data: Data | Data[], schema: Schema, skipRequiredField?: boolean): void;
+    private validateTableData;
     private cleanObject;
     private formatField;
     private checkUnique;

package/dist/index.js

@@ -25,13 +25,19 @@ export const ERROR_CODES = [
 // hide ExperimentalWarning glob()
 process.removeAllListeners("warning");
 export const globalConfig = {};
+/**
+ * @param {string} database - Database name
+ * @param {string} [mainFolder="."] - Main folder path
+ * @param {ErrorLang} [language="en"] - Language for error messages
+ */
 export default class Inibase {
     pageInfo;
     language;
     fileExtension = ".txt";
+    totalItems;
     databasePath;
     uniqueMap;
-    totalItems;
+    schemaFileExtension = process.env.INIBASE_SCHEMA_EXTENSION ?? "json";
     constructor(database, mainFolder = ".", language = "en") {
         this.databasePath = join(mainFolder, database);
         this.language = language;
@@ -137,15 +143,16 @@ export default class Inibase {
             mainExtension += ".gz";
         return mainExtension;
     }
-    _schemaToIdsPath(tableName, schema, prefix = "") {
+    schemaToIdsPath(tableName, schema, prefix = "") {
         const RETURN = {};
         for (const field of schema)
             if ((field.type === "array" || field.type === "object") &&
                 field.children &&
                 Utils.isArrayOfObjects(field.children))
-                Utils.deepMerge(RETURN, this._schemaToIdsPath(tableName, field.children, `${(prefix ?? "") + field.key}.`));
+                Utils.deepMerge(RETURN, this.schemaToIdsPath(tableName, field.children, `${(prefix ?? "") + field.key}.`));
             else if (field.id)
-                RETURN[Utils.isValidID(field.id) ? UtilsServer.decodeID(field.id) : field.id] = `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`;
+                RETURN[field.id] =
+                    `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`;
         return RETURN;
     }
     /**
@@ -179,7 +186,9 @@ export default class Inibase {
         }
         if (schema) {
             const lastSchemaID = { value: 0 };
-            await writeFile(join(tablePath, "schema.json"), JSON.stringify(UtilsServer.addIdToSchema(schema, lastSchemaID), null, 2));
+            await writeFile(join(tablePath, `schema.${this.schemaFileExtension}`), this.schemaFileExtension === "json"
+                ? JSON.stringify(Utils.addIdToSchema(schema, lastSchemaID), null, 2)
+                : Inison.stringify(Utils.addIdToSchema(schema, lastSchemaID)));
             await writeFile(join(tablePath, `${lastSchemaID.value}.schema`), "");
         }
         else
@@ -213,21 +222,25 @@ export default class Inibase {
             const lastSchemaID = {
                 value: schemaIdFilePath ? Number(parse(schemaIdFilePath).name) : 0,
             };
-            if (await File.isExists(join(tablePath, "schema.json"))) {
-                // update columns files names based on field id
-                schema = UtilsServer.addIdToSchema(schema, lastSchemaID);
-                if (table.schema?.length) {
-                    const replaceOldPathes = Utils.findChangedProperties(this._schemaToIdsPath(tableName, table.schema), this._schemaToIdsPath(tableName, schema));
-                    if (replaceOldPathes)
-                        await Promise.all(Object.entries(replaceOldPathes).map(async ([oldPath, newPath]) => {
-                            if (await File.isExists(join(tablePath, oldPath)))
+            schema = Utils.addIdToSchema(schema, lastSchemaID);
+            // if schema.json exists, update columns files names based on field id
+            if ((await File.isExists(join(tablePath, `schema.${this.schemaFileExtension}`))) &&
+                table.schema?.length) {
+                const replaceOldPathes = Utils.findChangedProperties(this.schemaToIdsPath(tableName, table.schema), this.schemaToIdsPath(tableName, schema));
+                if (replaceOldPathes)
+                    await Promise.all(Object.entries(replaceOldPathes).map(async ([oldPath, newPath]) => {
+                        if (await File.isExists(join(tablePath, oldPath))) {
+                            // if newPath is null, it means the field was removed
+                            if (newPath === null)
+                                await unlink(join(tablePath, oldPath));
+                            else
                                 await rename(join(tablePath, oldPath), join(tablePath, newPath));
-                        }));
-                }
+                        }
+                    }));
             }
-            else
-                schema = UtilsServer.addIdToSchema(schema, lastSchemaID);
-            await writeFile(join(tablePath, "schema.json"), JSON.stringify(schema, null, 2));
+            await writeFile(join(tablePath, `schema.${this.schemaFileExtension}`), this.schemaFileExtension === "json"
+                ? JSON.stringify(schema, null, 2)
+                : Inison.stringify(schema));
             if (schemaIdFilePath)
                 await rename(schemaIdFilePath, join(tablePath, `${lastSchemaID.value}.schema`));
             else
@@ -294,10 +307,16 @@ export default class Inibase {
             if (config.name) {
                 await rename(tablePath, join(this.databasePath, config.name));
                 // replace table name in other linked tables (relationship)
-                for await (const schemaPath of glob("**/schema.json", {
+                for await (const schemaPath of glob(`**/schema.${this.schemaFileExtension}`, {
                     cwd: this.databasePath,
                 }))
-                    await this.replaceStringInFile(schemaPath, `"table": "${tableName}"`, `"table": "${config.name}"`);
+                    await this.replaceStringInFile(schemaPath, 
+                    // TODO: escape caracters in table name
+                    this.schemaFileExtension === "json"
+                        ? `"table": "${tableName}"`
+                        : `table:${tableName}`, this.schemaFileExtension === "json"
+                        ? `"table": "${config.name}"`
+                        : `table:${config.name}`);
             }
         }
         globalConfig[this.databasePath].tables.delete(tableName);
@@ -308,7 +327,7 @@ export default class Inibase {
      * @param {string} tableName
      * @return {*}  {Promise<TableObject>}
      */
-    async getTable(tableName, encodeIDs = true) {
+    async getTable(tableName) {
         const tablePath = join(this.databasePath, tableName);
         if (!(await File.isExists(tablePath)))
             throw this.createError("TABLE_NOT_EXISTS", tableName);
@@ -316,7 +335,7 @@ export default class Inibase {
             globalConfig[this.databasePath].tables.get(tableName).timestamp !==
                 (await File.getFileDate(join(tablePath, "schema.json"))))
             globalConfig[this.databasePath].tables.set(tableName, {
-                schema: await this.getTableSchema(tableName, encodeIDs),
+                schema: await this.getTableSchema(tableName),
                 config: {
                     compression: await File.isExists(join(tablePath, ".compression.config")),
                     cache: await File.isExists(join(tablePath, ".cache.config")),
@@ -327,15 +346,36 @@ export default class Inibase {
             });
         return globalConfig[this.databasePath].tables.get(tableName);
     }
-    async getTableSchema(tableName, encodeIDs = true) {
+    async getTableSchema(tableName) {
         const tablePath = join(this.databasePath, tableName);
-        if (!(await File.isExists(join(tablePath, "schema.json"))))
-            return undefined;
-        const schemaFile = await readFile(join(tablePath, "schema.json"), "utf8");
+        let schemaFile;
+        let schema;
+        if (!(await File.isExists(join(tablePath, `schema.${this.schemaFileExtension}`)))) {
+            const otherSchemaFileExtension = this.schemaFileExtension === "json" ? "inis" : "json";
+            if (!(await File.isExists(join(tablePath, `schema.${otherSchemaFileExtension}`))))
+                return undefined;
+            schemaFile = await readFile(join(tablePath, `schema.${otherSchemaFileExtension}`), "utf8");
+            if (!schemaFile)
+                return undefined;
+            schema =
+                otherSchemaFileExtension === "json"
+                    ? JSON.parse(schemaFile)
+                    : Inison.unstringify(schemaFile);
+            await writeFile(join(tablePath, `schema.${this.schemaFileExtension}`), this.schemaFileExtension === "json"
+                ? JSON.stringify(schema, null, 2)
+                : Inison.stringify(schema));
+            await unlink(join(tablePath, `schema.${otherSchemaFileExtension}`));
+        }
+        else
+            schemaFile = await readFile(join(tablePath, `schema.${this.schemaFileExtension}`), "utf8");
         if (!schemaFile)
             return undefined;
-        let schema = JSON.parse(schemaFile);
-        schema = [
+        if (!schema)
+            schema =
+                this.schemaFileExtension === "json"
+                    ? JSON.parse(schemaFile)
+                    : Inison.unstringify(schemaFile);
+        return [
             {
                 id: 0,
                 key: "id",
@@ -355,21 +395,18 @@ export default class Inibase {
                 type: "date",
             },
         ];
-        if (!encodeIDs)
-            return schema;
-        return UtilsServer.encodeSchemaID(schema);
     }
     async throwErrorIfTableEmpty(tableName) {
-        const table = await this.getTable(tableName, false);
+        const table = await this.getTable(tableName);
         if (!table.schema)
             throw this.createError("NO_SCHEMA", tableName);
         if (!(await File.isExists(join(this.databasePath, tableName, `id${this.getFileExtension(tableName)}`))))
             throw this.createError("TABLE_EMPTY", tableName);
     }
-    _validateData(data, schema, skipRequiredField = false) {
+    validateData(data, schema, skipRequiredField = false) {
         if (Utils.isArrayOfObjects(data)) {
             for (const single_data of data)
-                this._validateData(single_data, schema, skipRequiredField);
+                this.validateData(single_data, schema, skipRequiredField);
             return;
         }
         if (Utils.isObject(data)) {
@@ -398,7 +435,7 @@ export default class Inibase {
                 if ((field.type === "array" || field.type === "object") &&
                     field.children &&
                     Utils.isArrayOfObjects(field.children))
-                    this._validateData(data[field.key], field.children, skipRequiredField);
+                    this.validateData(data[field.key], field.children, skipRequiredField);
                 else {
                     if (field.table &&
                         Utils.isObject(data[field.key]) &&
@@ -420,9 +457,7 @@ export default class Inibase {
                                 exclude: new Set(),
                                 columnsValues: new Map(),
                             });
-                        if (!this.uniqueMap
-                            .get(uniqueKey)
-                            .columnsValues.has(field.id))
+                        if (!this.uniqueMap.get(uniqueKey).columnsValues.has(field.id))
                             this.uniqueMap
                                 .get(uniqueKey)
                                 .columnsValues.set(field.id, new Set());
@@ -437,10 +472,10 @@ export default class Inibase {
             }
         }
     }
-    async validateData(tableName, data, skipRequiredField = false) {
+    async validateTableData(tableName, data, skipRequiredField = false) {
         const clonedData = structuredClone(data);
         // Skip ID and (created|updated)At
-        this._validateData(clonedData, globalConfig[this.databasePath].tables.get(tableName).schema.slice(1, -2), skipRequiredField);
+        this.validateData(clonedData, globalConfig[this.databasePath].tables.get(tableName).schema.slice(1, -2), skipRequiredField);
         await this.checkUnique(tableName);
     }
     cleanObject(obj) {
@@ -1053,7 +1088,7 @@ export default class Inibase {
             const searchResult = await this.applyCriteria(tableName, options, criteriaAND, true, searchIn);
             if (searchResult) {
                 searchIn = new Set(Object.keys(searchResult).map(Number));
-                RETURN = Utils.deepMerge(RETURN, Object.fromEntries(Object.entries(searchResult).filter(([_k, v], _i) => Object.keys(v).filter((key) => Object.keys(criteriaAND).includes(key)).length)));
+                RETURN = Utils.deepMerge(RETURN, Object.fromEntries(Object.entries(searchResult).filter(([_k, v], _i) => Object.keys(v).filter((key) => Object.keys(criteriaAND).find((criteriaKey) => criteriaKey === key || criteriaKey.startsWith(`${key}.`))).length)));
             }
             else
                 return null;
@@ -1355,7 +1390,7 @@ export default class Inibase {
             returnPostedData = false;
         let clonedData = structuredClone(data);
         const keys = UtilsServer.hashString(Object.keys(Array.isArray(clonedData) ? clonedData[0] : clonedData).join("."));
-        await this.validateData(tableName, clonedData);
+        await this.validateTableData(tableName, clonedData);
         const renameList = [];
         try {
             await File.lock(join(tablePath, ".tmp"), keys);
@@ -1437,7 +1472,7 @@ export default class Inibase {
                     throw this.createError("INVALID_ID", clonedData.id);
                 return this.put(tableName, clonedData, clonedData.id, options, returnUpdatedData);
             }
-            await this.validateData(tableName, clonedData, true);
+            await this.validateTableData(tableName, clonedData, true);
             clonedData = this.formatData(clonedData, globalConfig[this.databasePath].tables.get(tableName).schema, true);
             const pathesContents = this.joinPathesContents(tableName, {
                 ...(({ id, ...restOfData }) => restOfData)(clonedData),
@@ -1469,7 +1504,7 @@ export default class Inibase {
             (_whereIsLinesNumbers ||
                 !globalConfig[this.databasePath].tables.get(tableName).config.decodeID)) {
             // "where" in this case, is the line(s) number(s) and not id(s)
-            await this.validateData(tableName, clonedData, true);
+            await this.validateTableData(tableName, clonedData, true);
             clonedData = this.formatData(clonedData, globalConfig[this.databasePath].tables.get(tableName).schema, true);
             const pathesContents = Object.fromEntries(Object.entries(this.joinPathesContents(tableName, Array.isArray(clonedData)
                 ? clonedData.map((item) => ({

package/dist/utils.d.ts

@@ -200,3 +200,21 @@ export declare const setField: (keyPath: string, schema: Schema, field: Omit<Fie
  */
 export declare const unsetField: (keyPath: string, schema: Schema) => Field;
 export declare function toDotNotation(obj: Record<string, any>, skipKeys?: string[], currentPath?: string): Record<string, any>;
+export declare const extractIdsFromSchema: (schema: Schema) => number[];
+/**
+ * Finds the last ID number in a schema, potentially decoding it if encrypted.
+ *
+ * @param schema - The schema to search, defined as an array of schema objects.
+ * @returns The last ID number in the schema, decoded if necessary.
+ */
+export declare const findLastIdNumber: (schema: Schema) => number;
+/**
+ * Adds or updates IDs in a schema, encoding them using a provided secret key or salt.
+ *
+ * @param schema - The schema to update, defined as an array of schema objects.
+ * @param startWithID - An object containing the starting ID for generating new IDs.
+ * @returns The updated schema with encoded IDs.
+ */
+export declare function addIdToSchema(schema: Schema, startWithID: {
+    value: number;
+}): Field[];

package/dist/utils.js

@@ -226,9 +226,14 @@ export const deepMerge = (target, source) => {
  */
 export const findChangedProperties = (obj1, obj2) => {
     const result = {};
-    for (const key1 in obj1)
-        if (Object.hasOwn(obj2, key1) && obj1[key1] !== obj2[key1])
-            result[obj1[key1]] = obj2[key1];
+    for (const key1 in obj1) {
+        if (Object.hasOwn(obj2, key1)) {
+            if (obj1[key1] !== obj2[key1])
+                result[obj1[key1]] = obj2[key1];
+        }
+        else
+            result[obj1[key1]] = null;
+    }
     return Object.keys(result).length ? result : null;
 };
 /**
@@ -583,3 +588,43 @@ export function toDotNotation(obj, skipKeys, currentPath = "") {
     }
     return result;
 }
+// Function to recursively flatten an array of objects and their nested children
+export const extractIdsFromSchema = (schema) => {
+    const result = [];
+    for (const field of schema) {
+        if (field.id)
+            result.push(field.id);
+        if (field.children && isArrayOfObjects(field.children))
+            result.push(...extractIdsFromSchema(field.children));
+    }
+    return result;
+};
+/**
+ * Finds the last ID number in a schema, potentially decoding it if encrypted.
+ *
+ * @param schema - The schema to search, defined as an array of schema objects.
+ * @returns The last ID number in the schema, decoded if necessary.
+ */
+export const findLastIdNumber = (schema) => Math.max(...extractIdsFromSchema(schema));
+/**
+ * Adds or updates IDs in a schema, encoding them using a provided secret key or salt.
+ *
+ * @param schema - The schema to update, defined as an array of schema objects.
+ * @param startWithID - An object containing the starting ID for generating new IDs.
+ * @returns The updated schema with encoded IDs.
+ */
+export function addIdToSchema(schema, startWithID) {
+    const clonedSchema = structuredClone(schema);
+    function addIdToField(field) {
+        if (!field.id) {
+            startWithID.value++;
+            field.id = startWithID.value;
+        }
+        if ((field.type === "array" || field.type === "object") &&
+            isArrayOfObjects(field.children))
+            field.children = addIdToSchemaHelper(field.children);
+        return field;
+    }
+    const addIdToSchemaHelper = (schema) => schema.map(addIdToField);
+    return addIdToSchemaHelper(clonedSchema);
+}

package/dist/utils.server.d.ts

@@ -2,7 +2,7 @@ import "dotenv/config";
 import { execFile as execFileSync, exec as execSync } from "node:child_process";
 import { gunzip as gunzipSync, gzip as gzipSync } from "node:zlib";
 import RE2 from "re2";
-import type { ComparisonOperator, Field, FieldType, Schema } from "./index.js";
+import type { ComparisonOperator, FieldType } from "./index.js";
 export declare const exec: typeof execSync.__promisify__;
 export declare const execFile: typeof execFileSync.__promisify__;
 export declare const gzip: typeof gzipSync.__promisify__;
@@ -25,25 +25,6 @@ export declare const comparePassword: (hash: string, password: string) => boolea
 export declare const encodeID: (id: number | string) => string;
 export declare function decodeID(input: string, raw: true): string | null;
 export declare function decodeID(input?: string, raw?: false): number | null;
-export declare const extractIdsFromSchema: (schema: Schema) => number[];
-/**
- * Finds the last ID number in a schema, potentially decoding it if encrypted.
- *
- * @param schema - The schema to search, defined as an array of schema objects.
- * @returns The last ID number in the schema, decoded if necessary.
- */
-export declare const findLastIdNumber: (schema: Schema) => number;
-/**
- * Adds or updates IDs in a schema, encoding them using a provided secret key or salt.
- *
- * @param schema - The schema to update, defined as an array of schema objects.
- * @param startWithID - An object containing the starting ID for generating new IDs.
- * @returns The updated schema with encoded IDs.
- */
-export declare const addIdToSchema: (schema: Schema, startWithID: {
-    value: number;
-}) => Field[];
-export declare const encodeSchemaID: (schema: Schema) => Schema;
 export declare const hashString: (str: string) => string;
 /**
  * Evaluates a comparison between two values based on a specified operator and field types.

package/dist/utils.server.js

@@ -5,7 +5,7 @@ import { promisify } from "node:util";
 import { gunzip as gunzipSync, gzip as gzipSync } from "node:zlib";
 import RE2 from "re2";
 import { globalConfig } from "./index.js";
-import { detectFieldType, isArrayOfObjects, isNumber, isPassword, isValidID, } from "./utils.js";
+import { detectFieldType, isNumber, isPassword } from "./utils.js";
 export const exec = promisify(execSync);
 export const execFile = promisify(execFileSync);
 export const gzip = promisify(gzipSync);
@@ -70,58 +70,6 @@ export function decodeID(input, raw) {
         return null;
     }
 }
-// Function to recursively flatten an array of objects and their nested children
-export const extractIdsFromSchema = (schema) => {
-    const result = [];
-    for (const field of schema) {
-        if (field.id)
-            result.push(typeof field.id === "number" ? field.id : decodeID(field.id));
-        if (field.children && isArrayOfObjects(field.children))
-            result.push(...extractIdsFromSchema(field.children));
-    }
-    return result;
-};
-/**
- * Finds the last ID number in a schema, potentially decoding it if encrypted.
- *
- * @param schema - The schema to search, defined as an array of schema objects.
- * @returns The last ID number in the schema, decoded if necessary.
- */
-export const findLastIdNumber = (schema) => Math.max(...extractIdsFromSchema(schema));
-/**
- * Adds or updates IDs in a schema, encoding them using a provided secret key or salt.
- *
- * @param schema - The schema to update, defined as an array of schema objects.
- * @param startWithID - An object containing the starting ID for generating new IDs.
- * @returns The updated schema with encoded IDs.
- */
-export const addIdToSchema = (schema, startWithID) => {
-    function _addIdToField(field) {
-        if (!field.id) {
-            startWithID.value++;
-            field.id = startWithID.value;
-        }
-        else if (isValidID(field.id))
-            field.id = decodeID(field.id);
-        if ((field.type === "array" || field.type === "object") &&
-            isArrayOfObjects(field.children))
-            field.children = _addIdToSchema(field.children);
-        return field;
-    }
-    const _addIdToSchema = (schema) => schema.map(_addIdToField);
-    return _addIdToSchema(schema);
-};
-export const encodeSchemaID = (schema) => schema.map((field) => ({
-    ...field,
-    id: isNumber(field.id) ? encodeID(field.id) : field.id,
-    ...(field.children
-        ? isArrayOfObjects(field.children)
-            ? {
-                children: encodeSchemaID(field.children),
-            }
-            : { children: field.children }
-        : {}),
-}));
 export const hashString = (str) => createHash("sha256").update(str).digest("hex");
 /**
  * Evaluates a comparison between two values based on a specified operator and field types.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.2.20",
+  "version": "1.4.0",
   "type": "module",
   "author": {
     "name": "Karim Amahtil",