CONNECT

// JavaScript - Complete OAuth flow
const express = require('express');
const { WaveClient } = require('@wave/sdk');

const app = express();
const wave = new WaveClient({
  clientId: process.env.WAVE_CLIENT_ID,
  clientSecret: process.env.WAVE_CLIENT_SECRET,
  redirectUri: 'https://yourapp.com/callback'
});

// Step 1: Redirect to authorization
app.get('/auth', (req, res) => {
  const authUrl = wave.oauth.getAuthorizationUrl({
    scope: ['streams:read', 'streams:write', 'analytics:read'],
    state: generateRandomState() // CSRF protection
  });
  res.redirect(authUrl);
});

// Step 2: Handle callback
app.get('/callback', async (req, res) => {
  const { code, state } = req.query;

  // Verify state for CSRF protection
  if (!verifyState(state)) {
    return res.status(400).send('Invalid state');
  }

  // Exchange code for tokens
  const tokens = await wave.oauth.exchangeCode(code);
  // tokens: { access_token, refresh_token, expires_in }

  // Store tokens securely
  await saveUserTokens(req.user.id, tokens);

  res.redirect('/dashboard');
});

// Step 3: Use access token
app.get('/api/streams', async (req, res) => {
  const tokens = await getUserTokens(req.user.id);
  const authenticatedWave = new WaveClient({ accessToken: tokens.access_token });

  const streams = await authenticatedWave.streams.list();
  res.json(streams);
});

// Node.js - Secure webhook handling
const crypto = require('crypto');

function verifyWebhookSignature(payload, signature, secret) {
  const hmac = crypto.createHmac('sha256', secret);
  const digest = hmac.update(payload).digest('hex');
  const expectedSignature = `sha256=${digest}`;

  // Use timing-safe comparison
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expectedSignature)
  );
}

app.post('/webhooks/wave', express.raw({ type: 'application/json' }), (req, res) => {
  const signature = req.headers['x-wave-signature'];
  const payload = req.body.toString();

  if (!verifyWebhookSignature(payload, signature, process.env.WAVE_WEBHOOK_SECRET)) {
    return res.status(401).send('Invalid signature');
  }

  const event = JSON.parse(payload);

  // Process event
  switch (event.type) {
    case 'stream.started':
      await handleStreamStarted(event.data);
      break;
    case 'stream.ended':
      await handleStreamEnded(event.data);
      break;
    // ... handle other events
  }

  res.json({ received: true });
});

# Python equivalent
import hmac
import hashlib

def verify_webhook_signature(payload: bytes, signature: str, secret: str) -> bool:
    expected_signature = hmac.new(
        secret.encode('utf-8'),
        payload,
        hashlib.sha256
    ).hexdigest()

    return hmac.compare_digest(
        signature,
        f"sha256={expected_signature}"
    )

// Real-time stream metrics via WebSocket
import { WaveWebSocket } from '@wave/sdk';

const ws = new WaveWebSocket({
  apiKey: process.env.WAVE_API_KEY
});

// Connect and authenticate
await ws.connect();

// Subscribe to stream events
await ws.subscribe('stream.metrics', { streamId: 'stream_abc123' });

// Listen for real-time updates
ws.on('stream.metrics', (data) => {
  console.log('Current viewers:', data.viewers);
  console.log('Current bitrate:', data.bitrate);
  console.log('Dropped frames:', data.droppedFrames);

  // Update UI in real-time
  updateDashboard(data);
});

// Subscribe to chat messages
await ws.subscribe('stream.chat', { streamId: 'stream_abc123' });

ws.on('stream.chat', (message) => {
  console.log(`${message.user}: ${message.text}`);
  displayChatMessage(message);
});

// Handle errors and reconnection
ws.on('error', (error) => {
  console.error('WebSocket error:', error);
});

ws.on('close', () => {
  console.log('Connection closed, attempting reconnect...');
  setTimeout(() => ws.connect(), 5000);
});

