┌─────────────────────────────────────────────────────────────────┐
│           Infrastructure as Code-Prinzipien                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐     │
│  │   Versions-  │───▶│    Test-     │───▶│   Deployment-│     │
│  │   Kontrolle  │    │  Automatisierung│   │  Automatisierung│     │
│  └──────────────┘    └──────────────┘    └──────────────┘     │
│         │                   │                   │                │
│         ▼                   ▼                   ▼                │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐     │
│  │   Audit-     │    │   Team-      │    │   Skalierung  │     │
│  │   Trail      │    │   Kollaboration│   │   mit Vertrauen│     │
│  └──────────────┘    └──────────────┘    └──────────────┘     │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

// workflow-definition.ts
import { Workflow, Node, Connection } from 'n8n-as-code';

export const customerOnboardingWorkflow = new Workflow({
  name: 'Kunden-Onboarding',
  id: 'customer-onboarding-v2',
  
  nodes: [
    {
      name: 'Webhook Trigger',
      type: 'n8n-nodes-base.webhook',
      parameters: {
        httpMethod: 'POST',
        path: 'onboard-customer',
        responseMode: 'responseNode'
      },
      position: [250, 300]
    },
    {
      name: 'Eingabe validieren',
      type: 'n8n-nodes-base.function',
      parameters: {
        functionCode: `
          const required = ['email', 'company', 'plan'];
          const missing = required.filter(field => !items[0].json[field]);
          
          if (missing.length > 0) {
            throw new Error(\`Fehlende Pflichtfelder: \${missing.join(', ')}\`);
          }
          
          return [{
            json: {
              ...items[0].json,
              validated: true,
              timestamp: new Date().toISOString()
            }
          }];
        `
      },
      position: [450, 300]
    },
    {
      name: 'CRM Eintrag erstellen',
      type: 'n8n-nodes-base.salesforce',
      parameters: {
        resource: 'contact',
        operation: 'create',
        additionalFields: {
          Email: '={{ $input.email }}',
          Company: '={{ $input.company }}',
          LeadSource: 'Web Anmeldung'
        }
      },
      position: [650, 300]
    },
    {
      name: 'Willkommens-E-Mail senden',
      type: 'n8n-nodes-base.sendGrid',
      parameters: {
        fromEmail: '[email protected]',
        toEmail: '={{ $input.email }}',
        subject: 'Willkommen bei {{ $input.company }}!',
        html: '<p>Danke für Ihre Anmeldung!</p>'
      },
      position: [850, 300]
    },
    {
      name: 'Erfolgsantwort',
      type: 'n8n-nodes-base.respondToWebhook',
      parameters: {
        statusCode: 200,
        responseBody: {
          success: true,
          message: 'Onboarding gestartet'
        }
      },
      position: [1050, 300]
    }
  ],
  
  connections: {
    'Webhook Trigger': {
      main: [[{ node: 'Eingabe validieren', type: 'main', index: 0 }]]
    },
    'Eingabe validieren': {
      main: [[{ node: 'CRM Eintrag erstellen', type: 'main', index: 0 }]]
    },
    'CRM Eintrag erstellen': {
      main: [[{ node: 'Willkommens-E-Mail senden', type: 'main', index: 0 }]]
    },
    'Willkommens-E-Mail senden': {
      main: [[{ node: 'Erfolgsantwort', type: 'main', index: 0 }]]
    }
  },
  
  settings: {
    saveExecutionProgress: true,
    saveManualExecutions: true,
    executionTimeout: 300,
    errorWorkflow: 'error-handling-workflow'
  },
  
  tags: ['customer-success', 'onboarding', 'production']
});

# environments/production.yaml
n8n:
  base_url: https://n8n.company.com
  api_key: ${N8N_API_KEY}
  
webhooks:
  base_url: https://hooks.company.com
  
integrations:
  salesforce:
    instance_url: https://company.my.salesforce.com
    client_id: ${SF_CLIENT_ID}
    client_secret: ${SF_CLIENT_SECRET}
    
  sendgrid:
    api_key: ${SENDGRID_API_KEY}
    from_email: [email protected]
    
  database:
    host: prod-db.company.internal
    port: 5432
    database: n8n_production
    credentials: ${DB_CREDENTIALS}
    
settings:
  execution:
    timeout: 300
    max_retries: 3
    concurrent_limit: 50
    
  security:
    require_auth: true
    mfa_enabled: true
    audit_logging: true

