@librechat/data-schemas 0.0.14 → 0.0.15

package/dist/index.es.js

@@ -8,7 +8,6 @@ import winston from 'winston';
 import 'winston-daily-rotate-file';
 import path from 'path';
 import { klona } from 'klona';
-import traverseLib from 'traverse';
 import { nanoid } from 'nanoid';
 
 async function signPayload({ payload, secret, expirationTime, }) {
@@ -2249,12 +2248,158 @@ function createUserMethods(mongoose) {
 }
 
 /**
- * Wrapper for the traverse module to handle CommonJS imports in ESM context
+ * ESM-native object traversal utility
+ * Simplified implementation focused on the forEach use case
  */
-// @ts-ignore - traverse doesn't have proper ESM exports
-// Handle both default export and named exports
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const traverse = (traverseLib.default || traverseLib);
+function isObject(value) {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    // Treat these built-in types as leaf nodes, not objects to traverse
+    if (value instanceof Date)
+        return false;
+    if (value instanceof RegExp)
+        return false;
+    if (value instanceof Error)
+        return false;
+    if (value instanceof URL)
+        return false;
+    // Check for Buffer (Node.js)
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value))
+        return false;
+    // Check for TypedArrays and ArrayBuffer
+    if (ArrayBuffer.isView(value))
+        return false;
+    if (value instanceof ArrayBuffer)
+        return false;
+    if (value instanceof SharedArrayBuffer)
+        return false;
+    // Check for other built-in types that shouldn't be traversed
+    if (value instanceof Promise)
+        return false;
+    if (value instanceof WeakMap)
+        return false;
+    if (value instanceof WeakSet)
+        return false;
+    if (value instanceof Map)
+        return false;
+    if (value instanceof Set)
+        return false;
+    // Check if it's a primitive wrapper object
+    const stringTag = Object.prototype.toString.call(value);
+    if (stringTag === '[object Boolean]' ||
+        stringTag === '[object Number]' ||
+        stringTag === '[object String]') {
+        return false;
+    }
+    return true;
+}
+// Helper to safely set a property on an object or array
+function setProperty(obj, key, value) {
+    if (Array.isArray(obj) && typeof key === 'number') {
+        obj[key] = value;
+    }
+    else if (!Array.isArray(obj) && typeof key === 'string') {
+        obj[key] = value;
+    }
+    else if (!Array.isArray(obj) && typeof key === 'number') {
+        // Handle numeric keys on objects
+        obj[key] = value;
+    }
+}
+// Helper to safely delete a property from an object
+function deleteProperty(obj, key) {
+    if (Array.isArray(obj) && typeof key === 'number') {
+        // For arrays, we should use splice, but this is handled in remove()
+        // This function is only called for non-array deletion
+        return;
+    }
+    if (!Array.isArray(obj)) {
+        delete obj[key];
+    }
+}
+function forEach(obj, callback) {
+    const visited = new WeakSet();
+    function walk(node, path = [], parent) {
+        // Check for circular references
+        let circular = null;
+        if (isObject(node)) {
+            if (visited.has(node)) {
+                // Find the circular reference in the parent chain
+                let p = parent;
+                while (p) {
+                    if (p.node === node) {
+                        circular = p;
+                        break;
+                    }
+                    p = p.parent;
+                }
+                return; // Skip circular references
+            }
+            visited.add(node);
+        }
+        const key = path.length > 0 ? path[path.length - 1] : undefined;
+        const isRoot = path.length === 0;
+        const level = path.length;
+        // Determine if this is a leaf node
+        const isLeaf = !isObject(node) ||
+            (Array.isArray(node) && node.length === 0) ||
+            Object.keys(node).length === 0;
+        // Create context
+        const context = {
+            node,
+            path: [...path],
+            parent,
+            key,
+            isLeaf,
+            notLeaf: !isLeaf,
+            isRoot,
+            notRoot: !isRoot,
+            level,
+            circular,
+            update(value) {
+                if (!isRoot && parent && key !== undefined && isObject(parent.node)) {
+                    setProperty(parent.node, key, value);
+                }
+                this.node = value;
+            },
+            remove() {
+                if (!isRoot && parent && key !== undefined && isObject(parent.node)) {
+                    if (Array.isArray(parent.node) && typeof key === 'number') {
+                        parent.node.splice(key, 1);
+                    }
+                    else {
+                        deleteProperty(parent.node, key);
+                    }
+                }
+            },
+        };
+        // Call the callback with the context
+        callback.call(context, node);
+        // Traverse children if not circular and is an object
+        if (!circular && isObject(node) && !isLeaf) {
+            if (Array.isArray(node)) {
+                for (let i = 0; i < node.length; i++) {
+                    walk(node[i], [...path, i], context);
+                }
+            }
+            else {
+                for (const [childKey, childValue] of Object.entries(node)) {
+                    walk(childValue, [...path, childKey], context);
+                }
+            }
+        }
+    }
+    walk(obj);
+}
+// Main traverse function that returns an object with forEach method
+function traverse(obj) {
+    return {
+        forEach(callback) {
+            forEach(obj, callback);
+        },
+    };
+}
 
 const SPLAT_SYMBOL = Symbol.for('splat');
 const MESSAGE_SYMBOL = Symbol.for('message');