// Efficient pagination through large result sets
async function fetchAllStreams(wave) {
  const allStreams = [];
  let cursor = null;

  do {
    const response = await wave.streams.list({
      limit: 100, // Fetch 100 items per page
      cursor: cursor // Continue from last position
    });

    allStreams.push(...response.data);
    cursor = response.pagination.nextCursor;

    console.log(`Fetched ${allStreams.length} of ${response.pagination.total} streams`);

  } while (cursor); // Continue until no more pages

  return allStreams;
}

// Usage
const wave = new WaveClient({ apiKey: process.env.WAVE_API_KEY });
const streams = await fetchAllStreams(wave);
console.log(`Total streams: ${streams.length}`);

// Create multiple streams efficiently
const wave = new WaveClient({ apiKey: process.env.WAVE_API_KEY });

const streamConfigs = [
  { title: 'Stream 1', protocol: 'srt', quality: '1080p' },
  { title: 'Stream 2', protocol: 'webrtc', quality: '4k' },
  { title: 'Stream 3', protocol: 'rtmp', quality: '720p' }
];

// Batch create (single API call)
const result = await wave.streams.batchCreate(streamConfigs);

console.log(`Created ${result.successful.length} streams`);
console.log(`Failed ${result.failed.length} streams`);

// Process results
result.successful.forEach(stream => {
  console.log(`✓ Created stream: ${stream.id}`);
});

result.failed.forEach(error => {
  console.error(`✗ Failed: ${error.message}`);
});

// Batch update streams
const updates = [
  { id: 'stream_1', title: 'Updated Title 1' },
  { id: 'stream_2', title: 'Updated Title 2' }
];

await wave.streams.batchUpdate(updates);

// Robust error handling with exponential backoff
async function retryableRequest(fn, maxRetries = 3) {
  let lastError;

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      lastError = error;

      // Don't retry client errors (4xx)
      if (error.status >= 400 && error.status < 500) {
        throw error;
      }

      // Check if we should retry
      if (attempt < maxRetries - 1) {
        const delay = Math.min(1000 * Math.pow(2, attempt), 10000);
        console.log(`Retry ${attempt + 1}/${maxRetries} after ${delay}ms`);
        await new Promise(resolve => setTimeout(resolve, delay));
      }
    }
  }

  throw lastError;
}

// Usage
const wave = new WaveClient({ apiKey: process.env.WAVE_API_KEY });

try {
  const stream = await retryableRequest(() =>
    wave.streams.create({
      title: 'My Stream',
      protocol: 'srt'
    })
  );
  console.log('Stream created:', stream.id);
} catch (error) {
  console.error('Failed after retries:', error.message);
  // Handle failure (notify user, log to monitoring, etc.)
}

// Respect rate limits with automatic backoff
class RateLimitedClient {
  constructor(wave) {
    this.wave = wave;
    this.queue = [];
    this.processing = false;
  }

  async request(fn) {
    return new Promise((resolve, reject) => {
      this.queue.push({ fn, resolve, reject });
      this.processQueue();
    });
  }

  async processQueue() {
    if (this.processing || this.queue.length === 0) return;

    this.processing = true;
    const { fn, resolve, reject } = this.queue.shift();

    try {
      const result = await fn();
      resolve(result);
    } catch (error) {
      if (error.status === 429) {
        // Rate limited - respect Retry-After header
        const retryAfter = parseInt(error.headers['retry-after']) || 60;
        console.log(`Rate limited. Retrying after ${retryAfter}s`);

        // Re-queue the request
        this.queue.unshift({ fn, resolve, reject });

        // Wait before processing next request
        await new Promise(r => setTimeout(r, retryAfter * 1000));
      } else {
        reject(error);
      }
    }

    this.processing = false;
    this.processQueue();
  }
}

// Usage
const wave = new WaveClient({ apiKey: process.env.WAVE_API_KEY });
const rateLimited = new RateLimitedClient(wave);

// All requests automatically respect rate limits
const stream1 = await rateLimited.request(() => wave.streams.create({...}));
const stream2 = await rateLimited.request(() => wave.streams.create({...}));

