Authentication Setup

{
  "name": "Development Integration",
  "environment": "staging",
  "permissions": [
    "customer:read",
    "customer:write",
    "loyalty:read", 
    "loyalty:write",
    "coupons:validate",
    "coupons:redeem"
  ],
  "rate_limit": 500,
  "description": "Key for development and testing"
}

{
  "name": "Production PDV Integration", 
  "environment": "production",
  "permissions": [
    "customer:read",
    "customer:write",
    "loyalty:read",
    "coupons:validate", 
    "coupons:redeem"
  ],
  "rate_limit": 1000,
  "ip_restrictions": [
    "203.0.113.0/24",  // Your office network
    "198.51.100.15"    // Production server IP
  ],
  "expires_at": "2025-12-31T23:59:59Z"
}

{
  "api_key": "zup_test_sk_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6",
  "key_id": "key_abc123def456", 
  "name": "Development Integration",
  "environment": "staging",
  "permissions": [
    "customer:read",
    "customer:write", 
    "loyalty:read",
    "loyalty:write",
    "coupons:validate",
    "coupons:redeem"
  ],
  "rate_limit": 500,
  "ip_restrictions": [],
  "created_at": "2025-09-04T10:30:00Z",
  "expires_at": "2026-09-04T10:30:00Z",
  "last_used_at": null,
  "usage_count": 0
}

# Zupy API Configuration
ZUPY_API_KEY=zup_test_sk_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6
ZUPY_BASE_URL=https://api-staging.zupy.com/v1
ZUPY_COMPANY_ID=your_company_identifier

# Production values (use separate .env.production)
# ZUPY_API_KEY=zup_live_sk_production_key_here
# ZUPY_BASE_URL=https://api.zupy.com/v1

version: '3.8'
services:
  your-app:
    image: your-app:latest
    environment:
      - ZUPY_API_KEY=${ZUPY_API_KEY}
      - ZUPY_BASE_URL=${ZUPY_BASE_URL}
      - ZUPY_COMPANY_ID=${ZUPY_COMPANY_ID}
    env_file:
      - .env.production

class ZupyAuthentication {
  constructor(apiKey, baseUrl) {
    this.apiKey = apiKey;
    this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
    this.headers = {
      'Authorization': `Bearer ${apiKey}`,
      'Content-Type': 'application/json',
      'User-Agent': 'YourApp/1.0.0'
    };
  }

  async makeRequest(endpoint, options = {}) {
    const url = `${this.baseUrl}${endpoint}`;
    
    const config = {
      ...options,
      headers: {
        ...this.headers,
        ...options.headers
      }
    };

    try {
      const response = await fetch(url, config);
      
      // Check for authentication errors
      if (response.status === 401) {
        throw new Error('Authentication failed: Invalid or expired API key');
      }
      
      if (response.status === 403) {
        throw new Error('Permission denied: API key lacks required permissions');
      }
      
      if (response.status === 429) {
        const retryAfter = response.headers.get('X-RateLimit-Reset');
        throw new Error(`Rate limit exceeded. Retry after: ${retryAfter}`);
      }
      
      if (!response.ok) {
        const errorData = await response.json().catch(() => null);
        throw new Error(`API Error ${response.status}: ${errorData?.message || response.statusText}`);
      }
      
      return await response.json();
    } catch (error) {
      console.error('Zupy API Error:', error);
      throw error;
    }
  }

  // Test authentication
  async testConnection() {
    try {
      const result = await this.makeRequest('/loyalty/program');
      console.log('✅ Authentication successful');
      return { success: true, program: result };
    } catch (error) {
      console.error('❌ Authentication failed:', error.message);
      return { success: false, error: error.message };
    }
  }
}

// Usage
const zupy = new ZupyAuthentication(
  process.env.ZUPY_API_KEY,
  process.env.ZUPY_BASE_URL
);

// Test authentication on startup
zupy.testConnection().then(result => {
  if (!result.success) {
    console.error('Failed to authenticate with Zupy API');
    process.exit(1);
  }
});

class ZupyHealthCheck {
  constructor(zupyAuth) {
    this.zupy = zupyAuth;
    this.lastCheck = null;
    this.healthStatus = null;
  }

  async performHealthCheck() {
    try {
      const startTime = Date.now();
      const result = await this.zupy.makeRequest('/loyalty/program');
      const responseTime = Date.now() - startTime;
      
      this.healthStatus = {
        healthy: true,
        responseTime: responseTime,
        timestamp: new Date().toISOString(),
        lastError: null
      };
      
      console.log(`✅ Zupy API healthy (${responseTime}ms)`);
      return this.healthStatus;
      
    } catch (error) {
      this.healthStatus = {
        healthy: false,
        responseTime: null,
        timestamp: new Date().toISOString(),
        lastError: error.message
      };
      
      console.error(`❌ Zupy API unhealthy: ${error.message}`);
      return this.healthStatus;
    }
  }

  // Schedule regular health checks
  startMonitoring(intervalMinutes = 5) {
    const interval = intervalMinutes * 60 * 1000;
    
    // Initial check
    this.performHealthCheck();
    
    // Regular checks
    setInterval(() => {
      this.performHealthCheck();
    }, interval);
  }
}

// Usage
const healthCheck = new ZupyHealthCheck(zupy);
healthCheck.startMonitoring(5); // Check every 5 minutes