integrations.js

Go to the documentation of this file.

/**
 * @file integrations.js
 * @module IntegrationsRoutes
 * @description API routes for managing third-party integrations for tenants. Handles CRUD, enable/disable, and configuration of integrations. All routes require authentication and tenant context.
 * @see {@link ../services/db} for database connection
 * @see {@link ../middleware/auth} for authentication middleware
 * @see {@link ../middleware/tenant} for tenant context utilities
 * @apiDefine IntegrationsGroup Integrations
 * @apiGroup Integrations
 * @apiHeader {string} Authorization Bearer token required.
 * @apiHeader {string} X-Tenant-ID Tenant context header required.
 * @apiError (Error 401) Unauthorized Missing or invalid token.
 * @apiError (Error 403) Forbidden Tenant context missing or invalid.
 * @apiError (Error 500) ServerError Internal server error.
 */
 
const express = require('express');
const router = express.Router();
const pool = require('../services/db');
const authenticateToken = require('../middleware/auth');
const { getTenantFilter, setTenantContext } = require('../middleware/tenant');
 
// Apply authentication and tenant context to all routes
router.use(authenticateToken, setTenantContext);
 
// GET /integrations - List all integrations for tenant
router.get('/', async (req, res) => {
  try {
    const { clause: tenantClause, params: tenantParams } = getTenantFilter(req, 'i');
    
    let query = `
      SELECT i.integration_id, i.integration_type, i.config, i.is_active, 
             i.created_at, i.updated_at, i.tenant_id,
             t.name as tenant_name,
             p.name as plugin_name, p.description as plugin_description, p.logo_url, p.config_schema
      FROM integrations i
      LEFT JOIN tenants t ON i.tenant_id = t.tenant_id
      LEFT JOIN plugins p ON i.integration_type = p.type
      WHERE 1=1
    `;
    
    let queryParams = [];
    
    if (tenantClause) {
      query += ` AND ${tenantClause}`;
      queryParams.push(...tenantParams);
    }
    
    query += ` ORDER BY i.integration_type ASC`;
    
    const result = await pool.query(query, queryParams);
    res.json(result.rows);
  } catch (err) {
    console.error('Error fetching integrations:', err);
    res.status(500).json({ error: 'Server error' });
  }
});
 
/**
 * @api {get} /integrations List all integrations for tenant
 * @apiName GetIntegrations
 * @apiGroup Integrations
 * @apiDescription Retrieve all integrations (with plugin metadata) for the current tenant.
 * @apiSuccess {object[]} integrations List of integrations.
 * @apiExample {curl} Example usage:
 *     curl -H "Authorization: Bearer <token>" -H "X-Tenant-ID: <id>" https://api.example.com/integrations
 */
 
// ==========================================
// GENERIC ROUTES
// ==========================================
// Note: RustDesk and Guacamole specific routes removed - MeshCentral-only architecture
 
// GET /integrations/:id - Get single integration
router.get('/:id', async (req, res) => {
  const { id } = req.params;
  try {
    const { clause: tenantClause, params: tenantParams, nextParamIndex } = getTenantFilter(req, 'i');
    
    let query = `
      SELECT i.integration_id, i.integration_type, i.config, i.is_active,
             i.created_at, i.updated_at, i.tenant_id,
             t.name as tenant_name
      FROM integrations i
      LEFT JOIN tenants t ON i.tenant_id = t.tenant_id
      WHERE i.integration_id = $1
    `;
    
    let queryParams = [id];
    
    if (tenantClause) {
      query += ` AND ${tenantClause}`;
      queryParams.push(...tenantParams);
    }
    
    const result = await pool.query(query, queryParams);
    
    if (result.rows.length === 0) {
      return res.status(404).json({ error: 'Integration not found' });
    }
    
    res.json(result.rows[0]);
  } catch (err) {
    console.error('Error fetching integration:', err);
    res.status(500).json({ error: 'Server error' });
  }
});
 
/**
 * @api {get} /integrations/:id Get single integration
 * @apiName GetIntegration
 * @apiGroup Integrations
 * @apiDescription Retrieve a single integration by ID for the current tenant.
 * @apiParam {string} id Integration ID.
 * @apiSuccess {object} integration Integration object.
 * @apiError (Error 404) NotFound Integration not found.
 * @apiExample {curl} Example usage:
 *     curl -H "Authorization: Bearer <token>" -H "X-Tenant-ID: <id>" https://api.example.com/integrations/123
 */
 
