digitalOceanService.js

Go to the documentation of this file.

/**
 * DigitalOcean API Service
 * Handles API interactions with DigitalOcean App Platform, Droplets, and Databases
 * Multi-tenant aware - each instance is bound to a specific tenant
 */
 
const axios = require('axios');
const pool = require('../db');
 
const DO_API_BASE = 'https://api.digitalocean.com/v2';
 
/**
 * DigitalOcean API service.
 * Multi-tenant aware service for interacting with DigitalOcean App Platform, Droplets, and Databases.
 */
class DigitalOceanService {
  /**
   * Initialize DigitalOcean service for specific tenant.
   * @param {number} tenantId - Tenant ID
   */
  constructor(tenantId) {
    this.tenantId = tenantId;
    this.config = null;
    this.apiToken = null;
  }
 
  /**
   * Load DigitalOcean configuration for the tenant.
   * @returns {Promise<object>} Configuration object with API token
   */
  async loadConfig() {
    // First, try to use environment variable (for root tenant or global config)
    if (process.env.DO_API_TOKEN) {
      console.log('[DO] Using DO_API_TOKEN from environment');
      this.apiToken = process.env.DO_API_TOKEN;
      return { api_token_encrypted: this.apiToken };
    }
 
    // Otherwise, load from database
    const result = await pool.query(
      'SELECT * FROM digitalocean_config WHERE tenant_id = $1 AND is_active = true',
      [this.tenantId]
    );
    
    if (result.rows.length === 0) {
      throw new Error('DigitalOcean configuration not found for this tenant. Please configure DO API token first.');
    }
    
    this.config = result.rows[0];
    // TODO: Decrypt api_token_encrypted before using
    this.apiToken = this.config.api_token_encrypted; // Implement decryption later
    return this.config;
  }
 
  /**
   * Make authenticated API request to DigitalOcean
   * @param {string} method - HTTP method (GET, POST, PATCH, DELETE)
   * @param {string} endpoint - API endpoint (e.g., '/apps')
   * @param {object} [data] - Request body data (for POST/PATCH)
   * @param {object} [params] - Query parameters
   * @returns {Promise<object>} API response data
   */
  async apiRequest(method, endpoint, data = null, params = null) {
    if (!this.apiToken) {
      await this.loadConfig();
    }
    
    try {
      const config = {
        method,
        url: `${DO_API_BASE}${endpoint}`,
        headers: {
          'Authorization': `Bearer ${this.apiToken}`,
          'Content-Type': 'application/json'
        }
      };
 
      if (data) {
        config.data = data;
      }
 
      if (params) {
        config.params = params;
      }
 
      console.log(`[DO] ${method} ${endpoint}`);
      const response = await axios(config);
      return response.data;
    } catch (error) {
      console.error(`[DO] API request failed:`, error.response?.data || error.message);
      throw new Error(`DigitalOcean API error: ${error.response?.data?.message || error.message}`);
    }
  }
 
  /**
   * Test API connection.
   * @returns {Promise<boolean>} True if connection successful
   */
  async testConnection() {
    try {
      const account = await this.apiRequest('GET', '/account');
      return {
        success: true,
        account: {
          email: account.account.email,
          status: account.account.status,
          uuid: account.account.uuid
        }
      };
    } catch (error) {
      return {
        success: false,
        error: error.message
      };
    }
  }
 
  // ===========================
  // App Platform API Methods
  // ===========================
 
  /**
   * List all apps in the account
   * @returns {Promise<Array>} List of app objects
   */
  async listApps() {
    const data = await this.apiRequest('GET', '/apps');
    return data.apps || [];
  }
 
  /**
   * Get specific app details
   * @param {string} appId - DigitalOcean App ID
   * @returns {Promise<object>} App object
   */
  async getApp(appId) {
    const data = await this.apiRequest('GET', `/apps/${appId}`);
    return data.app;
  }
 
  /**
   * Get app deployments
   * @param {string} appId - DigitalOcean App ID
   * @returns {Promise<Array>} List of deployment objects
   */
  async getAppDeployments(appId) {
    const data = await this.apiRequest('GET', `/apps/${appId}/deployments`);
    return data.deployments || [];
  }
 
  /**
   * Trigger a new deployment
   * @param {string} appId - DigitalOcean App ID
   * @param {boolean} [forceRebuild] - Force rebuild from source
   * @returns {Promise<object>} Deployment object
   */
  async createDeployment(appId, forceRebuild = false) {
    const data = await this.apiRequest('POST', `/apps/${appId}/deployments`, {
      force_build: forceRebuild
    });
    return data.deployment;
  }
 
  /**
   * Update an app's configuration
   * @param {string} appId - DigitalOcean App ID
   * @param {object} appSpec - Updated app specification
   * @returns {Promise<object>} Updated app object
   */
  async updateApp(appId, appSpec) {
    const data = await this.apiRequest('PUT', `/apps/${appId}`, {
      spec: appSpec
    });
    return data.app;
  }
 
