@joystick.js/db-canary 0.0.0-canary.2250 → 0.0.0-canary.2252

package/src/server/lib/operations/admin.js

@@ -35,6 +35,131 @@ import { performance_monitor } from '../performance_monitor.js';
 
 const { create_context_logger } = create_logger('admin');
 
+/**
+ * Safely retrieves database settings with fallback.
+ * @returns {Object} Settings object with defaults
+ */
+const get_safe_settings = () => {
+  try {
+    return get_settings();
+  } catch (settings_error) {
+    return { port: 1983 };
+  }
+};
+
+/**
+ * Safely retrieves database statistics.
+ * @param {Object} db - Database instance
+ * @returns {Object} Database statistics object
+ */
+const get_safe_database_stats = (db) => {
+  try {
+    const raw_stats = db.getStats ? db.getStats() : {};
+    return {
+      pageSize: raw_stats.pageSize || 0,
+      treeDepth: raw_stats.treeDepth || 0,
+      treeBranchPages: raw_stats.treeBranchPages || 0,
+      treeLeafPages: raw_stats.treeLeafPages || 0,
+      entryCount: raw_stats.entryCount || 0,
+      mapSize: raw_stats.mapSize || 0,
+      lastPageNumber: raw_stats.lastPageNumber || 0
+    };
+  } catch (stats_error) {
+    return { error: 'Could not retrieve database stats' };
+  }
+};
+
+/**
+ * Counts collections and documents in database.
+ * @param {Object} db - Database instance
+ * @param {Object} log - Logger instance
+ * @returns {Object} Collections count and total documents
+ */
+const count_collections_and_documents = (db, log) => {
+  const collections = {};
+  let total_documents = 0;
+  
+  try {
+    for (const { key } of db.getRange()) {
+      if (typeof key === 'string' && key.includes(':') && !key.startsWith('_')) {
+        const collection_name = key.split(':')[0];
+        collections[collection_name] = (collections[collection_name] || 0) + 1;
+        total_documents++;
+      }
+    }
+  } catch (range_error) {
+    log.warn('Could not iterate database range for stats', { error: range_error.message });
+  }
+  
+  return { collections, total_documents };
+};
+
+/**
+ * Calculates memory usage in megabytes.
+ * @returns {Object} Memory usage statistics
+ */
+const calculate_memory_usage = () => {
+  const memory_usage = process.memoryUsage();
+  return {
+    rss: Math.round(memory_usage.rss / 1024 / 1024),
+    heapTotal: Math.round(memory_usage.heapTotal / 1024 / 1024),
+    heapUsed: Math.round(memory_usage.heapUsed / 1024 / 1024),
+    external: Math.round(memory_usage.external / 1024 / 1024)
+  };
+};
+
+/**
+ * Calculates database size usage percentage.
+ * @param {Object} db_stats - Database statistics
+ * @returns {number} Usage percentage
+ */
+const calculate_database_usage_percent = (db_stats) => {
+  return db_stats.mapSize > 0 
+    ? Math.round((db_stats.lastPageNumber * db_stats.pageSize / db_stats.mapSize) * 100)
+    : 0;
+};
+
+/**
+ * Creates server statistics object.
+ * @param {Object} memory_usage_mb - Memory usage in MB
+ * @returns {Object} Server statistics
+ */
+const create_server_stats = (memory_usage_mb) => {
+  return {
+    uptime: Math.floor(process.uptime()),
+    uptime_formatted: format_uptime(process.uptime()),
+    memory_usage: memory_usage_mb,
+    memory_usage_raw: process.memoryUsage(),
+    node_version: process.version,
+    platform: process.platform,
+    arch: process.arch,
+    pid: process.pid,
+    cpu_usage: process.cpuUsage()
+  };
+};
+
+/**
+ * Creates database statistics object.
+ * @param {number} total_documents - Total document count
+ * @param {Object} collections - Collections object
+ * @param {Object} db_stats - Database statistics
+ * @param {number} map_size_usage_percent - Usage percentage
+ * @returns {Object} Database statistics
+ */
+const create_database_stats = (total_documents, collections, db_stats, map_size_usage_percent) => {
+  return {
+    total_documents,
+    total_collections: Object.keys(collections).length,
+    collections,
+    stats: db_stats,
+    map_size_usage_percent,
+    disk_usage: {
+      map_size_mb: Math.round((db_stats.mapSize || 0) / 1024 / 1024),
+      used_space_mb: Math.round(((db_stats.lastPageNumber || 0) * (db_stats.pageSize || 0)) / 1024 / 1024)
+    }
+  };
+};
+
 /**
  * Gets comprehensive server and database statistics.
  * @returns {Object} Enhanced statistics including server, database, and performance metrics
@@ -45,85 +170,15 @@ const get_enhanced_stats = () => {
   
   try {
     const db = get_database();
-    
-    // Handle settings gracefully - use defaults if not loaded
-    let settings;
-    try {
-      settings = get_settings();
-    } catch (settings_error) {
-      settings = { port: 1983 };
-    }
-    
-    // Safely get database stats
-    let db_stats = {};
-    try {
-      const raw_stats = db.getStats ? db.getStats() : {};
-      db_stats = {
-        pageSize: raw_stats.pageSize || 0,
-        treeDepth: raw_stats.treeDepth || 0,
-        treeBranchPages: raw_stats.treeBranchPages || 0,
-        treeLeafPages: raw_stats.treeLeafPages || 0,
-        entryCount: raw_stats.entryCount || 0,
-        mapSize: raw_stats.mapSize || 0,
-        lastPageNumber: raw_stats.lastPageNumber || 0
-      };
-    } catch (stats_error) {
-      db_stats = { error: 'Could not retrieve database stats' };
-    }
-    
-    // Count collections and documents safely
-    const collections = {};
-    let total_documents = 0;
-    
-    try {
-      for (const { key } of db.getRange()) {
-        if (typeof key === 'string' && key.includes(':') && !key.startsWith('_')) {
-          const collection_name = key.split(':')[0];
-          collections[collection_name] = (collections[collection_name] || 0) + 1;
-          total_documents++;
-        }
-      }
-    } catch (range_error) {
-      log.warn('Could not iterate database range for stats', { error: range_error.message });
-    }
-    
-    // Calculate memory usage percentage
-    const memory_usage = process.memoryUsage();
-    const memory_usage_mb = {
-      rss: Math.round(memory_usage.rss / 1024 / 1024),
-      heapTotal: Math.round(memory_usage.heapTotal / 1024 / 1024),
-      heapUsed: Math.round(memory_usage.heapUsed / 1024 / 1024),
-      external: Math.round(memory_usage.external / 1024 / 1024)
-    };
-    
-    // Calculate database size percentage
-    const map_size_usage_percent = db_stats.mapSize > 0 
-      ? Math.round((db_stats.lastPageNumber * db_stats.pageSize / db_stats.mapSize) * 100)
-      : 0;
+    const settings = get_safe_settings();
+    const db_stats = get_safe_database_stats(db);
+    const { collections, total_documents } = count_collections_and_documents(db, log);
+    const memory_usage_mb = calculate_memory_usage();
+    const map_size_usage_percent = calculate_database_usage_percent(db_stats);
     
     return {
-      server: {
-        uptime: Math.floor(process.uptime()),
-        uptime_formatted: format_uptime(process.uptime()),
-        memory_usage: memory_usage_mb,
-        memory_usage_raw: memory_usage,
-        node_version: process.version,
-        platform: process.platform,
-        arch: process.arch,
-        pid: process.pid,
-        cpu_usage: process.cpuUsage()
-      },
-      database: {
-        total_documents,
-        total_collections: Object.keys(collections).length,
-        collections,
-        stats: db_stats,
-        map_size_usage_percent,
-        disk_usage: {
-          map_size_mb: Math.round((db_stats.mapSize || 0) / 1024 / 1024),
-          used_space_mb: Math.round(((db_stats.lastPageNumber || 0) * (db_stats.pageSize || 0)) / 1024 / 1024)
-        }
-      },
+      server: create_server_stats(memory_usage_mb),
+      database: create_database_stats(total_documents, collections, db_stats, map_size_usage_percent),
       performance: {
         ops_per_second: calculate_ops_per_second(),
         avg_response_time_ms: calculate_avg_response_time()
@@ -189,100 +244,147 @@ export const track_operation = (duration_ms) => {
 };
 
 /**
- * Lists all collections in the database with metadata.
- * @param {string} [database_name='default'] - Database name to list collections from
- * @returns {Object} Object containing collections array, total counts
- * @throws {Error} When collection listing fails
+ * Creates initial collection metadata object.
+ * @param {string} collection_name - Collection name
+ * @returns {Object} Collection metadata object
  */