// POST /integrations - Create new integration
router.post('/', async (req, res) => {
  const { integration_type, config, is_active = true } = req.body;
  
  if (!integration_type) {
    return res.status(400).json({ error: 'integration_type is required' });
  }
  
  try {
    const result = await pool.query(
      `INSERT INTO integrations (integration_type, config, is_active, tenant_id, created_at, updated_at)
       VALUES ($1, $2, $3, $4, NOW(), NOW())
       RETURNING *`,
      [integration_type, JSON.stringify(config || {}), is_active, req.tenant.id]
    );
    
    res.status(201).json(result.rows[0]);
  } catch (err) {
    console.error('Error creating integration:', err);
    
    // Check for unique constraint violation (duplicate integration type per tenant)
    if (err.code === '23505') {
      return res.status(400).json({ error: 'This integration already exists for your tenant' });
    }
    
    res.status(500).json({ error: 'Server error' });
  }
});
 
/**
 * @api {post} /integrations Create new integration
 * @apiName CreateIntegration
 * @apiGroup Integrations
 * @apiDescription Create a new integration for the current tenant.
 * @apiParam {string} integration_type Type of integration (e.g., rustdesk, guacamole).
 * @apiParam {object} [config] Integration configuration object.
 * @apiParam {boolean} [is_active=true] Whether the integration is active.
 * @apiSuccess {object} integration Created integration object.
 * @apiError (Error 400) DuplicateIntegration This integration already exists for your tenant.
 * @apiExample {curl} Example usage:
 *     curl -X POST -H "Authorization: Bearer <token>" -H "X-Tenant-ID: <id>" -d '{"integration_type":"custom","config":{}}' https://api.example.com/integrations
 */
 
// PUT /integrations/:id - Update integration
router.put('/:id', async (req, res) => {
  const { id } = req.params;
  const { integration_type, config, is_active } = req.body;
  
  try {
    // First check if integration exists and belongs to tenant
    const checkQuery = `SELECT * FROM integrations WHERE integration_id = $1 AND tenant_id = $2`;
    const checkResult = await pool.query(checkQuery, [id, req.tenant.id]);
    
    if (checkResult.rows.length === 0) {
      return res.status(404).json({ error: 'Integration not found' });
    }
    
    // Build update query dynamically based on provided fields
    const updates = [];
    const values = [];
    let paramIndex = 1;
    
    if (integration_type !== undefined) {
      updates.push(`integration_type = $${paramIndex++}`);
      values.push(integration_type);
    }
    
    if (config !== undefined) {
      updates.push(`config = $${paramIndex++}`);
      values.push(JSON.stringify(config));
    }
    
    if (is_active !== undefined) {
      updates.push(`is_active = $${paramIndex++}`);
      values.push(is_active);
    }
    
    updates.push(`updated_at = NOW()`);
    
    if (updates.length === 1) { // Only updated_at
      return res.status(400).json({ error: 'No fields to update' });
    }
    
    values.push(id, req.tenant.id);
    
    const query = `
      UPDATE integrations 
      SET ${updates.join(', ')}
      WHERE integration_id = $${paramIndex++} AND tenant_id = $${paramIndex++}
      RETURNING *
    `;
    
    const result = await pool.query(query, values);
    res.json(result.rows[0]);
  } catch (err) {
    console.error('Error updating integration:', err);
    res.status(500).json({ error: 'Server error' });
  }
});
 
/**
 * @api {put} /integrations/:id Update integration
 * @apiName UpdateIntegration
 * @apiGroup Integrations
 * @apiDescription Update an existing integration for the current tenant. Only provided fields will be updated.
 * @apiParam {string} id Integration ID.
 * @apiParam {string} [integration_type] Type of integration.
 * @apiParam {object} [config] Integration configuration object.
 * @apiParam {boolean} [is_active] Whether the integration is active.
 * @apiSuccess {object} integration Updated integration object.
 * @apiError (Error 404) NotFound Integration not found.
 * @apiError (Error 400) NoFields No fields to update.
 * @apiExample {curl} Example usage:
 *     curl -X PUT -H "Authorization: Bearer <token>" -H "X-Tenant-ID: <id>" -d '{"is_active":false}' https://api.example.com/integrations/123
 */
 
// DELETE /integrations/:id - Delete integration
router.delete('/:id', async (req, res) => {
  const { id } = req.params;
  
  try {
    const result = await pool.query(
      `DELETE FROM integrations WHERE integration_id = $1 AND tenant_id = $2 RETURNING *`,
      [id, req.tenant.id]
    );
    
    if (result.rows.length === 0) {
      return res.status(404).json({ error: 'Integration not found' });
    }
    
    res.json({ message: 'Integration deleted successfully' });
  } catch (err) {
    console.error('Error deleting integration:', err);
    res.status(500).json({ error: 'Server error' });
  }
});
 
module.exports = router;