SDK errors and retries

import {
  APIConnectionError,
  APIError,
  ISnapClient,
  QuotaExceededError,
  RateLimitError
} from '@isnap/sdk'

const client = new ISnapClient({ apiKey: process.env.ISNAP_API_KEY ?? '', maxRetries: 2 })

try {
  const message = await client.messages.send({
    line_id: 'line_8Xk2mQ4vTn7Bw9Rz3Lc6Yp1Hd',
    to: '+14155550123',
    body: 'Your order has shipped.'
  })
  console.log(message.id, message.status)
} catch (err) {
  if (err instanceof QuotaExceededError || err instanceof RateLimitError) {
    // A 429. Neither class extends the other: test both.
    const delay = typeof err.retryAfter === 'number' ? `${err.retryAfter} s` : 'not stated'
    console.error(`${err.code}, delay: ${delay}`)
  } else if (err instanceof APIError) {
    switch (err.code) {
      case 'validation_failed':
        for (const issue of Array.isArray(err.issues) ? err.issues : []) {
          console.error(JSON.stringify(issue.path), issue.code, issue.message)
        }
        break
      case 'line_suspended':
      case 'line_not_active':
        console.error(`The line cannot send: ${err.code}`)
        break
      default:
        console.error(err.status, err.code, err.traceId, err.requestId)
    }
  } else if (err instanceof APIConnectionError) {
    // No usable response. The API may have received the request.
    console.error(err.message)
  } else {
    throw err
  }
}

import { ISnapClient, RateLimitError } from '@isnap/sdk'

// No wait longer than 5 seconds before a retry: a 429 that states 60 seconds is thrown immediately.
const client = new ISnapClient({
  apiKey: process.env.ISNAP_API_KEY ?? '',
  maxRetries: 2,
  maxRetryDelayMs: 5_000
})

try {
  const { lines } = await client.lines.listMine()
  console.log(lines.length)

  // One call without any retry.
  const line = await client.lines.get('line_8Xk2mQ4vTn7Bw9Rz3Lc6Yp1Hd', { maxRetries: 0 })
  console.log(line.status)
} catch (err) {
  if (!(err instanceof RateLimitError)) throw err
  console.error(`${err.code}: wait ${err.retryAfter} seconds before the next request.`)
}

import { APIConnectionError, ISnapClient } from '@isnap/sdk'

const client = new ISnapClient({ apiKey: process.env.ISNAP_API_KEY ?? '', maxRetries: 2 })
const url = 'https://hooks.your-domain.example/isnap'

try {
  const webhook = await client.webhooks.create({ url, events: ['message.*'] }, { maxRetries: 0 })
  console.log(webhook.id)
} catch (err) {
  if (!(err instanceof APIConnectionError)) throw err
  // The API may have created the subscription. Look before you create again.
  const { webhooks } = await client.webhooks.list()
  const created = webhooks.some((webhook) => webhook.url === url)
  console.error(created ? 'Created, and the response was lost.' : 'Not created.')
}

import { ISnapClient } from '@isnap/sdk'

const client = new ISnapClient({ apiKey: process.env.ISNAP_API_KEY ?? '', maxRetries: 2 })

// One key per message you intend to send, built from a record of your own.
// Store it with your record of the message: reuse it to retry.
const idempotencyKey = 'order-4812-shipped'

const message = await client.messages.send(
  {
    line_id: 'line_8Xk2mQ4vTn7Bw9Rz3Lc6Yp1Hd',
    to: '+14155550123',
    body: 'Your order has shipped.'
  },
  { idempotencyKey }
)
console.log(message.id, message.status)

import { ISnapClient } from '@isnap/sdk'

const client = new ISnapClient({
  apiKey: process.env.ISNAP_API_KEY ?? '',
  maxRetries: 2,
  idempotencyKey: 'manual'
})

// The call carries the key you pass. Without it, the call carries no key and is still retried.
// Store the key with your record of the reaction: reuse it to retry.
const idempotencyKey = 'ticket-9271-like'

const reaction = await client.messages.addReaction(
  'msg_3Fh8Kq2Zx7Wn5Tb9Rm4Yc6Jd1',
  { type: 'like' },
  { idempotencyKey }
)
console.log(reaction)

import { APIConnectionError, ISnapClient } from '@isnap/sdk'

const client = new ISnapClient({ apiKey: process.env.ISNAP_API_KEY ?? '', maxRetries: 2 })

// Abort the call after 5 seconds, retries included. A response body that has started
// to arrive is still read to the end.
const controller = new AbortController()
const timer = setTimeout(() => controller.abort(new Error('5 seconds spent')), 5_000)

try {
  const { lines } = await client.lines.listMine({ signal: controller.signal })
  console.log(lines.length)
} catch (err) {
  if (!(err instanceof APIConnectionError) || !controller.signal.aborted) throw err
  console.error('Canceled:', err.cause)
} finally {
  clearTimeout(timer)
}