inibase 1.1.21 → 1.1.23

package/dist/utils.js

@@ -284,30 +284,28 @@ export const detectFieldType = (input, availableTypes) => {
             return "array";
     return undefined;
 };
-export const isFieldType = (compareAtType, fieldType, fieldChildrenType) => {
-    if (fieldType) {
-        if (Array.isArray(fieldType)) {
-            if (fieldType.some((type) => Array.isArray(compareAtType)
-                ? compareAtType.includes(type)
-                : compareAtType === type))
-                return true;
-        }
-        else if ((Array.isArray(compareAtType) && compareAtType.includes(fieldType)) ||
-            compareAtType === fieldType)
+export const isFieldType = (field, compareAtType) => {
+    if (Array.isArray(field.type)) {
+        if (field.type.some((type) => Array.isArray(compareAtType)
+            ? compareAtType.includes(type)
+            : compareAtType === type))
             return true;
     }
-    if (fieldChildrenType) {
-        if (Array.isArray(fieldChildrenType)) {
-            if (!isArrayOfObjects(fieldChildrenType)) {
-                if (fieldChildrenType.some((type) => Array.isArray(compareAtType)
+    else if ((Array.isArray(compareAtType) && compareAtType.includes(field.type)) ||
+        compareAtType === field.type)
+        return true;
+    if (field.children) {
+        if (Array.isArray(field.children)) {
+            if (!isArrayOfObjects(field.children)) {
+                if (field.children.some((type) => Array.isArray(compareAtType)
                     ? compareAtType.includes(type)
                     : compareAtType === type))
                     return true;
             }
         }
         else if ((Array.isArray(compareAtType) &&
-            compareAtType.includes(fieldChildrenType)) ||
-            compareAtType === fieldChildrenType)
+            compareAtType.includes(field.children)) ||
+            compareAtType === field.children)
             return true;
     }
     return false;
@@ -341,32 +339,35 @@ export const filterSchema = (schema, callback) => schema.filter((field) => {
  * Validates if the given value matches the specified field type(s).
  *
  * @param value - The value to be validated.
- * @param fieldType - The expected field type or an array of possible field types.
- * @param fieldChildrenType - Optional; the expected type(s) of children elements, used if the field type is an array.
+ * @param field - Field object config.
  * @returns A boolean indicating whether the value matches the specified field type(s).
  */
-export const validateFieldType = (value, fieldType, fieldChildrenType) => {
+export const validateFieldType = (value, field) => {
     if (value === null)
         return true;
-    if (Array.isArray(fieldType)) {
-        const detectedFieldType = detectFieldType(value, fieldType);
+    if (Array.isArray(field.type)) {
+        const detectedFieldType = detectFieldType(value, field.type);
         if (!detectedFieldType)
             return false;
-        fieldType = detectedFieldType;
+        field.type = detectedFieldType;
     }
-    if (fieldType === "array" && fieldChildrenType)
+    if (field.type === "array" && field.children)
         return (Array.isArray(value) &&
-            value.every((v) => {
-                let _fieldChildrenType = fieldChildrenType;
-                if (Array.isArray(_fieldChildrenType)) {
-                    const detectedFieldType = detectFieldType(v, _fieldChildrenType);
-                    if (!detectedFieldType)
-                        return false;
-                    _fieldChildrenType = detectedFieldType;
-                }
-                return validateFieldType(v, _fieldChildrenType);
-            }));
-    switch (fieldType) {
+            (isArrayOfObjects(field.children) ||
+                value.every((v) => {
+                    let _fieldChildrenType = field.children;
+                    if (Array.isArray(_fieldChildrenType)) {
+                        const detectedFieldType = detectFieldType(v, _fieldChildrenType);
+                        if (!detectedFieldType)
+                            return false;
+                        _fieldChildrenType = detectedFieldType;
+                    }
+                    return validateFieldType(v, {
+                        key: "BLABLA",
+                        type: _fieldChildrenType,
+                    });
+                })));
+    switch (field.type) {
         case "string":
             return isString(value);
         case "password":

package/dist/utils.server.d.ts

@@ -1,7 +1,7 @@
-import { exec as execSync, execFile as execFileSync } from "node:child_process";
+import { execFile as execFileSync, exec as execSync } from "node:child_process";
 import { gunzip as gunzipSync, gzip as gzipSync } from "node:zlib";
-import type { ComparisonOperator, Field, FieldType, Schema } from "./index.js";
 import RE2 from "re2";
+import type { ComparisonOperator, Field, FieldType, Schema } from "./index.js";
 export declare const exec: typeof execSync.__promisify__;
 export declare const execFile: typeof execFileSync.__promisify__;
 export declare const gzip: typeof gzipSync.__promisify__;
@@ -21,30 +21,27 @@ export declare const hashPassword: (password: string) => string;
  * @returns A boolean indicating whether the input password matches the hashed password.
  */
 export declare const comparePassword: (hash: string, password: string) => boolean;
-export declare const encodeID: (id: number | string, secretKeyOrSalt: string | number | Buffer) => string;
-export declare const decodeID: (input: string, secretKeyOrSalt: string | number | Buffer) => number;
-export declare const extractIdsFromSchema: (schema: Schema, secretKeyOrSalt: string | number | Buffer) => number[];
+export declare const encodeID: (id: number | string) => string;
+export declare const decodeID: (input: string) => number;
+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.
- * @param secretKeyOrSalt - The secret key or salt for decoding an encrypted ID, can be a string, number, or Buffer.
  * @returns The last ID number in the schema, decoded if necessary.
  */
-export declare const findLastIdNumber: (schema: Schema, secretKeyOrSalt: string | number | Buffer) => number;
+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.
- * @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, startWithID: {
     value: number;
-}, secretKeyOrSalt: string | number | Buffer, encodeIDs?: boolean) => Field[];
-export declare const encodeSchemaID: (schema: Schema, secretKeyOrSalt: string | number | Buffer) => Schema;
+}) => 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.
@@ -52,8 +49,7 @@ export declare const hashString: (str: string) => string;
  * @param operator - The comparison operator (e.g., '=', '!=', '>', '<', '>=', '<=', '[]', '![]', '*', '!*').
  * @param originalValue - The value to compare, can be a single value or an array of values.
  * @param comparedValue - The value or values to compare against.
- * @param fieldType - Optional type of the field to guide comparison (e.g., 'password', 'boolean').
- * @param fieldChildrenType - Optional type for child elements in array inputs.
+ * @param fieldType - Optional type of the field.
  * @returns boolean - Result of the comparison operation.
  *
  * Note: Handles various data types and comparison logic, including special handling for passwords and regex patterns.
@@ -64,7 +60,7 @@ export declare const compare: (operator: ComparisonOperator, originalValue: stri
  *
  * @param originalValue - The original value.
  * @param comparedValue - The value to compare against.
- * @param fieldType - Type of the field.
+ * @param field - Field object config.
  * @returns boolean - Result of the equality check.
  */
 export declare const isEqual: (originalValue: string | number | boolean | null | (string | number | boolean | null)[], comparedValue: string | number | boolean | null | (string | number | boolean | null)[], fieldType?: FieldType) => boolean;

package/dist/utils.server.js

@@ -1,9 +1,10 @@
-import { exec as execSync, execFile as execFileSync } from "node:child_process";
+import { execFile as execFileSync, exec as execSync } from "node:child_process";
 import { createCipheriv, createDecipheriv, createHash, randomBytes, scryptSync, } from "node:crypto";
-import { gunzip as gunzipSync, gzip as gzipSync } from "node:zlib";
 import { promisify } from "node:util";
-import { detectFieldType, isArrayOfObjects, isNumber, isPassword, isValidID, } from "./utils.js";
+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";
 export const exec = promisify(execSync);
 export const execFile = promisify(execFileSync);
 export const gzip = promisify(gzipSync);
@@ -38,11 +39,11 @@ export const comparePassword = (hash, password) => {
 // Cache for derived keys if using scrypt
 const derivedKeyCache = new Map();
 // Helper function to create cipher or decipher
-const getKeyAndIv = (secretKeyOrSalt) => {
-    if (Buffer.isBuffer(secretKeyOrSalt)) {
-        return { key: secretKeyOrSalt, iv: secretKeyOrSalt.subarray(0, 16) };
+const getKeyAndIv = () => {
+    if (Buffer.isBuffer(globalConfig.salt)) {
+        return { key: globalConfig.salt, iv: globalConfig.salt.subarray(0, 16) };
     }
-    const cacheKey = secretKeyOrSalt.toString();
+    const cacheKey = globalConfig.salt.toString();
     let key = derivedKeyCache.get(cacheKey);
     if (!key) {
         key = scryptSync(cacheKey, `${INIBASE_SECRET}`, 32);
@@ -53,27 +54,25 @@ const getKeyAndIv = (secretKeyOrSalt) => {
 // Ensure the environment variable is read once
 const INIBASE_SECRET = process.env.INIBASE_SECRET ?? "inibase";
 // Optimized encodeID
-export const encodeID = (id, secretKeyOrSalt) => {
-    const { key, iv } = getKeyAndIv(secretKeyOrSalt);
+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, secretKeyOrSalt) => {
-    const { key, iv } = getKeyAndIv(secretKeyOrSalt);
+export const decodeID = (input) => {
+    const { key, iv } = getKeyAndIv();
     const decipher = createDecipheriv("aes-256-cbc", key, iv);
     return Number(decipher.update(input, "hex", "utf8") + decipher.final("utf8"));
 };
 // Function to recursively flatten an array of objects and their nested children
-export const extractIdsFromSchema = (schema, secretKeyOrSalt) => {
+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, secretKeyOrSalt));
+            result.push(typeof field.id === "number" ? field.id : decodeID(field.id));
         if (field.children && isArrayOfObjects(field.children))
-            result.push(...extractIdsFromSchema(field.children, secretKeyOrSalt));
+            result.push(...extractIdsFromSchema(field.children));
     }
     return result;
 };
@@ -81,35 +80,24 @@ export const extractIdsFromSchema = (schema, secretKeyOrSalt) => {
  * 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.
- * @param secretKeyOrSalt - The secret key or salt for decoding an encrypted ID, can be a string, number, or Buffer.
  * @returns The last ID number in the schema, decoded if necessary.
  */
-export const findLastIdNumber = (schema, secretKeyOrSalt) => Math.max(...extractIdsFromSchema(schema, secretKeyOrSalt));
+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.
- * @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, startWithID, secretKeyOrSalt, encodeIDs) => {
+export const addIdToSchema = (schema, startWithID) => {
     function _addIdToField(field) {
         if (!field.id) {
             startWithID.value++;
-            field.id = encodeIDs
-                ? encodeID(startWithID.value, secretKeyOrSalt)
-                : startWithID.value;
-        }
-        else {
-            if (isValidID(field.id)) {
-                if (!encodeIDs)
-                    field.id = decodeID(field.id, secretKeyOrSalt);
-            }
-            else if (encodeIDs)
-                field.id = encodeID(field.id, secretKeyOrSalt);
+            field.id = encodeID(startWithID.value);
         }
+        else
+            field.id = isValidID(field.id) ? decodeID(field.id) : encodeID(field.id);
         if ((field.type === "array" || field.type === "object") &&
             isArrayOfObjects(field.children))
             field.children = _addIdToSchema(field.children);
@@ -118,13 +106,13 @@ export const addIdToSchema = (schema, startWithID, secretKeyOrSalt, encodeIDs) =
     const _addIdToSchema = (schema) => schema.map(_addIdToField);
     return _addIdToSchema(schema);
 };
-export const encodeSchemaID = (schema, secretKeyOrSalt) => schema.map((field) => ({
+export const encodeSchemaID = (schema) => schema.map((field) => ({
     ...field,
-    id: isNumber(field.id) ? encodeID(field.id, secretKeyOrSalt) : field.id,
+    id: isNumber(field.id) ? encodeID(field.id) : field.id,
     ...(field.children
         ? isArrayOfObjects(field.children)
             ? {
-                children: encodeSchemaID(field.children, secretKeyOrSalt),
+                children: encodeSchemaID(field.children),
             }
             : { children: field.children }
         : {}),
@@ -136,8 +124,7 @@ export const hashString = (str) => createHash("sha256").update(str).digest("hex"
  * @param operator - The comparison operator (e.g., '=', '!=', '>', '<', '>=', '<=', '[]', '![]', '*', '!*').
  * @param originalValue - The value to compare, can be a single value or an array of values.
  * @param comparedValue - The value or values to compare against.
- * @param fieldType - Optional type of the field to guide comparison (e.g., 'password', 'boolean').
- * @param fieldChildrenType - Optional type for child elements in array inputs.
+ * @param fieldType - Optional type of the field.
  * @returns boolean - Result of the comparison operation.
  *
  * Note: Handles various data types and comparison logic, including special handling for passwords and regex patterns.
@@ -199,7 +186,7 @@ const compareNonNullValues = (originalValue, comparedValue, comparator) => {
  *
  * @param originalValue - The original value.
  * @param comparedValue - The value to compare against.
- * @param fieldType - Type of the field.
+ * @param field - Field object config.
  * @returns boolean - Result of the equality check.
  */
 export const isEqual = (originalValue, comparedValue, fieldType) => {

package/package.json

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