# Fetch nested stream data with analytics
query GetStreamWithAnalytics($streamId: ID!, $period: TimePeriod!) {
  stream(id: $streamId) {
    id
    title
    status
    protocol
    settings {
      quality
      bitrate
      latency
    }

    # Current viewers
    viewers {
      total
      byCountry {
        country
        count
      }
    }

    # Analytics for specified period
    analytics(period: $period) {
      viewers {
        peak
        average
        total
      }
      watchTime {
        total
        average
      }
      engagement {
        likes
        comments
        shares
      }
    }

    # Recording info
    recordings {
      id
      duration
      size
      downloadUrl
      createdAt
    }
  }
}

# JavaScript usage
const { GraphQLClient } = require('@wave/sdk');

const client = new GraphQLClient({
  apiKey: process.env.WAVE_API_KEY
});

const data = await client.query(query, {
  streamId: 'stream_abc123',
  period: 'LAST_7_DAYS'
});

console.log('Stream:', data.stream.title);
console.log('Peak viewers:', data.stream.analytics.viewers.peak);
console.log('Total watch time:', data.stream.analytics.watchTime.total);

// iOS - Swift
import WaveSDK

class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_ application: UIApplication,
                    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

        // Initialize WAVE SDK
        Wave.configure(
            apiKey: "your_api_key",
            environment: .production,
            options: WaveOptions(
                enableAnalytics: true,
                enableDebugLogging: false,
                autoReconnect: true
            )
        )

        return true
    }
}

// Create and start stream
let streamManager = Wave.streams()

streamManager.create(
    title: "My iOS Stream",
    protocol: .webrtc,
    quality: .hd1080p
) { result in
    switch result {
    case .success(let stream):
        print("Stream created: \(stream.id)")

        // Start broadcasting
        streamManager.start(streamId: stream.id) { startResult in
            if case .success = startResult {
                print("Stream started successfully")
            }
        }

    case .failure(let error):
        print("Error: \(error.localizedDescription)")
    }
}

// Android - Kotlin
import com.wave.sdk.Wave
import com.wave.sdk.WaveOptions
import com.wave.sdk.models.StreamProtocol

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Initialize WAVE SDK
        Wave.configure(
            context = this,
            apiKey = "your_api_key",
            options = WaveOptions(
                enableAnalytics = true,
                enableDebugLogging = false,
                autoReconnect = true
            )
        )

        // Create stream
        val streamManager = Wave.streams()

        streamManager.create(
            title = "My Android Stream",
            protocol = StreamProtocol.WEBRTC,
            quality = StreamQuality.HD_1080P
        ).subscribe { stream ->
            println("Stream created: ${stream.id}")

            // Start broadcasting
            streamManager.start(stream.id).subscribe {
                println("Stream started successfully")
            }
        }
    }
}

// app/streams/[streamId]/page.tsx
import { WaveClient } from '@wave/sdk';
import { StreamPlayer } from '@/components/StreamPlayer';

import { DesignTokens, getContainer, getSection } from '@/lib/design-tokens';
// Server Component - fetch data at build/request time
export default async function StreamPage({
  params
}: {
  params: { streamId: string }
}) {
  const wave = new WaveClient({
    apiKey: process.env.WAVE_API_KEY
  });

  // Fetch stream data on server
  const stream = await wave.streams.get(params.streamId);

  if (!stream) {
    notFound();
  }

  // Pre-fetch analytics for better UX
  const analytics = await wave.analytics.getStreamStats(params.streamId);

  return (
    <div>
      <h1>{stream.title}</h1>

      {/* Player component (Client Component) */}
      <StreamPlayer
        streamId={stream.id}
        playbackUrl={stream.playbackUrl}
        protocol={stream.protocol}
      />

      {/* Pre-rendered analytics */}
      <div className="analytics">
        <p>Current Viewers: {analytics.viewers}</p>
        <p>Peak Viewers: {analytics.peakViewers}</p>
      </div>
    </div>
  );
}

// Generate static params for ISR
export async function generateStaticParams() {
  const wave = new WaveClient({ apiKey: process.env.WAVE_API_KEY });
  const streams = await wave.streams.list({ limit: 100 });

  return streams.data.map((stream) => ({
    streamId: stream.id,
  }));
}

// Revalidate every 60 seconds
export const revalidate = 60;