@joystick.js/db-canary 0.0.0-canary.2274 → 0.0.0-canary.2276

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

@@ -175,10 +175,228 @@ const apply_pull_operator = (document, operations) => {
   return updated_document;
 };
 
+/**
+ * Applies $add_to_set operator to document.
+ * @param {Object} document - Document to update
+ * @param {Object} operations - AddToSet operations
+ * @returns {Object} Updated document
+ */
+const apply_add_to_set_operator = (document, operations) => {
+  let updated_document = { ...document };
+  
+  for (const [field, value] of Object.entries(operations)) {
+    if (field.includes('.')) {
+      // Handle nested field add_to_set with dot notation
+      let current_array = get_nested_field(updated_document, field);
+      if (!Array.isArray(current_array)) {
+        current_array = [];
+      }
+      
+      // Only add if the value doesn't already exist in the array
+      if (!current_array.includes(value)) {
+        current_array = [...current_array, value];
+      }
+      
+      updated_document = set_nested_field(updated_document, field, current_array);
+    } else {
+      // Handle simple field add_to_set
+      if (!Array.isArray(updated_document[field])) {
+        updated_document[field] = [];
+      }
+      
+      // Only add if the value doesn't already exist in the array
+      if (!updated_document[field].includes(value)) {
+        updated_document[field] = [...updated_document[field], value];
+      }
+    }
+  }
+  
+  return updated_document;
+};
+
+/**
+ * Applies $pull_all operator to document.
+ * @param {Object} document - Document to update
+ * @param {Object} operations - PullAll operations
+ * @returns {Object} Updated document
+ */
+const apply_pull_all_operator = (document, operations) => {
+  const updated_document = { ...document };
+  for (const [field, values] of Object.entries(operations)) {
+    if (Array.isArray(updated_document[field]) && Array.isArray(values)) {
+      updated_document[field] = updated_document[field].filter(item => !values.includes(item));
+    }
+  }
+  return updated_document;
+};
+
+/**
+ * Applies $pop operator to document.
+ * @param {Object} document - Document to update
+ * @param {Object} operations - Pop operations
+ * @returns {Object} Updated document
+ */
+const apply_pop_operator = (document, operations) => {
+  const updated_document = { ...document };
+  for (const [field, direction] of Object.entries(operations)) {
+    if (Array.isArray(updated_document[field]) && updated_document[field].length > 0) {
+      if (direction === 1 || direction === '1') {
+        // Remove last element
+        updated_document[field] = updated_document[field].slice(0, -1);
+      } else if (direction === -1 || direction === '-1') {
+        // Remove first element
+        updated_document[field] = updated_document[field].slice(1);
+      }
+    }
+  }
+  return updated_document;
+};
+
+/**
+ * Applies $rename operator to document.
+ * @param {Object} document - Document to update
+ * @param {Object} operations - Rename operations
+ * @returns {Object} Updated document
+ */
+const apply_rename_operator = (document, operations) => {
+  let updated_document = { ...document };
+  
+  for (const [old_field, new_field] of Object.entries(operations)) {
+    if (old_field.includes('.') || new_field.includes('.')) {
+      // Handle nested field renames with dot notation
+      const old_value = get_nested_field(updated_document, old_field);
+      if (old_value !== undefined) {
+        updated_document = set_nested_field(updated_document, new_field, old_value);
+        updated_document = unset_nested_field(updated_document, old_field);
+      }
+    } else {
+      // Handle simple field renames
+      if (old_field in updated_document) {
+        updated_document[new_field] = updated_document[old_field];
+        delete updated_document[old_field];
+      }
+    }
+  }
+  
+  return updated_document;
+};
+
+/**
+ * Applies $min operator to document.
+ * @param {Object} document - Document to update
+ * @param {Object} operations - Min operations
+ * @returns {Object} Updated document
+ */
+const apply_min_operator = (document, operations) => {
+  let updated_document = { ...document };
+  
+  for (const [field, value] of Object.entries(operations)) {
+    if (field.includes('.')) {
+      // Handle nested field min with dot notation
+      const current_value = get_nested_field(updated_document, field);
+      if (current_value === undefined || value < current_value) {
+        updated_document = set_nested_field(updated_document, field, value);
+      }
+    } else {
+      // Handle simple field min
+      if (!(field in updated_document) || value < updated_document[field]) {
+        updated_document[field] = value;
+      }
+    }
+  }
+  
+  return updated_document;
+};
+
+/**
+ * Applies $max operator to document.
+ * @param {Object} document - Document to update
+ * @param {Object} operations - Max operations
+ * @returns {Object} Updated document
+ */
+const apply_max_operator = (document, operations) => {
+  let updated_document = { ...document };
+  
+  for (const [field, value] of Object.entries(operations)) {
+    if (field.includes('.')) {
+      // Handle nested field max with dot notation
+      const current_value = get_nested_field(updated_document, field);
+      if (current_value === undefined || value > current_value) {
+        updated_document = set_nested_field(updated_document, field, value);
+      }
+    } else {
+      // Handle simple field max
+      if (!(field in updated_document) || value > updated_document[field]) {
+        updated_document[field] = value;
+      }
+    }
+  }
+  
+  return updated_document;
+};
+
+/**
+ * Applies $mul operator to document.
+ * @param {Object} document - Document to update
+ * @param {Object} operations - Multiply operations
+ * @returns {Object} Updated document
+ */
+const apply_mul_operator = (document, operations) => {
+  let updated_document = { ...document };
+  
+  for (const [field, value] of Object.entries(operations)) {
+    if (field.includes('.')) {
+      // Handle nested field multiply with dot notation
+      const current_value = get_nested_field(updated_document, field) || 0;
+      updated_document = set_nested_field(updated_document, field, current_value * value);
+    } else {
+      // Handle simple field multiply
+      updated_document[field] = (updated_document[field] || 0) * value;
+    }
+  }
+  
+  return updated_document;
+};
+
+/**
+ * Applies $current_date operator to document.
+ * @param {Object} document - Document to update
+ * @param {Object} operations - CurrentDate operations
+ * @returns {Object} Updated document
+ */
+const apply_current_date_operator = (document, operations) => {
+  let updated_document = { ...document };
+  const current_date = new Date();
+  
+  for (const [field, type_spec] of Object.entries(operations)) {
+    let date_value;
+    
+    if (type_spec === true) {
+      date_value = current_date;
+    } else if (typeof type_spec === 'object' && type_spec !== null && type_spec.$type === 'date') {
+      date_value = current_date;
+    } else if (typeof type_spec === 'object' && type_spec !== null && type_spec.$type === 'timestamp') {
+      date_value = current_date.toISOString();
+    } else {
+      date_value = current_date;
+    }
+    
+    if (field.includes('.')) {
+      // Handle nested field current date with dot notation
+      updated_document = set_nested_field(updated_document, field, date_value);
+    } else {
+      // Handle simple field current date
+      updated_document[field] = date_value;
+    }
+  }
+  
+  return updated_document;
+};
+
 /**
  * Applies MongoDB-style update operators to a document.
  * @param {Object} document - Original document
- * @param {Object} update_operations - Update operations ($set, $unset, $inc, $push, $pull)
+ * @param {Object} update_operations - Update operations with supported operators
  * @returns {Object} Updated document
  * @throws {Error} When unsupported update operator is used
  */
