API

curl -X GET "https://automate.localmind.ai/api/v1/workflows" \
  -H "X-Api-Key: your-api-key-here"

X-RateLimit-Limit: 100
X-RateLimit-Remaining: 95
X-RateLimit-Reset: 1640995200

async function makeApiRequest(url, options) {
  const response = await fetch(url, options);
  
  if (response.status === 429) {
    // Rate Limit erreicht
    const resetTime = parseInt(response.headers.get('X-RateLimit-Reset'));
    const waitTime = resetTime - Math.floor(Date.now() / 1000);
    
    console.log(`Rate limit erreicht. Warte ${waitTime} Sekunden...`);
    await new Promise(resolve => setTimeout(resolve, waitTime * 1000));
    
    // Retry
    return makeApiRequest(url, options);
  }
  
  return response;
}

GET /api/v1/workflows
X-Api-Key: your-api-key-here

GET /api/v1/workflows/workflow_123
X-Api-Key: your-api-key-here

POST /api/v1/workflows
X-Api-Key: your-api-key-here
Content-Type: application/json

{
  "name": "New Workflow",
  "nodes": [
    {
      "id": "node_1",
      "type": "webhook",
      "name": "Webhook",
      "parameters": {}
    }
  ],
  "connections": {},
  "settings": {
    "saveDataErrorExecution": "all",
    "saveDataSuccessExecution": "all"
  }
}

PUT /api/v1/workflows/workflow_123
X-Api-Key: your-api-key-here
Content-Type: application/json

{
  "name": "Updated Workflow Name",
  "active": true,
  "nodes": [...],
  "connections": {...}
}

POST /api/v1/workflows/workflow_123/activate
X-Api-Key: your-api-key-here

DELETE /api/v1/workflows/workflow_123
X-Api-Key: your-api-key-here

GET /api/v1/executions?workflowId=workflow_123&limit=50&status=success
X-Api-Key: your-api-key-here

GET /api/v1/executions/execution_789
X-Api-Key: your-api-key-here

POST /api/v1/workflows/workflow_123/execute
X-Api-Key: your-api-key-here
Content-Type: application/json

{
  "data": {
    "main": [
      [
        {
          "json": {
            "input": "Test data"
          }
        }
      ]
    ]
  }
}

GET /api/v1/workflows/workflow_123/webhook
X-Api-Key: your-api-key-here

curl -X POST "https://automate.localmind.ai/webhook/workflow_123/abc123" \
  -H "Content-Type: application/json" \
  -d '{
    "test": "data"
  }'

{
  "error": {
    "message": "Workflow nicht gefunden",
    "code": "WORKFLOW_NOT_FOUND",
    "statusCode": 404,
    "details": {
      "workflowId": "workflow_123"
    }
  }
}

async function apiRequestWithRetry(url, options, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const response = await fetch(url, options);
      
      if (response.ok) {
        return await response.json();
      }
      
      // Retry bei 5xx Fehlern
      if (response.status >= 500 && attempt < maxRetries) {
        const waitTime = Math.pow(2, attempt) * 1000; // Exponential backoff
        await new Promise(resolve => setTimeout(resolve, waitTime));
        continue;
      }
      
      throw new Error(`HTTP ${response.status}`);
    } catch (error) {
      if (attempt === maxRetries) {
        throw error;
      }
      
      const waitTime = Math.pow(2, attempt) * 1000;
      await new Promise(resolve => setTimeout(resolve, waitTime));
    }
  }
}

function logApiCall(method, url, status, duration) {
  console.log({
    timestamp: new Date().toISOString(),
    method,
    url,
    status,
    duration: `${duration}ms`,
  });
}

async function monitoredApiCall(url, options) {
  const startTime = Date.now();
  
  try {
    const response = await fetch(url, options);
    const duration = Date.now() - startTime;
    
    logApiCall(options.method || 'GET', url, response.status, duration);
    
    return response;
  } catch (error) {
    const duration = Date.now() - startTime;
    logApiCall(options.method || 'GET', url, 'ERROR', duration);
    throw error;
  }
}

class AutomateApiClient {
  constructor(apiKey, baseUrl = 'https://automate.localmind.ai/api/v1') {
    this.apiKey = apiKey;
    this.baseUrl = baseUrl;
  }

  async request(endpoint, options = {}) {
    const url = `${this.baseUrl}${endpoint}`;
    const headers = {
      'X-Api-Key': this.apiKey,
      'Content-Type': 'application/json',
      ...options.headers,
    };

    const response = await fetch(url, {
      ...options,
      headers,
    });

    if (!response.ok) {
      const error = await response.json();
      throw new Error(error.error?.message || `HTTP ${response.status}`);
    }

    return await response.json();
  }

  async getWorkflows() {
    return this.request('/workflows');
  }

  async getWorkflow(id) {
    return this.request(`/workflows/${id}`);
  }

  async createWorkflow(workflow) {
    return this.request('/workflows', {
      method: 'POST',
      body: JSON.stringify(workflow),
    });
  }

  async executeWorkflow(id, data) {
    return this.request(`/workflows/${id}/execute`, {
      method: 'POST',
      body: JSON.stringify({ data }),
    });
  }
}

// Verwendung
const client = new AutomateApiClient('your-api-key');

// Workflows abrufen
const workflows = await client.getWorkflows();
console.log(workflows.data);

// Workflow ausführen
const execution = await client.executeWorkflow('workflow_123', {
  main: [[{ json: { input: 'Test' } }]],
});
console.log('Execution ID:', execution.data.id);