┌─────────────────────────────────────────────────────────────────┐
│           หลักการ Infrastructure as Code                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐     │
│  │   Version    │───▶│     Test     │───▶│    Deploy    │     │
│  │   Control    │    │  Automation  │    │  Automation  │     │
│  └──────────────┘    └──────────────┘    └──────────────┘     │
│         │                   │                   │                │
│         ▼                   ▼                   ▼                │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐     │
│  │     Audit    │    │  Collaborate │    │    Scale     │     │
│  │     Trail    │    │   & Review   │    │  Confidently │     │
│  └──────────────┘    └──────────────┘    └──────────────┘     │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

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

export const customerOnboardingWorkflow = new Workflow({
  name: 'Customer 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: 'Validate Input',
      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(\`Missing required fields: \${missing.join(', ')}\`);
          }
          
          return [{
            json: {
              ...items[0].json,
              validated: true,
              timestamp: new Date().toISOString()
            }
          }];
        `
      },
      position: [450, 300]
    },
    {
      name: 'Create CRM Record',
      type: 'n8n-nodes-base.salesforce',
      parameters: {
        resource: 'contact',
        operation: 'create',
        additionalFields: {
          Email: '={{ $input.email }}',
          Company: '={{ $input.company }}',
          LeadSource: 'Web Signup'
        }
      },
      position: [650, 300]
    },
    {
      name: 'Send Welcome Email',
      type: 'n8n-nodes-base.sendGrid',
      parameters: {
        fromEmail: '[email protected]',
        toEmail: '={{ $input.email }}',
        subject: 'Welcome to {{ $input.company }}!',
        html: '<p>Thanks for signing up!</p>'
      },
      position: [850, 300]
    },
    {
      name: 'Success Response',
      type: 'n8n-nodes-base.respondToWebhook',
      parameters: {
        statusCode: 200,
        responseBody: {
          success: true,
          message: 'Onboarding initiated'
        }
      },
      position: [1050, 300]
    }
  ],
  
  connections: {
    'Webhook Trigger': {
      main: [[{ node: 'Validate Input', type: 'main', index: 0 }]]
    },
    'Validate Input': {
      main: [[{ node: 'Create CRM Record', type: 'main', index: 0 }]]
    },
    'Create CRM Record': {
      main: [[{ node: 'Send Welcome Email', type: 'main', index: 0 }]]
    },
    'Send Welcome Email': {
      main: [[{ node: 'Success Response', 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 Architecture                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────────┐          ┌──────────────┐                     │
│  │   Local      │◄────────►│   Git Repo   │                     │
│  │   Editor     │   Push   │   (Source)   │                     │
│  │  (VS Code)   │          │   of Truth   │                     │
│  └──────────────┘          └──────┬───────┘                     │
│                                    │                            │
│                                    │ Pull/Merge                  │
│                                    ▼                            │
│                           ┌──────────────┐                      │
│                           │   n8n-as-code│                      │
│                           │     CLI      │                      │
│                           └──────┬───────┘                      │
│                                  │                              │
│              ┌───────────────────┼───────────────────┐         │
│              │                   │                   │          │
│              ▼                   ▼                   ▼          │
│        ┌──────────┐       ┌──────────┐       ┌──────────┐       │
│        │   Dev    │       │  Staging │       │   Prod   │       │
│        │ Instance │       │ Instance │       │ Instance │       │
│        └──────────┘       └──────────┘       └──────────┘       │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

# ติดตั้งแบบ global
npm install -g n8n-as-code

# หรือใช้ npx สำหับ one-off commands
npx n8n-as-code --help

# ตรวจสอบการติดตั้ง
n8nac --version
# Output: n8n-as-code v2.1.0

# สร้างโปรเจคใหม่
n8nac init my-automation-project

cd my-automation-project

# โครงสร้างโปรเจคที่สร้าง:
# .
# ├── 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: "Enterprise Automation Platform"
  version: "2.0.0"
  description: "Production workflow automation"

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  # หรือ 'push-only', 'pull-only'
  conflict_resolution: manual  # หรือ '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}"

# Initialize Git
git init

# สร้าง .gitignore
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

# Initial commit
git add .
git commit -m "[n8n] Initial project 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 Automation',
  id: 'lead-scoring-v1',
  
  // Workflow-level settings
  settings: {
    saveExecutionProgress: true,
    executionTimeout: 120,
    errorWorkflow: 'error-handler'
  },
  
  // Trigger nodes
  triggers: [
    nodes.webhook({
      name: 'Lead Webhook',
      method: 'POST',
      path: 'score-lead',
      responseMode: 'responseNode'
    })
  ],
  
  // Processing nodes
  nodes: [
    // Data validation
    nodes.function({
      name: 'Validate Lead Data',
      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: \`Missing: \${missing.join(', ')}\` }, pairedItem: 0 }];
        }
        
        // Calculate initial score
        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()
          }
        }];
      `
    }),
    
    // Enrich with Clearbit
    nodes.httpRequest({
      name: 'Enrich Company Data',
      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] }}'
          }
        ]
      }
    }),
    
    // Calculate final score
    nodes.function({
      name: 'Calculate Final Score',
      code: `
        const lead = items[0].json;
        const enrichment = items[0].json.clearbit || {};
        
        let finalScore = lead.initialScore || 0;
        
        // Add enrichment points
        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;
        }
        
        // Determine tier
        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
            }
          }
        }];
      `
    }),
    
    // Conditional routing based on tier
    new If({
      name: 'Route by Tier',
      conditions: {
        hot: '={{ $input.tier === "hot" }}',
        warm: '={{ $input.tier === "warm" }}',
        cold: '={{ $input.tier === "cold" }}'
      }
    }),
    
    // Hot leads: Immediate Slack alert
    nodes.slack({
      name: 'Alert Sales Team',
      channel: '#hot-leads',
      text: `
        🔥 Hot Lead Alert!
        
        Company: {{ $input.company }}
        Score: {{ $input.finalScore }}/100
        Tier: {{ $input.tier }}
        Email: {{ $input.email }}
        
        Enrichment: {{ JSON.stringify($input.enrichment) }}
      `
    }),
    
    // Warm leads: Add to nurturing sequence
    nodes.activeCampaign({
      name: 'Add to Nurture Sequence',
      operation: 'create',
      resource: 'contact',
      additionalFields: {
        email: '={{ $input.email }}',
        firstName: '={{ $input.firstName }}',
        tags: 'warm-lead, nurturing'
      }
    }),
    
    // Cold leads: Log for analysis
    nodes.postgres({
      name: 'Log Cold Lead',
      operation: 'insert',
      table: 'cold_leads',
      columns: {
        email: '={{ $input.email }}',
        company: '={{ $input.company }}',
        score: '={{ $input.finalScore }}',
        created_at: '={{ new Date().toISOString() }}'
      }
    }),
    
    // Merge branches
    new Merge({
      name: 'Combine Results',
      mode: 'waitAll'
    }),
    
    // Final response
    nodes.respondToWebhook({
      name: 'Return Score',
      statusCode: 200,
      responseBody: {
        scored: true,
        score: '={{ $input.finalScore }}',
        tier: '={{ $input.tier }}'
      }
    })
  ],
  
  // Define connections
  connections: [
    // Linear flow
    { from: 'Lead Webhook', to: 'Validate Lead Data' },
    { from: 'Validate Lead Data', to: 'Enrich Company Data' },
    { from: 'Enrich Company Data', to: 'Calculate Final Score' },
    { from: 'Calculate Final Score', to: 'Route by Tier' },
    
    // Conditional branches
    { from: 'Route by Tier', to: 'Alert Sales Team', condition: 'hot' },
    { from: 'Route by Tier', to: 'Add to Nurture Sequence', condition: 'warm' },
    { from: 'Route by Tier', to: 'Log Cold Lead', condition: 'cold' },
    
    // Merge back
    { from: 'Alert Sales Team', to: 'Combine Results' },
    { from: 'Add to Nurture Sequence', to: 'Combine Results' },
    { from: 'Log Cold Lead', to: 'Combine Results' },
    { from: 'Combine Results', to: 'Return Score' }
  ],
  
  tags: ['sales', 'lead-scoring', 'enrichment']
});