┌─────────────────────────────────────────────────────────────────┐
│                    Git Sync Architektur                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────────┐          ┌──────────────┐                     │
│  │   Lokaler    │◄────────►│   Git Repo   │                     │
│  │   Editor     │   Push   │   (Source)   │                     │
│  │  (VS Code)   │          │   of Truth   │                     │
│  └──────────────┘          └──────┬───────┘                     │
│                                    │                            │
│                                    │ Pull/Merge                  │
│                                    ▼                            │
│                           ┌──────────────┐                      │
│                           │   n8n-as-code│                      │
│                           │     CLI      │                      │
│                           └──────┬───────┘                      │
│                                  │                              │
│              ┌───────────────────┼───────────────────┐         │
│              │                   │                   │          │
│              ▼                   ▼                   ▼          │
│        ┌──────────┐       ┌──────────┐       ┌──────────┐       │
│        │   Dev    │       │  Staging │       │   Prod   │       │
│        │ Instance │       │ Instance │       │ Instance │       │
│        └──────────┘       └──────────┘       └──────────┘       │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

# Global installieren
npm install -g n8n-as-code

# Oder npx für einmalige Befehle verwenden
npx n8n-as-code --help

# Installation überprüfen
n8nac --version
# Output: n8n-as-code v2.1.0

# Neues Projekt erstellen
n8nac init my-automation-project

cd my-automation-project

# Projektstruktur wird erstellt:
# .
# ├── n8n.config.yaml
# ├── workflows/
# │   ├── index.ts
# │   └── examples/
# ├── credentials/
# │   └── index.yaml
# ├── environments/
# │   ├── development.yaml
# │   ├── staging.yaml
# │   └── production.yaml
# ├── tests/
# │   └── workflows/
# ├── scripts/
# │   ├── deploy.sh
# │   └── validate.sh
# └── .github/
#     └── workflows/
#         └── ci-cd.yaml

# n8n.config.yaml
project:
  name: "Unternehmens-Automatisierungsplattform"
  version: "2.0.0"
  description: "Produktions-Workflow-Automatisierung"

instances:
  development:
    url: http://localhost:5678
    api_key: ${N8N_DEV_API_KEY}
    
  staging:
    url: https://n8n-staging.company.com
    api_key: ${N8N_STAGING_API_KEY}
    
  production:
    url: https://n8n.company.com
    api_key: ${N8N_PROD_API_KEY}

sync:
  mode: bidirectional  # oder 'push-only', 'pull-only'
  conflict_resolution: manual  # oder 'auto-accept-local', 'auto-accept-remote'
  backup_before_sync: true
  
validation:
  strict_mode: true
  require_tests: true
  max_workflow_size: 10MB
  forbidden_nodes:
    - n8n-nodes-base.executeCommand
    - n8n-nodes-base.ssh
    
git:
  commit_message_template: "[n8n] {action}: {workflow_name}"
  auto_commit: false
  branch_naming:
    pattern: "n8n/{workflow_name}/{action}"

# Git initialisieren
git init

# .gitignore erstellen
cat > .gitignore << 'EOF'
# Dependencies
node_modules/

# Environment files
.env
.env.local
.env.*.local

