inibase 1.2.10 → 1.2.12

package/dist/index.js

@@ -696,19 +696,19 @@ export default class Inibase {
         for (const field of schema) {
             // If the field is of simple type (non-recursive), process it directly
             if (this.isSimpleField(field.type)) {
-                await this.processSimpleField(tableName, field, linesNumber, RETURN, options, prefix);
+                await this.processSimpleField(tableName, field, RETURN, linesNumber, prefix);
             }
             else if (this.isArrayField(field.type)) {
                 // Process array fields (recursive if needed)
-                await this.processArrayField(tableName, field, linesNumber, RETURN, options, prefix);
+                await this.processArrayField(tableName, field, RETURN, linesNumber, options, prefix);
             }
             else if (this.isObjectField(field.type)) {
                 // Process object fields (recursive if needed)
-                await this.processObjectField(tableName, field, linesNumber, RETURN, options, prefix);
+                await this.processObjectField(tableName, field, RETURN, linesNumber, options, prefix);
             }
             else if (this.isTableField(field.type)) {
                 // Process table reference fields
-                await this.processTableField(tableName, field, linesNumber, RETURN, options, prefix);
+                await this.processTableField(tableName, field, RETURN, linesNumber, options, prefix);
             }
         }
         return RETURN;
@@ -721,7 +721,7 @@ export default class Inibase {
         return !complexTypes.includes(fieldType);
     }
     // Process a simple field (non-recursive)
-    async processSimpleField(tableName, field, linesNumber, RETURN, _options, prefix) {
+    async processSimpleField(tableName, field, RETURN, linesNumber, prefix) {
         const fieldPath = join(this.databasePath, tableName, `${prefix ?? ""}${field.key}${this.getFileExtension(tableName)}`);
         if (await File.isExists(fieldPath)) {
             const items = await File.get(fieldPath, linesNumber, {
@@ -751,13 +751,13 @@ export default class Inibase {
             fieldType === "array");
     }
     // Process array fields (recursive if needed)
-    async processArrayField(tableName, field, linesNumber, RETURN, options, prefix) {
+    async processArrayField(tableName, field, RETURN, linesNumber, options, prefix) {
         if (Array.isArray(field.children)) {
             if (this.isSimpleField(field.children)) {
-                await this.processSimpleField(tableName, field, linesNumber, RETURN, options, prefix);
+                await this.processSimpleField(tableName, field, RETURN, linesNumber, prefix);
             }
             else if (this.isTableField(field.children)) {
-                await this.processTableField(tableName, field, linesNumber, RETURN, options, prefix);
+                await this.processTableField(tableName, field, RETURN, linesNumber, options, prefix);
             }
             else {
                 let _fieldChildren = field.children;
@@ -835,10 +835,10 @@ export default class Inibase {
         }
         else if (this.isSimpleField(field.children)) {
             // If `children` is FieldType, handle it as an array of simple types (no recursion needed here)
-            await this.processSimpleField(tableName, field, linesNumber, RETURN, options, prefix);
+            await this.processSimpleField(tableName, field, RETURN, linesNumber, prefix);
         }
         else if (this.isTableField(field.children)) {
-            await this.processTableField(tableName, field, linesNumber, RETURN, options, prefix);
+            await this.processTableField(tableName, field, RETURN, linesNumber, options, prefix);
         }
     }
     // Helper function to check if the field type is object
@@ -849,7 +849,7 @@ export default class Inibase {
                 fieldType.includes("object")));
     }
     // Process object fields (recursive if needed)
-    async processObjectField(tableName, field, linesNumber, RETURN, options, prefix) {
+    async processObjectField(tableName, field, RETURN, linesNumber, options, prefix) {
         if (Array.isArray(field.children)) {
             // If `children` is a Schema (array of Field objects), recurse
             const items = await this.processSchemaData(tableName, field.children, linesNumber, options, `${prefix ?? ""}${field.key}.`);
@@ -873,7 +873,7 @@ export default class Inibase {
                 fieldType.includes("table")));
     }
     // Process table reference fields
-    async processTableField(tableName, field, linesNumber, RETURN, options, prefix) {
+    async processTableField(tableName, field, RETURN, linesNumber, options, prefix) {
         if (field.table &&
             (await File.isExists(join(this.databasePath, field.table)))) {
             const fieldPath = join(this.databasePath, tableName, `${prefix ?? ""}${field.key}${this.getFileExtension(tableName)}`);
@@ -899,7 +899,7 @@ export default class Inibase {
                             .flat()
                             .filter((item) => item), {
                             ...options,
-                            perPage: Number.POSITIVE_INFINITY,
+                            perPage: -1,
                             columns: options.columns
                                 ?.filter((column) => column.includes(`${field.key}.`))
                                 .map((column) => column.replace(`${field.key}.`, "")),
@@ -960,7 +960,7 @@ export default class Inibase {
                 if (field.table && Utils.isObject(value)) {
                     const items = await this.get(field.table, value, {
                         columns: "id",
-                        perPage: Number.POSITIVE_INFINITY,
+                        perPage: -1,
                     });
                     if (items?.length)
                         value = `[]${items.map(({ id }) => id)}`;
@@ -1013,8 +1013,10 @@ export default class Inibase {
                     ...field,
                     databasePath: this.databasePath,
                     table: field.table ?? tableName,
-                }, options.perPage, (options.page - 1) * options.perPage +
-                    (options.page > 1 ? 1 : 0), true);
+                }, options.perPage < 0 ? undefined : options.perPage, options.perPage < 0
+                    ? undefined
+                    : (options.page - 1) * options.perPage +
+                        (options.page > 1 ? 1 : 0), true);
                 if (!searchResult) {
                     if (allTrue)
                         return null;
@@ -1223,9 +1225,11 @@ export default class Inibase {
         }
         if (!where) {
             // Display all data
-            RETURN = Object.values(await this.processSchemaData(tableName, schema, Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
-                index +
-                1), options));
+            RETURN = Object.values(await this.processSchemaData(tableName, schema, options.perPage < 0
+                ? undefined
+                : Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
+                    index +
+                    1), options));
             if (!this.totalItems.has(`${tableName}-*`))
                 this.totalItems.set(`${tableName}-*`, pagination[1]);
         }

package/dist/utils.server.d.ts

@@ -23,7 +23,8 @@ export declare const hashPassword: (password: string) => string;
  */
 export declare const comparePassword: (hash: string, password: string) => boolean;
 export declare const encodeID: (id: number | string) => string;
-export declare const decodeID: (input?: string) => number;
+export declare function decodeID(input: string, raw: true): string;
+export declare function decodeID(input?: string, raw?: false): number;
 export declare const extractIdsFromSchema: (schema: Schema) => number[];
 /**
  * Finds the last ID number in a schema, potentially decoding it if encrypted.

package/dist/utils.server.js

@@ -54,18 +54,17 @@ const getKeyAndIv = () => {
     }
     return { key, iv: key.subarray(0, 16) };
 };
-// Optimized encodeID
 export const encodeID = (id) => {
     const { key, iv } = getKeyAndIv();
     const cipher = createCipheriv("aes-256-cbc", key, iv);
     return cipher.update(id.toString(), "utf8", "hex") + cipher.final("hex");
 };
-// Optimized decodeID
-export const decodeID = (input) => {
+export function decodeID(input, raw) {
     const { key, iv } = getKeyAndIv();
     const decipher = createDecipheriv("aes-256-cbc", key, iv);
-    return Number(decipher.update(input, "hex", "utf8") + decipher.final("utf8"));
-};
+    const rawData = decipher.update(input, "hex", "utf8") + decipher.final("utf8");
+    return raw ? rawData : Number(rawData);
+}
 // Function to recursively flatten an array of objects and their nested children
 export const extractIdsFromSchema = (schema) => {
     const result = [];

package/package.json

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