@@ -207,6 +425,38 @@ const apply_update_operators = (document, update_operations) => {
         updated_document = apply_pull_operator(updated_document, operations);
         break;
         
+      case '$add_to_set':
+        updated_document = apply_add_to_set_operator(updated_document, operations);
+        break;
+        
+      case '$pull_all':
+        updated_document = apply_pull_all_operator(updated_document, operations);
+        break;
+        
+      case '$pop':
+        updated_document = apply_pop_operator(updated_document, operations);
+        break;
+        
+      case '$rename':
+        updated_document = apply_rename_operator(updated_document, operations);
+        break;
+        
+      case '$min':
+        updated_document = apply_min_operator(updated_document, operations);
+        break;
+        
+      case '$max':
+        updated_document = apply_max_operator(updated_document, operations);
+        break;
+        
+      case '$mul':
+        updated_document = apply_mul_operator(updated_document, operations);
+        break;
+        
+      case '$current_date':
+        updated_document = apply_current_date_operator(updated_document, operations);
+        break;
+        
       default:
         throw new Error(`Unsupported update operator: ${operator}`);
     }

package/src/server/lib/simple_sync_manager.js

@@ -0,0 +1,444 @@
+/**
+ * @fileoverview Simple sync manager for primary nodes in JoystickDB.
+ * Provides basic TCP synchronization of write operations to secondary nodes
+ * with API_KEY authentication and simple retry logic.
+ */
+
+import net from 'net';
+import { get_settings } from './load_settings.js';
+import { encode_message } from './tcp_protocol.js';
+import create_logger from './logger.js';
+
+const { create_context_logger } = create_logger('simple_sync');
+
+/**
+ * Simple sync manager that syncs write operations to secondary nodes.
+ * Uses API_KEY authentication and basic TCP connections with retry logic.
+ */
+class SimpleSyncManager {
+  /**
+   * Creates a new SimpleSyncManager instance.
+   */
+  constructor() {
+    /** @type {boolean} Whether this node is configured as primary */
+    this.is_primary = false;
+    
+    /** @type {Array<Object>} List of secondary nodes to sync to */
+    this.secondary_nodes = [];
+    
+    /** @type {Map<string, Object>} Active connections to secondary nodes */
+    this.connections = new Map();
+    
+    /** @type {number} TCP port for sync operations */
+    this.sync_port = 1985;
+    
+    /** @type {number} Timeout for sync operations in milliseconds */
+    this.sync_timeout_ms = 5000;
+    
+    /** @type {number} Number of retry attempts */
+    this.sync_retries = 2;
+    
+    /** @type {number} Sequence number for operations */
+    this.sequence_number = 0;
+    
+    /** @type {Object} Logger instance */
+    this.log = create_context_logger();
+    
+    /** @type {Object} Sync statistics */
+    this.stats = {
+      total_synced: 0,
+      successful_syncs: 0,
+      failed_syncs: 0,
+      auth_failures: 0
+    };
+  }
+
+  /**
+   * Initializes the sync manager with settings configuration.
+   */
+  initialize() {
+    try {
+      const settings = get_settings();
+      
+      if (!settings.primary) {
+        this.log.info('Node not configured as primary - sync disabled');
+        return;
+      }
+      
+      this.is_primary = settings.primary;
+      this.secondary_nodes = settings.secondary_nodes || [];
+      this.sync_port = settings.sync_port || 1985;
+      this.sync_timeout_ms = settings.sync_timeout_ms || 5000;
+      this.sync_retries = settings.sync_retries || 2;
+      
+      this.log.info('Initializing simple sync manager', {
+        is_primary: this.is_primary,
+        secondary_count: this.secondary_nodes.length,
+        sync_port: this.sync_port,
+        timeout_ms: this.sync_timeout_ms,
+        retries: this.sync_retries
+      });
+      
+      this.connect_to_secondaries();
+      
+    } catch (error) {
+      this.log.warn('Could not initialize sync manager - settings not loaded', {
+        error: error.message
+      });
+    }
+  }
+
+  /**
+   * Establishes connections to all secondary nodes.
+   */
+  connect_to_secondaries() {
+    for (const secondary of this.secondary_nodes) {
+      this.connect_to_secondary(secondary);
+    }
+  }
+
+  /**
+   * Connects to a single secondary node.
+   * @param {Object} secondary - Secondary node configuration
+   */
+  connect_to_secondary(secondary) {
+    const { ip } = secondary;
+    const connection_id = `${ip}:${this.sync_port}`;
+    
+    if (this.connections.has(connection_id)) {
+      return;
+    }
+    
+    this.log.info('Connecting to secondary node', { ip, port: this.sync_port });
+    
+    try {
+      const socket = new net.Socket();
+      
+      socket.connect(this.sync_port, ip, () => {
+        this.log.info('Connected to secondary node', { ip, port: this.sync_port });
+      });
+      
+      socket.on('error', (error) => {
+        this.log.error('Secondary connection error', {
+          ip,
+          error: error.message
+        });
+        
+        this.connections.delete(connection_id);
+        
+        // Retry connection after delay
+        setTimeout(() => {
+          try {
+            this.connect_to_secondary(secondary);
+          } catch (retry_error) {
+            this.log.error('Failed to retry secondary connection', {
+              ip,
+              error: retry_error.message
+            });
+          }
+        }, 5000);
+      });
+      
+      socket.on('close', () => {
+        this.log.warn('Secondary connection closed', { ip });
+        this.connections.delete(connection_id);
+        
+        // Retry connection after delay
+        setTimeout(() => {
+          try {
+            this.connect_to_secondary(secondary);
+          } catch (retry_error) {
+            this.log.error('Failed to retry secondary connection', {
+              ip,
+              error: retry_error.message
+            });
+          }
+        }, 5000);
+      });
+      
+      socket.on('data', (data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          this.handle_sync_response(connection_id, message);
+        } catch (error) {
+          this.log.error('Failed to parse sync response', {
+            connection_id,
+            error: error.message
+          });
+        }
+      });
+      
+      this.connections.set(connection_id, {
+        socket,
+        ip,
+        connected: true,
+        last_sync: null
+      });
+      
+    } catch (error) {
+      this.log.error('Failed to connect to secondary', {
+        ip,
+        error: error.message
+      });
+    }
+  }
+
+  /**
+   * Handles sync response from secondary node.
+   * @param {string} connection_id - Connection identifier
+   * @param {Object} message - Response message from secondary
+   */
+  handle_sync_response(connection_id, message) {
+    const { type, status, sequence, error } = message;
+    
+    if (type !== 'sync_acknowledged') {
+      return;
+    }
+    
+    if (status === 'success') {
+      this.stats.successful_syncs++;
+      this.log.debug('Sync acknowledged', { connection_id, sequence });
+    } else if (status === 'auth_failed') {
+      this.stats.auth_failures++;
+      this.log.error('Sync authentication failed', { connection_id, sequence, error });
+    } else {
+      this.stats.failed_syncs++;
+      this.log.error('Sync failed', { connection_id, sequence, error });
+    }
+  }
+
+  /**
+   * Queues an operation for sync to secondary nodes.
+   * @param {string} operation - Operation type
+   * @param {string} collection - Collection name
+   * @param {Object} data - Operation data
+   */
+  queue_sync(operation, collection, data) {
+    if (!this.is_primary || this.connections.size === 0) {
+      return;
+    }
+    
+    const sequence = ++this.sequence_number;
+    
+    this.log.debug('Queuing sync operation', {
+      operation,
+      collection,
+      sequence,
+      secondary_count: this.connections.size
+    });
+    
+    this.stats.total_synced++;
+    
+    // Send immediately to all connected secondaries
+    this.send_sync_to_secondaries(operation, collection, data, sequence);
+  }
+
+  /**
+   * Sends sync message to all connected secondary nodes.
+   * @param {string} operation - Operation type
+   * @param {string} collection - Collection name
+   * @param {Object} data - Operation data
+   * @param {number} sequence - Sequence number
+   */
+  send_sync_to_secondaries(operation, collection, data, sequence) {
+    try {
+      const settings = get_settings();
+      
+      if (!settings.api_key) {
+        this.log.error('No API_KEY configured for sync operations');
+        return;
+      }
+      
+      const sync_message = {
+        type: 'operation_sync',
+        api_key: settings.api_key,
+        sequence,
+        timestamp: Date.now(),
+        operation,
+        collection,
+        data
+      };
+      
+      const encoded_message = encode_message(sync_message);
+      
+      for (const [connection_id, connection] of this.connections) {
+        if (!connection.connected || !connection.socket) {
+          continue;
+        }
+        
+        try {
+          connection.socket.write(encoded_message);
+          connection.last_sync = Date.now();
+          
+          this.log.debug('Sent sync to secondary', {
+            connection_id,
+            operation,
+            sequence
+          });
+          
+        } catch (error) {
+          this.log.error('Failed to send sync to secondary', {
+            connection_id,
+            error: error.message
+          });
+        }
+      }
+    } catch (error) {
+      this.log.error('Failed to send sync to secondaries', {
+        operation,
+        sequence,
+        error: error.message
+      });
+    }
+  }
+
+  /**
+   * Updates the secondary nodes configuration at runtime.
+   * @param {Array<Object>} new_secondary_nodes - New secondary nodes list
+   */
+  update_secondary_nodes(new_secondary_nodes) {
+    this.log.info('Updating secondary nodes configuration', {
+      old_count: this.secondary_nodes.length,
+      new_count: new_secondary_nodes.length
+    });
+    
+    // Close existing connections
+    for (const [connection_id, connection] of this.connections) {
+      try {
+        connection.socket.end();
+      } catch (error) {
+        this.log.warn('Error closing secondary connection', {
+          connection_id,
+          error: error.message
+        });
+      }
+    }
+    
+    this.connections.clear();
+    this.secondary_nodes = new_secondary_nodes;
+    
+    // Establish new connections
+    this.connect_to_secondaries();
+  }
+
+  /**
+   * Forces sync of all connected secondaries (health check).
+   * @returns {Promise<Object>} Sync status for each secondary
+   */
+  async force_sync() {
+    if (!this.is_primary) {
+      throw new Error('Node is not configured as primary');
+    }
+    
+    const results = [];
+    
+    for (const [connection_id, connection] of this.connections) {
+      try {
+        if (connection.connected) {
+          results.push({
+            connection_id,
+            status: 'sync_initiated'
+          });
+        } else {
+          results.push({
+            connection_id,
+            status: 'not_connected'
+          });
+        }
+      } catch (error) {
+        results.push({
+          connection_id,
+          status: 'error',
+          error: error.message
+        });
+      }
+    }
+    
+    return {
+      success: true,
+      message: 'Force sync initiated',
+      results
+    };
+  }
+
+  /**
+   * Gets current sync status and statistics.
+   * @returns {Object} Sync status information
+   */
+  get_sync_status() {
+    const secondary_status = [];
+    
+    for (const [connection_id, connection] of this.connections) {
+      secondary_status.push({
+        connection_id,
+        ip: connection.ip,
+        connected: connection.connected,
+        last_sync: connection.last_sync
+      });
+    }
+    
+    return {
+      is_primary: this.is_primary,
+      secondary_count: this.connections.size,
+      stats: this.stats,
+      secondaries: secondary_status
+    };
+  }
+
+  /**
+   * Shuts down the sync manager and closes all connections.
+   * @returns {Promise<void>}
+   */
+  async shutdown() {
+    this.log.info('Shutting down simple sync manager');
+    
+    for (const [connection_id, connection] of this.connections) {
+      try {
+        connection.socket.end();
+      } catch (error) {
+        this.log.warn('Error closing secondary connection during shutdown', {
+          connection_id,
+          error: error.message
+        });
+      }
+    }
+    
+    this.connections.clear();
+    this.is_primary = false;
+    
+    this.log.info('Simple sync manager shutdown complete');
+  }
+}
+
+/** @type {SimpleSyncManager|null} Singleton instance */
+let sync_manager_instance = null;
+
+/**
+ * Gets the sync manager singleton instance.
+ * @returns {SimpleSyncManager} Sync manager instance
+ */
+export const get_simple_sync_manager = () => {
+  if (!sync_manager_instance) {
+    sync_manager_instance = new SimpleSyncManager();
+  }
+  return sync_manager_instance;
+};
+
+/**
+ * Initializes the sync manager singleton.
+ */
+export const initialize_simple_sync_manager = () => {
+  const manager = get_simple_sync_manager();
+  manager.initialize();
+};
+
+/**
+ * Shuts down the sync manager singleton.
+ * @returns {Promise<void>}
+ */
+export const shutdown_simple_sync_manager = async () => {
+  if (sync_manager_instance) {
+    await sync_manager_instance.shutdown();
+    sync_manager_instance = null;
+  }
+};