# Credentials (use n8n native credential store)
credentials/*.key
credentials/*.secret

# Runtime
dist/
build/
.cache/

# IDE
.vscode/
.idea/
*.swp
*.swo

# OS
.DS_Store
Thumbs.db
EOF

# Initialer Commit
git add .
git commit -m "[n8n] Initiales Projekt-Setup"

// workflows/lead-scoring.ts
import { Workflow, Node, If, Merge } from 'n8n-as-code';
import { nodes, logic } from 'n8n-as-code/stdlib';

export default new Workflow({
  name: 'Lead Scoring Automatisierung',
  id: 'lead-scoring-v1',
  
  // Workflow-Einstellungen
  settings: {
    saveExecutionProgress: true,
    executionTimeout: 120,
    errorWorkflow: 'error-handler'
  },
  
  // Trigger-Nodes
  triggers: [
    nodes.webhook({
      name: 'Lead Webhook',
      method: 'POST',
      path: 'score-lead',
      responseMode: 'responseNode'
    })
  ],
  
  // Verarbeitungs-Nodes
  nodes: [
    // Datenvalidierung
    nodes.function({
      name: 'Lead-Daten validieren',
      code: `
        const lead = items[0].json;
        const required = ['email', 'company', 'source'];
        const missing = required.filter(f => !lead[f]);
        
        if (missing.length > 0) {
          return [{ json: { error: \`Fehlt: \${missing.join(', ')}\` }, pairedItem: 0 }];
        }
        
        // Anfangswert berechnen
        let score = 0;
        if (lead.company?.includes('Enterprise')) score += 20;
        if (lead.source === 'LinkedIn') score += 15;
        if (lead.email?.includes('@company.com')) score += 10;
        
        return [{
          json: {
            ...lead,
            initialScore: score,
            validatedAt: new Date().toISOString()
          }
        }];
      `
    }),
    
    // Mit Clearbit anreichern
    nodes.httpRequest({
      name: 'Unternehmensdaten anreichern',
      method: 'GET',
      url: 'https://company.clearbit.com/v2/companies/find',
      authentication: 'genericCredentialType',
      genericAuthType: 'httpHeaderAuth',
      sendQuery: true,
      queryParameters: {
        parameters: [
          {
            name: 'domain',
            value: '={{ $input.email.split("@")[1] }}'
          }
        ]
      }
    }),
    
    // Endwert berechnen
    nodes.function({
      name: 'Endwert berechnen',
      code: `
        const lead = items[0].json;
        const enrichment = items[0].json.clearbit || {};
        
        let finalScore = lead.initialScore || 0;
        
        // Anreicherungspunkte hinzufügen
        if (enrichment.metrics?.employees) {
          if (enrichment.metrics.employees > 1000) finalScore += 30;
          else if (enrichment.metrics.employees > 500) finalScore += 20;
          else if (enrichment.metrics.employees > 100) finalScore += 10;
        }
        
        if (enrichment.metrics?.raised) {
          const raised = parseInt(enrichment.metrics.raised);
          if (raised > 100000000) finalScore += 25;
          else if (raised > 50000000) finalScore += 15;
          else if (raised > 10000000) finalScore += 10;
        }
        
        // Tier bestimmen
        let tier = 'cold';
        if (finalScore >= 80) tier = 'hot';
        else if (finalScore >= 50) tier = 'warm';
        
        return [{
          json: {
            ...lead,
            finalScore,
            tier,
            enrichment: {
              company: enrichment.name,
              industry: enrichment.category?.industry,
              employees: enrichment.metrics?.employees
            }
          }
        }];
      `
    }),
    
    // Bedingtes Routing basierend auf Tier
    new If({
      name: 'Nach Tier routen',
      conditions: {
        hot: '={{ $input.tier === "hot" }}',
        warm: '={{ $input.tier === "warm" }}',
        cold: '={{ $input.tier === "cold" }}'
      }
    }),
    
    // Hot Leads: Sofortige Slack-Benachrichtigung
    nodes.slack({
      name: 'Vertriebsteam alarmieren',
      channel: '#hot-leads',
      text: `
        🔥 Hot Lead Alarm!
        
        Unternehmen: {{ $input.company }}
        Score: {{ $input.finalScore }}/100
        Tier: {{ $input.tier }}
        E-Mail: {{ $input.email }}
        
        Anreicherung: {{ JSON.stringify($input.enrichment) }}
      `
    }),
    
    // Warme Leads: Zur Pflegesequenz hinzufügen
    nodes.activeCampaign({
      name: 'Zur Pflegesequenz hinzufügen',
      operation: 'create',
      resource: 'contact',
      additionalFields: {
        email: '={{ $input.email }}',
        firstName: '={{ $input.firstName }}',
        tags: 'warm-lead, nurturing'
      }
    }),
    
    // Kalte Leads: Für Analyse protokollieren
    nodes.postgres({
      name: 'Kalten Lead protokollieren',
      operation: 'insert',
      table: 'cold_leads',
      columns: {
        email: '={{ $input.email }}',
        company: '={{ $input.company }}',
        score: '={{ $input.finalScore }}',
        created_at: '={{ new Date().toISOString() }}'
      }
    }),
    
    // Branches zusammenführen
    new Merge({
      name: 'Ergebnisse kombinieren',
      mode: 'waitAll'
    }),
    
    // Finale Antwort
    nodes.respondToWebhook({
      name: 'Score zurückgeben',
      statusCode: 200,
      responseBody: {
        scored: true,
        score: '={{ $input.finalScore }}',
        tier: '={{ $input.tier }}'
      }
    })
  ],
  
  // Verbindungen definieren
  connections: [
    // Linearer Fluss
    { from: 'Lead Webhook', to: 'Lead-Daten validieren' },
    { from: 'Lead-Daten validieren', to: 'Unternehmensdaten anreichern' },
    { from: 'Unternehmensdaten anreichern', to: 'Endwert berechnen' },
    { from: 'Endwert berechnen', to: 'Nach Tier routen' },
    
    // Bedingte Branches
    { from: 'Nach Tier routen', to: 'Vertriebsteam alarmieren', condition: 'hot' },
    { from: 'Nach Tier routen', to: 'Zur Pflegesequenz hinzufügen', condition: 'warm' },
    { from: 'Nach Tier routen', to: 'Kalten Lead protokollieren', condition: 'cold' },
    
    // Zusammenführen
    { from: 'Vertriebsteam alarmieren', to: 'Ergebnisse kombinieren' },
    { from: 'Zur Pflegesequenz hinzufügen', to: 'Ergebnisse kombinieren' },
    { from: 'Kalten Lead protokollieren', to: 'Ergebnisse kombinieren' },
    { from: 'Ergebnisse kombinieren', to: 'Score zurückgeben' }
  ],
  
  tags: ['sales', 'lead-scoring', 'enrichment']
});

# Workflows von n8n-Instanz pullen
n8nac sync pull --instance development

# Workflow zu n8n pushen
n8nac sync push --instance development --workflow lead-scoring

# Alle Workflows synchronisieren
n8nac sync push --instance development --all

# Dry-Run um Änderungen zu sehen
n8nac sync push --instance development --dry-run

# .github/workflows/n8n-cicd.yaml
name: n8n CI/CD Pipeline

on:
  push:
    branches: [main, develop]
    paths:
      - 'workflows/**'
      - 'environments/**'
      - '.github/workflows/n8n-cicd.yaml'
  pull_request:
    branches: [main]
    paths:
      - 'workflows/**'

jobs:
  validate:
    name: Workflows validieren
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Node.js einrichten
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      
      - name: Abhängigkeiten installieren
        run: npm ci
      
      - name: TypeScript-Compiler ausführen
        run: npx tsc --noEmit
      
      - name: Workflows linten
        run: n8nac lint
      
      - name: Workflow-Schemas validieren
        run: n8nac validate --strict
      
      - name: Auf Sicherheitsprobleme prüfen
        run: n8nac security-scan
        env:
          N8N_SECURITY_RULES: strict

  test:
    name: Workflows testen
    runs-on: ubuntu-latest
    needs: validate
    services:
      n8n:
        image: n8nio/n8n:latest
        env:
          N8N_BASIC_AUTH_ACTIVE: "false"
          WEBHOOK_URL: http://localhost:5678/
        ports:
          - 5678:5678
      postgres:
        image: postgres:15
        env:
          POSTGRES_PASSWORD: test
          POSTGRES_DB: n8n_test
        ports:
          - 5432:5432
    steps:
      - uses: actions/checkout@v4
      
      - name: Node.js einrichten
        uses: actions/setup-node@v4
        with:
          node-version: '20'
      
      - name: Abhängigkeiten installieren
        run: npm ci
      
      - name: Zur Test-Instanz deployen
        run: n8nac sync push --instance test --all
        env:
          N8N_TEST_API_KEY: ${{ secrets.N8N_TEST_API_KEY }}
      
      - name: Integrationstests ausführen
        run: npm run test:integration
        env:
          N8N_BASE_URL: http://localhost:5678
          N8N_API_KEY: ${{ secrets.N8N_TEST_API_KEY }}
      
      - name: Workflow-spezifische Tests ausführen
        run: n8nac test --coverage
      
      - name: Coverage hochladen
        uses: codecov/codecov-action@v4

  deploy-staging:
    name: In Staging deployen
    runs-on: ubuntu-latest
    needs: [validate, test]
    if: github.ref == 'refs/heads/develop'
    environment:
      name: staging
      url: https://n8n-staging.company.com
    steps:
      - uses: actions/checkout@v4
      
      - name: Node.js einrichten
        uses: actions/setup-node@v4
        with:
          node-version: '20'
      
      - name: Abhängigkeiten installieren
        run: npm ci
      
      - name: In Staging deployen
        run: |
          n8nac sync push --instance staging --all
          n8nac activate --instance staging --all
        env:
          N8N_STAGING_API_KEY: ${{ secrets.N8N_STAGING_API_KEY }}
      
      - name: Smoke-Tests ausführen
        run: n8nac test --instance staging --smoke

  deploy-production:
    name: In Produktion deployen
    runs-on: ubuntu-latest
    needs: [validate, test]
    if: github.ref == 'refs/heads/main'
    environment:
      name: production
      url: https://n8n.company.com
    steps:
      - uses: actions/checkout@v4
      
      - name: Node.js einrichten
        uses: actions/setup-node@v4
        with:
          node-version: '20'
      
      - name: Abhängigkeiten installieren
        run: npm ci
      
      - name: Aktuelle Produktions-Workflows backupen
        run: |
          n8nac backup create --instance production \
            --name "pre-deploy-${{ github.sha }}"
        env:
          N8N_PROD_API_KEY: ${{ secrets.N8N_PROD_API_KEY }}
      
      - name: In Produktion deployen
        run: |
          n8nac sync push --instance production --all
          n8nac activate --instance production --all
        env:
          N8N_PROD_API_KEY: ${{ secrets.N8N_PROD_API_KEY }}
      
      - name: Deployment überprüfen
        run: |
          n8nac health-check --instance production
          n8nac test --instance production --smoke
        env:
          N8N_PROD_API_KEY: ${{ secrets.N8N_PROD_API_KEY }}
      
      - name: Bei Erfolg benachrichtigen
        if: success()
        uses: slackapi/slack-github-action@v1
        with:
          payload: |
            {
              "text": "✅ n8n-Workflows in Produktion deployed",
              "blocks": [
                {
                  "type": "section",
                  "text": {
                    "type": "mrkdwn",
                    "text": "*n8n Deployment abgeschlossen*\nCommit: ${{ github.sha }}\nWorkflows erfolgreich in Produktion deployed"
                  }
                }
              ]
            }
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
      
      - name: Bei Fehler rollbacken
        if: failure()
        run: |
          n8nac backup restore --instance production \
            --name "pre-deploy-${{ github.sha }}"
        env:
          N8N_PROD_API_KEY: ${{ secrets.N8N_PROD_API_KEY }}

// tests/workflows/lead-scoring.test.ts
import { describe, it, expect, beforeEach } from 'vitest';
import { WorkflowTester } from 'n8n-as-code/testing';
import leadScoringWorkflow from '../../workflows/lead-scoring';

describe('Lead Scoring Workflow', () => {
  let tester: WorkflowTester;
  
  beforeEach(() => {
    tester = new WorkflowTester(leadScoringWorkflow);
  });
  
  describe('Eingabevalidierung', () => {
    it('sollte Leads ohne Pflichtfelder ablehnen', async () => {
      const result = await tester.run({
        json: { email: '[email protected]' } // Fehlt company und source
      });
      
      expect(result[0].json.error).toContain('Fehlt');
    });
    
    it('sollte gültige Lead-Daten akzeptieren', async () => {
      const result = await tester.run({
        json: {
          email: '[email protected]',
          company: 'Enterprise Corp',
          source: 'LinkedIn',
          firstName: 'John'
        }
      });
      
      expect(result[0].json.validatedAt).toBeDefined();
      expect(result[0].json.initialScore).toBeGreaterThan(0);
    });
  });
  
  describe('Score-Berechnung', () => {
    it('sollte Unternehmen höher bewerten', async () => {
      const result = await tester.run({
        json: {
          email: '[email protected]',
          company: 'Enterprise Solutions Inc',
          source: 'Website'
        }
      });
      
      expect(result[0].json.initialScore).toBeGreaterThanOrEqual(20);
    });
    
    it('sollte Hot Leads korrekt kategorisieren', async () => {
      const result = await tester.run({
        json: {
          email: '[email protected]',
          company: 'Unicorn Startup',
          source: 'LinkedIn'
        },
        clearbit: {
          metrics: {
            employees: 5000,
            raised: '$150,000,000'
          }
        }
      });
      
      expect(result[0].json.tier).toBe('hot');
      expect(result[0].json.finalScore).toBeGreaterThanOrEqual(80);
    });
  });
  
  describe('Integration Points', () => {
    it('sollte Slack für Hot Leads aufrufen', async () => {
      const mockSlack = tester.mock('slack');
      
      await tester.run({
        json: {
          email: '[email protected]',
          company: 'Big Corp',
          source: 'LinkedIn'
        },
        clearbit: {
          metrics: { employees: 10000 }
        }
      });
      
      expect(mockSlack).toHaveBeenCalledWith(
        expect.objectContaining({
          channel: '#hot-leads'
        })
      );
    });
  });
});