  /**
   * Get app logs
   * @param {string} appId - DigitalOcean App ID
   * @param {string} deploymentId - Deployment ID
   * @param {string} componentName - Component name
   * @param {string} [type] - Log type ('build', 'deploy', 'run')
   * @returns {Promise<object>} Log data
   */
  async getAppLogs(appId, deploymentId, componentName, type = 'run') {
    const data = await this.apiRequest('GET', `/apps/${appId}/deployments/${deploymentId}/components/${componentName}/logs`, null, {
      type,
      follow: false
    });
    return data.historic_urls || [];
  }
 
  // ===========================
  // Droplets API Methods
  // ===========================
 
  /**
   * List all droplets in the account
   * @returns {Promise<Array>} List of droplet objects
   */
  async listDroplets() {
    const data = await this.apiRequest('GET', '/droplets');
    return data.droplets || [];
  }
 
  /**
   * Get specific droplet details
   * @param {number} dropletId - Droplet ID
   * @returns {Promise<object>} Droplet object
   */
  async getDroplet(dropletId) {
    const data = await this.apiRequest('GET', `/droplets/${dropletId}`);
    return data.droplet;
  }
 
  /**
   * Create a new droplet
   * @param {object} config - Droplet configuration
   * @returns {Promise<object>} Created droplet object
   */
  async createDroplet(config) {
    const data = await this.apiRequest('POST', '/droplets', config);
    return data.droplet;
  }
 
  /**
   * Delete a droplet
   * @param {number} dropletId - Droplet ID
   * @returns {Promise<object>} Success confirmation
   */
  async deleteDroplet(dropletId) {
    await this.apiRequest('DELETE', `/droplets/${dropletId}`);
    return { success: true };
  }
 
  /**
   * Power on/off droplet
   * @param {number} dropletId - Droplet ID
   * @param {string} action - 'power_on', 'power_off', 'reboot', 'shutdown'
   * @returns {Promise<object>} Action object
   */
  async dropletAction(dropletId, action) {
    const data = await this.apiRequest('POST', `/droplets/${dropletId}/actions`, {
      type: action
    });
    return data.action;
  }
 
  // ===========================
  // Databases API Methods
  // ===========================
 
  /**
   * List all managed databases
   * @returns {Promise<Array>} List of database objects
   */
  async listDatabases() {
    const data = await this.apiRequest('GET', '/databases');
    return data.databases || [];
  }
 
  /**
   * Get specific database details
   * @param {string} databaseId - Database cluster UUID
   * @returns {Promise<object>} Database object
   */
  async getDatabase(databaseId) {
    const data = await this.apiRequest('GET', `/databases/${databaseId}`);
    return data.database;
  }
 
  /**
   * Get database users
   * @param {string} databaseId - Database cluster UUID
   * @returns {Promise<Array>} List of database user objects
   */
  async getDatabaseUsers(databaseId) {
    const data = await this.apiRequest('GET', `/databases/${databaseId}/users`);
    return data.users || [];
  }
 
  /**
   * Get database connection pools
   * @param {string} databaseId - Database cluster UUID
   * @returns {Promise<Array>} List of connection pool objects
   */
  async getDatabasePools(databaseId) {
    const data = await this.apiRequest('GET', `/databases/${databaseId}/pools`);
    return data.pools || [];
  }
 
  // ===========================
  // Volumes API Methods
  // ===========================
 
  /**
   * List all volumes
   * @returns {Promise<Array>} List of volume objects
   */
  async listVolumes() {
    const data = await this.apiRequest('GET', '/volumes');
    return data.volumes || [];
  }
 
  /**
   * Get volume details
   * @param {string} volumeId - Volume UUID
   * @returns {Promise<object>} Volume object
   */
  async getVolume(volumeId) {
    const data = await this.apiRequest('GET', `/volumes/${volumeId}`);
    return data.volume;
  }
 
  // ===========================
  // Projects API Methods
  // ===========================
 
  /**
   * List all projects
   * @returns {Promise<Array>} List of project objects
   */
  async listProjects() {
    const data = await this.apiRequest('GET', '/projects');
    return data.projects || [];
  }
 
  /**
   * Get specific project details
   * @param {string} projectId - Project UUID
   * @returns {Promise<object>} Project object
   */
  async getProject(projectId) {
    const data = await this.apiRequest('GET', `/projects/${projectId}`);
    return data.project;
  }
 
  /**
   * Find project by name
   * @param {string} projectName - Project name to search for
   * @returns {Promise<object|undefined>} Project object if found
   */
  async findProjectByName(projectName) {
    const projects = await this.listProjects();
    return projects.find(p => p.name.toLowerCase().includes(projectName.toLowerCase()));
  }
 