-const list_collections = (database_name = 'default') => {
-  const log = create_context_logger();
+const create_collection_metadata = (collection_name) => {
+  return {
+    name: collection_name,
+    document_count: 0,
+    indexes: [],
+    estimated_size_bytes: 0
+  };
+};
+
+/**
+ * Scans database range for collections and documents.
+ * @param {Object} db - Database instance
+ * @param {string} database_name - Database name
+ * @param {Object} log - Logger instance
+ * @returns {Object} Collections map and total documents count
+ */
+const scan_database_for_collections = (db, database_name, log) => {
+  const collections_map = {};
+  let total_documents = 0;
   
   try {
-    const db = get_database();
-    const collections_map = {};
-    let total_documents = 0;
-    
-    // Look for database:collection:document_id format
-    try {
-      for (const { key } of db.getRange()) {
-        if (typeof key === 'string' && key.includes(':') && !key.startsWith('_')) {
-          const parts = key.split(':');
-          if (parts.length >= 3) {
-            const key_database = parts[0];
-            const collection_name = parts[1];
-            
-            // Only count collections from the specified database
-            if (key_database === database_name) {
-              if (!collections_map[collection_name]) {
-                collections_map[collection_name] = {
-                  name: collection_name,
-                  document_count: 0,
-                  indexes: [],
-                  estimated_size_bytes: 0
-                };
-              }
-              collections_map[collection_name].document_count++;
-              total_documents++;
+    for (const { key } of db.getRange()) {
+      if (typeof key === 'string' && key.includes(':') && !key.startsWith('_')) {
+        const parts = key.split(':');
+        if (parts.length >= 3) {
+          const key_database = parts[0];
+          const collection_name = parts[1];
+          
+          if (key_database === database_name) {
+            if (!collections_map[collection_name]) {
+              collections_map[collection_name] = create_collection_metadata(collection_name);
             }
+            collections_map[collection_name].document_count++;
+            total_documents++;
           }
         }
       }
-    } catch (range_error) {
-      log.warn('Could not iterate database range for collections', { error: range_error.message });
+    }
+  } catch (range_error) {
+    log.warn('Could not iterate database range for collections', { error: range_error.message });
+  }
+  
+  return { collections_map, total_documents };
+};
+
+/**
+ * Fallback method to find collections using known patterns.
+ * @param {Object} db - Database instance
+ * @param {string} database_name - Database name
+ * @param {Object} collections_map - Existing collections map
+ * @returns {number} Additional documents found
+ */
+const fallback_collection_scan = (db, database_name, collections_map) => {
+  const potential_collections = [
+    'admin_test', 'test_collection', 'queue_test', 'users', 'products', 
+    'orders', 'sessions', 'logs', 'analytics', 'settings', 'another_collection',
+    'list_test', 'pagination_test', 'get_test', 'query_test', 'admin_insert_test',
+    'admin_update_test', 'admin_delete_test'
+  ];
+  
+  let additional_documents = 0;
+  
+  for (const collection_name of potential_collections) {
+    try {
+      const prefix = `${database_name}:${collection_name}:`;
+      const range = db.getRange({ start: prefix, end: prefix + '\xFF' });
       
-      // Fallback: try to find collections by checking for database-specific patterns
-      const potential_collections = [
-        'admin_test', 'test_collection', 'queue_test', 'users', 'products', 
-        'orders', 'sessions', 'logs', 'analytics', 'settings', 'another_collection',
-        'list_test', 'pagination_test', 'get_test', 'query_test', 'admin_insert_test',
-        'admin_update_test', 'admin_delete_test'
-      ];
+      let document_count = 0;
+      for (const entry of range) {
+        document_count++;
+        additional_documents++;
+      }
       
-      for (const collection_name of potential_collections) {
-        try {
-          // Check if this collection has any documents in the specified database
-          const prefix = `${database_name}:${collection_name}:`;
-          const range = db.getRange({ start: prefix, end: prefix + '\xFF' });
-          
-          let document_count = 0;
-          for (const entry of range) {
-            document_count++;
-            total_documents++;
-          }
-          
-          if (document_count > 0) {
-            collections_map[collection_name] = {
-              name: collection_name,
-              document_count,
-              indexes: [],
-              estimated_size_bytes: document_count * 100 // Rough estimate
-            };
-          }
-        } catch (collection_error) {
-          // Skip collections that can't be accessed
-          continue;
-        }
+      if (document_count > 0) {
+        collections_map[collection_name] = {
+          name: collection_name,
+          document_count,
+          indexes: [],
+          estimated_size_bytes: document_count * 100
+        };
       }
+    } catch (collection_error) {
+      continue;
     }
+  }
+  
+  return additional_documents;
+};
+
+/**
+ * Adds index information to collections.
+ * @param {Object} db - Database instance
+ * @param {string} database_name - Database name
+ * @param {Object} collections_map - Collections map to update
+ * @param {Object} log - Logger instance
+ */
+const add_index_information = (db, database_name, collections_map, log) => {
+  try {
+    const index_prefix = `index:${database_name}:`;
+    const index_range = db.getRange({ start: index_prefix, end: index_prefix + '\xFF' });
     
-    // Get index information for each collection safely
-    try {
-      const index_prefix = `index:${database_name}:`;
-      const index_range = db.getRange({ start: index_prefix, end: index_prefix + '\xFF' });
-      for (const { key, value } of index_range) {
-        if (typeof key === 'string' && key.startsWith(index_prefix)) {
-          const remaining_key = key.substring(index_prefix.length);
-          const collection_name = remaining_key.split(':')[0];
-          if (collections_map[collection_name]) {
-            if (!collections_map[collection_name].indexes.includes(remaining_key.split(':')[1])) {
-              collections_map[collection_name].indexes.push(remaining_key.split(':')[1]);
-            }
+    for (const { key, value } of index_range) {
+      if (typeof key === 'string' && key.startsWith(index_prefix)) {
+        const remaining_key = key.substring(index_prefix.length);
+        const collection_name = remaining_key.split(':')[0];
+        const index_name = remaining_key.split(':')[1];
+        
+        if (collections_map[collection_name] && index_name) {
+          if (!collections_map[collection_name].indexes.includes(index_name)) {
+            collections_map[collection_name].indexes.push(index_name);
           }
         }
       }
-    } catch (index_range_error) {
-      log.warn('Could not iterate index range', { error: index_range_error.message });
     }
+  } catch (index_range_error) {
+    log.warn('Could not iterate index range', { error: index_range_error.message });
+  }
+};
+
+/**
+ * Lists all collections in the database with metadata.
+ * @param {string} [database_name='default'] - Database name to list collections from
+ * @returns {Object} Object containing collections array, total counts
+ * @throws {Error} When collection listing fails
+ */
+const list_collections = (database_name = 'default') => {
+  const log = create_context_logger();
+  
+  try {
+    const db = get_database();
+    let { collections_map, total_documents } = scan_database_for_collections(db, database_name, log);
+    
+    if (Object.keys(collections_map).length === 0) {
+      total_documents += fallback_collection_scan(db, database_name, collections_map);
+    }
+    
+    add_index_information(db, database_name, collections_map, log);
     
     const collections_array = Object.values(collections_map);
     
@@ -416,6 +518,80 @@ const get_document = (collection, document_id, database = 'default') => {
   }
 };
 
+/**
+ * Evaluates a single query operator against a document value.
+ * @param {string} operator - Query operator (e.g., '$gt', '$regex')
+ * @param {*} op_value - Operator value
+ * @param {*} doc_value - Document field value
+ * @param {Object} filter_value - Full filter value for context
+ * @returns {boolean} Whether the operator matches
+ */
+const evaluate_query_operator = (operator, op_value, doc_value, filter_value) => {
+  switch (operator) {
+    case '$gt': return doc_value > op_value;
+    case '$gte': return doc_value >= op_value;
+    case '$lt': return doc_value < op_value;
+    case '$lte': return doc_value <= op_value;
+    case '$ne': return doc_value !== op_value;
+    case '$in': return Array.isArray(op_value) && op_value.includes(doc_value);
+    case '$regex': 
+      const regex_options = filter_value.$options || '';
+      return new RegExp(op_value, regex_options).test(String(doc_value));
+    default: return doc_value === filter_value;
+  }
+};
+
+/**
+ * Checks if a document matches the query filter.
+ * @param {Object} document - Document to check
+ * @param {Object} filter - Query filter
+ * @returns {boolean} Whether document matches filter
+ */
+const document_matches_filter = (document, filter) => {
+  return Object.keys(filter).every(field => {
+    const filter_value = filter[field];
+    const doc_value = document[field];
+    
+    if (typeof filter_value === 'object' && filter_value !== null) {
+      return Object.keys(filter_value).every(operator => {
+        const op_value = filter_value[operator];
+        return evaluate_query_operator(operator, op_value, doc_value, filter_value);
+      });
+    } else {
+      return doc_value === filter_value;
+    }
+  });
+};
+
+/**
+ * Processes a single document during query iteration.
+ * @param {string} key - Document key
+ * @param {string} value - Document value
+ * @param {string} prefix - Collection prefix
+ * @param {Object} filter - Query filter
+ * @param {Object} log - Logger instance
+ * @returns {Object|null} Processed document or null if invalid
+ */
+const process_query_document = (key, value, prefix, filter, log) => {
+  try {
+    const document = JSON.parse(value);
+    const document_id = key.substring(prefix.length);
+    const full_document = { _id: document_id, ...document };
+    
+    if (document_matches_filter(full_document, filter)) {
+      return full_document;
+    }
+    
+    return null;
+  } catch (parse_error) {
+    log.warn('Could not parse document during query', { 
+      key, 
+      error: parse_error.message 
+    });
+    return null;
+  }
+};
+
 /**
  * Queries documents in a collection with filtering and pagination.
  * @param {string} collection - Collection name
@@ -448,58 +624,20 @@ const query_documents = (collection, filter = {}, options = {}) => {
       if (typeof key === 'string' && key.startsWith(prefix)) {
         total_examined++;
         
-        try {
-          const document = JSON.parse(value);
-          const document_id = key.substring(prefix.length);
-          const full_document = { _id: document_id, ...document };
-          
-          // Simple filter matching
-          const matches = Object.keys(filter).every(field => {
-            const filter_value = filter[field];
-            const doc_value = full_document[field];
-            
-            if (typeof filter_value === 'object' && filter_value !== null) {
-              // Handle operators like { $gt: 5 }, { $regex: "pattern" }
-              return Object.keys(filter_value).every(operator => {
-                const op_value = filter_value[operator];
-                switch (operator) {
-                  case '$gt': return doc_value > op_value;
-                  case '$gte': return doc_value >= op_value;
-                  case '$lt': return doc_value < op_value;
-                  case '$lte': return doc_value <= op_value;
-                  case '$ne': return doc_value !== op_value;
-                  case '$in': return Array.isArray(op_value) && op_value.includes(doc_value);
-                  case '$regex': 
-                    // Handle $options parameter for regex flags
-                    const regex_options = filter_value.$options || '';
-                    return new RegExp(op_value, regex_options).test(String(doc_value));
-                  default: return doc_value === filter_value;
-                }
-              });
-            } else {
-              return doc_value === filter_value;
-            }
-          });
+        const processed_document = process_query_document(key, value, prefix, filter, log);
+        
+        if (processed_document) {
+          if (skipped < skip) {
+            skipped++;
+            continue;
+          }
           
-          if (matches) {
-            if (skipped < skip) {
-              skipped++;
-              continue;
-            }
-            
-            if (count >= limit) {
-              break;
-            }
-            
-            documents.push(full_document);
-            count++;
+          if (count >= limit) {
+            break;
           }
-        } catch (parse_error) {
-          log.warn('Could not parse document during query', { 
-            collection, 
-            key, 
-            error: parse_error.message 
-          });
+          
+          documents.push(processed_document);
+          count++;
         }
       }
     }