# Pull workflows จาก n8n instance
n8nac sync pull --instance development

# Push workflow ไปยัง n8n
n8nac sync push --instance development --workflow lead-scoring

# Sync ทุก workflows
n8nac sync push --instance development --all

# Dry run เพื่อดูว่าอะไรจะเปลี่ยน
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: Validate Workflows
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run TypeScript compiler
        run: npx tsc --noEmit
      
      - name: Lint workflows
        run: n8nac lint
      
      - name: Validate workflow schemas
        run: n8nac validate --strict
      
      - name: Check for security issues
        run: n8nac security-scan
        env:
          N8N_SECURITY_RULES: strict

  test:
    name: Test Workflows
    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: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Deploy to test instance
        run: n8nac sync push --instance test --all
        env:
          N8N_TEST_API_KEY: ${{ secrets.N8N_TEST_API_KEY }}
      
      - name: Run integration tests
        run: npm run test:integration
        env:
          N8N_BASE_URL: http://localhost:5678
          N8N_API_KEY: ${{ secrets.N8N_TEST_API_KEY }}
      
      - name: Run workflow-specific tests
        run: n8nac test --coverage
      
      - name: Upload coverage
        uses: codecov/codecov-action@v4

  deploy-staging:
    name: Deploy to Staging
    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: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Deploy to staging
        run: |
          n8nac sync push --instance staging --all
          n8nac activate --instance staging --all
        env:
          N8N_STAGING_API_KEY: ${{ secrets.N8N_STAGING_API_KEY }}
      
      - name: Run smoke tests
        run: n8nac test --instance staging --smoke

  deploy-production:
    name: Deploy to Production
    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: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Backup current production workflows
        run: |
          n8nac backup create --instance production \
            --name "pre-deploy-${{ github.sha }}"
        env:
          N8N_PROD_API_KEY: ${{ secrets.N8N_PROD_API_KEY }}
      
      - name: Deploy to production
        run: |
          n8nac sync push --instance production --all
          n8nac activate --instance production --all
        env:
          N8N_PROD_API_KEY: ${{ secrets.N8N_PROD_API_KEY }}
      
      - name: Verify deployment
        run: |
          n8nac health-check --instance production
          n8nac test --instance production --smoke
        env:
          N8N_PROD_API_KEY: ${{ secrets.N8N_PROD_API_KEY }}
      
      - name: Notify on success
        if: success()
        uses: slackapi/slack-github-action@v1
        with:
          payload: |
            {
              "text": "✅ n8n workflows deployed to production",
              "blocks": [
                {
                  "type": "section",
                  "text": {
                    "type": "mrkdwn",
                    "text": "*n8n Deployment Complete*\nCommit: ${{ github.sha }}\nWorkflows deployed successfully to production"
                  }
                }
              ]
            }
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
      
      - name: Rollback on failure
        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('Input Validation', () => {
    it('should reject leads without required fields', async () => {
      const result = await tester.run({
        json: { email: '[email protected]' } // Missing company and source
      });
      
      expect(result[0].json.error).toContain('Missing');
    });
    
    it('should accept valid lead data', 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 Calculation', () => {
    it('should score enterprise companies higher', async () => {
      const result = await tester.run({
        json: {
          email: '[email protected]',
          company: 'Enterprise Solutions Inc',
          source: 'Website'
        }
      });
      
      expect(result[0].json.initialScore).toBeGreaterThanOrEqual(20);
    });
    
    it('should categorize hot leads correctly', 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('should call Slack for hot leads', 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'
        })
      );
    });
  });
});