@@ -2359,67 +2504,78 @@ const debugTraverse = winston.format.printf(({ level, message, timestamp, ...met
     if (typeof message !== 'string' || !message.trim) {
         return `${timestamp} ${level}: ${JSON.stringify(message)}`;
     }
-    let msg = `${timestamp} ${level}: ${truncateLongStrings(message.trim(), 150)}`;
+    const msgParts = [
+        `${timestamp} ${level}: ${truncateLongStrings(message.trim(), 150)}`,
+    ];
     try {
         if (level !== 'debug') {
-            return msg;
+            return msgParts[0];
         }
         if (!metadata) {
-            return msg;
+            return msgParts[0];
         }
         // Type-safe access to SPLAT_SYMBOL using bracket notation
         const metadataRecord = metadata;
         const splatArray = metadataRecord[SPLAT_SYMBOL];
         const debugValue = Array.isArray(splatArray) ? splatArray[0] : undefined;
         if (!debugValue) {
-            return msg;
+            return msgParts[0];
         }
         if (debugValue && Array.isArray(debugValue)) {
-            msg += `\n${JSON.stringify(debugValue.map(condenseArray))}`;
-            return msg;
+            msgParts.push(`\n${JSON.stringify(debugValue.map(condenseArray))}`);
+            return msgParts.join('');
         }
         if (typeof debugValue !== 'object') {
-            return (msg += ` ${debugValue}`);
+            msgParts.push(` ${debugValue}`);
+            return msgParts.join('');
         }
-        msg += '\n{';
+        msgParts.push('\n{');
         const copy = klona(metadata);
-        traverse(copy).forEach(function (value) {
-            var _a;
-            if (typeof (this === null || this === void 0 ? void 0 : this.key) === 'symbol') {
-                return;
-            }
-            let _parentKey = '';
-            const parent = this.parent;
-            if (typeof (parent === null || parent === void 0 ? void 0 : parent.key) !== 'symbol' && (parent === null || parent === void 0 ? void 0 : parent.key)) {
-                _parentKey = parent.key;
-            }
-            const parentKey = `${parent && parent.notRoot ? _parentKey + '.' : ''}`;
-            const tabs = `${parent && parent.notRoot ? '    ' : '  '}`;
-            const currentKey = (_a = this === null || this === void 0 ? void 0 : this.key) !== null && _a !== void 0 ? _a : 'unknown';
-            if (this.isLeaf && typeof value === 'string') {
-                const truncatedText = truncateLongStrings(value);
-                msg += `\n${tabs}${parentKey}${currentKey}: ${JSON.stringify(truncatedText)},`;
-            }
-            else if (this.notLeaf && Array.isArray(value) && value.length > 0) {
-                const currentMessage = `\n${tabs}// ${value.length} ${currentKey.replace(/s$/, '')}(s)`;
-                this.update(currentMessage, true);
-                msg += currentMessage;
-                const stringifiedArray = value.map(condenseArray);
-                msg += `\n${tabs}${parentKey}${currentKey}: [${stringifiedArray}],`;
-            }
-            else if (this.isLeaf && typeof value === 'function') {
-                msg += `\n${tabs}${parentKey}${currentKey}: function,`;
-            }
-            else if (this.isLeaf) {
-                msg += `\n${tabs}${parentKey}${currentKey}: ${value},`;
-            }
-        });
-        msg += '\n}';
-        return msg;
+        try {
+            const traversal = traverse(copy);
+            traversal.forEach(function (value) {
+                var _a;
+                if (typeof (this === null || this === void 0 ? void 0 : this.key) === 'symbol') {
+                    return;
+                }
+                let _parentKey = '';
+                const parent = this.parent;
+                if (typeof (parent === null || parent === void 0 ? void 0 : parent.key) !== 'symbol' && (parent === null || parent === void 0 ? void 0 : parent.key) !== undefined) {
+                    _parentKey = String(parent.key);
+                }
+                const parentKey = `${parent && parent.notRoot ? _parentKey + '.' : ''}`;
+                const tabs = `${parent && parent.notRoot ? '    ' : '  '}`;
+                const currentKey = (_a = this === null || this === void 0 ? void 0 : this.key) !== null && _a !== void 0 ? _a : 'unknown';
+                if (this.isLeaf && typeof value === 'string') {
+                    const truncatedText = truncateLongStrings(value);
+                    msgParts.push(`\n${tabs}${parentKey}${currentKey}: ${JSON.stringify(truncatedText)},`);
+                }
+                else if (this.notLeaf && Array.isArray(value) && value.length > 0) {
+                    const currentMessage = `\n${tabs}// ${value.length} ${String(currentKey).replace(/s$/, '')}(s)`;
+                    this.update(currentMessage);
+                    msgParts.push(currentMessage);
+                    const stringifiedArray = value.map(condenseArray);
+                    msgParts.push(`\n${tabs}${parentKey}${currentKey}: [${stringifiedArray}],`);
+                }
+                else if (this.isLeaf && typeof value === 'function') {
+                    msgParts.push(`\n${tabs}${parentKey}${currentKey}: function,`);
+                }
+                else if (this.isLeaf) {
+                    msgParts.push(`\n${tabs}${parentKey}${currentKey}: ${value},`);
+                }
+            });
+        }
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : 'Unknown error';
+            msgParts.push(`\n[LOGGER TRAVERSAL ERROR] ${errorMessage}`);
+        }
+        msgParts.push('\n}');
+        return msgParts.join('');
     }
     catch (e) {
         const errorMessage = e instanceof Error ? e.message : 'Unknown error';
-        return (msg += `\n[LOGGER PARSING ERROR] ${errorMessage}`);
+        msgParts.push(`\n[LOGGER PARSING ERROR] ${errorMessage}`);
+        return msgParts.join('');
     }
 });
 /**