Questing

{
  "external_id": "login-play-game",
  "account_type": "discord",
  "account_id": "901290221440733204"
}

const reference = `${accountId}-${externalId}-${Date.now()}`;

async function submitQuestCompletionWithRetry(
  gameId: string,
  apiKey: string,
  externalId: string,
  accountType: string,
  accountId: string,
  reference: string,
  maxRetries = 3
) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const response = await fetch(
        `https://api.immutable.com/quests/v2/games/${gameId}/quest-completions`,
        {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
            'x-immutable-api-key': apiKey,
          },
          body: JSON.stringify({
            external_id: externalId,
            account_type: accountType,
            account_id: accountId,
            reference,
            completion_time: new Date().toISOString(),
          }),
        }
      );

      // Success - return immediately
      if (response.ok) {
        return await response.json();
      }

      // 409 Conflict - already recorded, treat as success
      if (response.status === 409) {
        console.log(`Quest completion already recorded: ${reference}`);
        return { result: { status: 'already_completed' } };
      }

      // 4xx errors - don't retry (client error)
      if (response.status >= 400 && response.status < 500) {
        const error = await response.json();
        throw new Error(`Client error: ${error.message || response.statusText}`);
      }

      // 5xx errors - retry with exponential backoff
      if (response.status >= 500) {
        if (attempt < maxRetries) {
          const delay = Math.pow(2, attempt) * 1000; // Exponential backoff
          await new Promise(resolve => setTimeout(resolve, delay));
          continue;
        }
        throw new Error(`Server error after ${maxRetries} attempts`);
      }
    } catch (error) {
      if (attempt === maxRetries) {
        throw error;
      }
      // Network errors - retry with exponential backoff
      const delay = Math.pow(2, attempt) * 1000;
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

function logQuestCompletion(
  externalId: string,
  accountType: string,
  accountId: string,
  reference: string,
  status: 'success' | 'error',
  error?: string
) {
  const logEntry = {
    timestamp: new Date().toISOString(),
    quest: externalId,
    account: { type: accountType, id: accountId },
    reference,
    status,
    error,
  };

  // Log to your preferred logging service
  console.log(JSON.stringify(logEntry));
  
  // Optionally send to monitoring service
  // sendToMonitoring(logEntry);
}

if (response.status === 429) {
  const retryAfter = response.headers.get('Retry-After');
  const delay = retryAfter ? parseInt(retryAfter) * 1000 : 60000; // Default 60s
  await new Promise(resolve => setTimeout(resolve, delay));
  // Retry the request
}

function validateAccountId(accountType: string, accountId: string): boolean {
  switch (accountType) {
    case 'discord':
      // Discord IDs are numeric strings (snowflakes)
      return /^\d+$/.test(accountId);
    
    case 'telegram':
      // Telegram IDs are numeric
      return /^\d+$/.test(accountId);
    
    case 'metamask':
    case 'passport':
      // Wallet addresses are hex strings starting with 0x
      return /^0x[a-fA-F0-9]{40}$/.test(accountId);
    
    case 'email':
      // Basic email validation
      return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(accountId);
    
    case 'epic_games':
      // Epic Games IDs are alphanumeric strings
      return /^[a-zA-Z0-9]+$/.test(accountId);
    
    default:
      return false;
  }
}

// Add to queue instead of blocking
questCompletionQueue.add({
  externalId: 'catch-3-fish',
  accountType: 'discord',
  accountId: playerDiscordId,
  reference: generateReference(),
});

// Process queue in background
async function processQuestQueue() {
  while (true) {
    const item = await questCompletionQueue.get();
    try {
      await submitQuestCompletion(item);
    } catch (error) {
      // Log error and potentially re-queue
      logError(error);
    }
  }
}