  // ===========================
  // Monitoring API Methods
  // ===========================
 
  /**
   * Get droplet metrics (CPU, memory, disk, bandwidth)
   * @param {number} dropletId - Droplet ID
   * @param {string} [metric] - Metric type: 'cpu', 'memory_free', 'memory_available', 'disk_read', 'disk_write', 'bandwidth_inbound', 'bandwidth_outbound'
   * @param {number} [start] - Start time (UTC unix timestamp)
   * @param {number} [end] - End time (UTC unix timestamp)
   * @returns {Promise<object>} Metrics data
   */
  async getDropletMetrics(dropletId, metric = 'cpu', start = null, end = null) {
    const now = Math.floor(Date.now() / 1000);
    const params = {
      host_id: dropletId,
      start: start || (now - 3600), // Default: last hour
      end: end || now
    };
    
    const data = await this.apiRequest('GET', `/monitoring/metrics/droplet/${metric}`, null, params);
    return data.data;
  }
 
  /**
   * Get database metrics (CPU, memory, disk, connections)
   * @param {string} databaseId - Database cluster UUID
   * @returns {Promise<object|null>} Database metrics or null on error
   */
  async getDatabaseMetrics(databaseId) {
    try {
      // Get basic database info first
      const db = await this.getDatabase(databaseId);
      
      // Get metrics - note: DB metrics may not be available for all clusters
      // DOC doesn't have direct metrics API for databases like droplets
      // We'll return the database status and connection info instead
      return {
        status: db.status,
        cpu_count: db.num_nodes || 1,
        memory_mb: this.parseDatabaseSize(db.size).memory,
        disk_gb: this.parseDatabaseSize(db.size).disk,
        connection: {
          host: db.connection?.host || null,
          port: db.connection?.port || null,
          protocol: db.connection?.protocol || null
        },
        nodes: db.num_nodes || 1
      };
    } catch (error) {
      console.error(`[DO] Error fetching database metrics:`, error.message);
      return null;
    }
  }
 
  /**
   * Parse database size string to extract memory and disk
   * @param {string} size - Size string like 'db-s-1vcpu-1gb' or 'db-s-2vcpu-4gb-60gb'
   * @returns {object} Parsed size with vcpus, memory (MB), and disk (GB)
   */
  parseDatabaseSize(size) {
    if (!size) return { vcpus: null, memory: null, disk: null };
    
    // Parse formats like: db-s-1vcpu-1gb, db-s-2vcpu-4gb, db-s-2vcpu-4gb-60gb
    const vcpuMatch = size.match(/(\d+)vcpu/);
    const memMatch = size.match(/(\d+)gb(?!-)/i); // GB not followed by hyphen
    const diskMatch = size.match(/-(\d+)gb$/i); // GB at end with hyphen before
    
    return {
      vcpus: vcpuMatch ? parseInt(vcpuMatch[1]) : null,
      memory: memMatch ? parseInt(memMatch[1]) * 1024 : null, // Convert to MB
      disk: diskMatch ? parseInt(diskMatch[1]) : null
    };
  }
 
  /**
   * Get app metrics (CPU, memory from most recent deployment)
   * @param {string} appId - App UUID
   * @returns {Promise<object|null>} App metrics or null on error
   */
  async getAppMetrics(appId) {
    try {
      const app = await this.getApp(appId);
      
      // App Platform doesn't expose detailed runtime metrics via API
      // We return deployment status and tier information instead
      return {
        status: app.phase || 'unknown',
        tier: app.tier_slug || 'basic',
        instance_count: app.spec?.services?.reduce((sum, s) => sum + (s.instance_count || 1), 0) || 1,
        instance_size: app.spec?.services?.[0]?.instance_size_slug || 'basic-xxs',
        region: app.region?.slug || null,
        live_url: app.live_url || null,
        created_at: app.created_at,
        updated_at: app.updated_at
      };
    } catch (error) {
      console.error(`[DO] Error fetching app metrics:`, error.message);
      return null;
    }
  }
 
  // ===========================
  // Utility Methods
  // ===========================
 
  /**
   * Get all resources summary
   * @returns {Promise<object>} Summary of all DigitalOcean resources
   */
  async getAllResources() {
    const [apps, droplets, databases, volumes] = await Promise.all([
      this.listApps().catch(() => []),
      this.listDroplets().catch(() => []),
      this.listDatabases().catch(() => []),
      this.listVolumes().catch(() => [])
    ]);
 
    return {
      apps,
      droplets,
      databases,
      volumes,
      summary: {
        total_apps: apps.length,
        total_droplets: droplets.length,
        total_databases: databases.length,
        total_volumes: volumes.length
      }
    };
  }
}
 
module.exports = DigitalOceanService;