Error Reference

import { WochaAuthenticationError } from "@wocha/sdk";
 
try {
  await wocha.apiKeys.list();
} catch (err) {
  if (err instanceof WochaAuthenticationError) {
    switch (err.errorCode) {
      case "invalid_key":
      case "expired_key":
      case "key_revoked":
        alertOps("Rotate management API key", err.requestId);
        break;
      case "token_inactive":
        await refreshOAuthToken();
        break;
      default:
        console.error(err.errorCode, err.docsUrl);
    }
  }
}

from wocha.errors import AuthenticationError
 
try:
    wocha.api_keys.list()
except AuthenticationError as e:
    if e.error_code in ("invalid_key", "expired_key", "key_revoked"):
        alert_ops(f"Rotate key ({e.request_id})")
    elif e.error_code == "token_inactive":
        refresh_oauth_token()
    else:
        print(e.error_code, e.docs_url)

_, err := client.APIKeys.List(ctx, nil)
var authErr *wocha.AuthenticationError
if errors.As(err, &authErr) {
    switch authErr.Code {
    case "invalid_key", "expired_key", "key_revoked":
        alertOps(authErr.RequestID)
    case "token_inactive":
        refreshOAuthToken()
    default:
        log.Println(authErr.Code, authErr.DocsURL)
    }
}

import { GreetPermissionError } from "@wocha/sdk";
 
try {
  await wocha.users.create({ email: "user@example.com" });
} catch (err) {
  if (err instanceof GreetPermissionError) {
    if (err.errorCode === "insufficient_scope") {
      console.error("Add users:write scope to your API key");
    } else if (err.errorCode === "quota_exceeded") {
      console.error("Plan quota reached — upgrade or remove unused resources");
    } else {
      console.error(err.errorCode, err.requestId);
    }
  }
}

from wocha.errors import PermissionError
 
try:
    wocha.users.create(email="user@example.com")
except PermissionError as e:
    if e.error_code == "insufficient_scope":
        print("Add users:write scope to your API key")
    elif e.error_code == "quota_exceeded":
        print("Plan quota reached")
    else:
        print(e.error_code, e.request_id)

_, err := client.Users.Create(ctx, &wocha.UserCreateParams{Email: "user@example.com"})
var permErr *wocha.PermissionError
if errors.As(err, &permErr) {
    switch permErr.Code {
    case "insufficient_scope":
        log.Println("Add users:write scope to your API key")
    case "quota_exceeded":
        log.Println("Plan quota reached")
    default:
        log.Println(permErr.Code, permErr.RequestID)
    }
}

import { WochaValidationError, WochaNotFoundError, WochaConflictError } from "@wocha/sdk";
 
try {
  await wocha.organisations.create({ slug: "engineering", display_name: "Engineering" });
} catch (err) {
  if (err instanceof WochaValidationError) {
    for (const [field, messages] of Object.entries(err.fieldErrors ?? {})) {
      setFieldError(field, messages[0]);
    }
  } else if (err instanceof WochaConflictError) {
    const { data } = await wocha.organisations.list();
    const existing = data.find((o) => o.slug === "engineering");
    if (existing) return existing;
  } else if (err instanceof WochaNotFoundError) {
    return null;
  }
  throw err;
}

from wocha.errors import ValidationError, ConflictError, NotFoundError
 
try:
    wocha.organisations.create(slug="engineering", display_name="Engineering")
except ValidationError as e:
    for field, messages in (e.field_errors or {}).items():
        set_field_error(field, messages[0])
except ConflictError:
    for org in wocha.organisations.list_all():
        if org["slug"] == "engineering":
            return org
except NotFoundError:
    return None

org, err := client.Organisations.Create(ctx, &wocha.OrganisationCreateParams{
    Slug: "engineering", DisplayName: "Engineering",
})
var validation *wocha.ValidationError
var conflict *wocha.ConflictError
var notFound *wocha.NotFoundError
switch {
case errors.As(err, &validation):
    for field, msgs := range validation.FieldErrors {
        setFieldError(field, msgs[0])
    }
case errors.As(err, &conflict):
    orgs, _ := client.Organisations.ListAll(ctx, nil)
    for _, o := range orgs {
        if o.Slug == "engineering" {
            return &o, nil
        }
    }
case errors.As(err, &notFound):
    return nil, nil
}

import { WochaRateLimitError } from "@wocha/sdk";
 
try {
  await wocha.logs.list({ page_size: 50 });
} catch (err) {
  if (err instanceof WochaRateLimitError) {
    const delay = (err.retryAfter ?? 60) * 1000;
    await new Promise((r) => setTimeout(r, delay));
    return wocha.logs.list({ page_size: 50 });
  }
  throw err;
}

import time
from wocha.errors import RateLimitError
 
try:
    wocha.logs.list(page_size=50)
except RateLimitError as e:
    time.sleep(e.retry_after or 60)
    wocha.logs.list(page_size=50)

logs, err := client.Logs.List(ctx, &wocha.ListParams{PageSize: wocha.Int(50)})
var rateLimit *wocha.RateLimitError
if errors.As(err, &rateLimit) {
    delay := 60
    if rateLimit.RetryAfter != nil {
        delay = *rateLimit.RetryAfter
    }
    time.Sleep(time.Duration(delay) * time.Second)
    logs, err = client.Logs.List(ctx, &wocha.ListParams{PageSize: wocha.Int(50)})
}

import { GreetServerError } from "@wocha/sdk";
 
async function withRetry<T>(fn: () => Promise<T>, attempts = 3): Promise<T> {
  for (let i = 0; i < attempts; i++) {
    try {
      return await fn();
    } catch (err) {
      if (err instanceof GreetServerError && err.statusCode >= 500 && i < attempts - 1) {
        await new Promise((r) => setTimeout(r, 1000 * 2 ** i));
        continue;
      }
      throw err;
    }
  }
  throw new Error("unreachable");
}

import time
from wocha.errors import ServerError
 
def with_retry(fn, attempts=3):
    for i in range(attempts):
        try:
            return fn()
        except ServerError as e:
            if e.status_code >= 500 and i < attempts - 1:
                time.sleep(2 ** i)
                continue
            raise

func withRetry[T any](attempts int, fn func() (T, error)) (T, error) {
    var zero T
    var lastErr error
    for i := 0; i < attempts; i++ {
        result, err := fn()
        if err == nil {
            return result, nil
        }
        var server *wocha.ServerError
        if errors.As(err, &server) && server.StatusCode >= 500 && i < attempts-1 {
            time.Sleep(time.Duration(1<<i) * time.Second)
            lastErr = err
            continue
        }
        return zero, err
    }
    return zero, lastErr
}