Error Types Reference

class SnackBaseError extends Error {
  public readonly code: string;
  public readonly status?: number;
  public readonly details?: any;
  public readonly field?: string;
  public readonly retryable: boolean;

  constructor(
    message: string,
    code: string,
    status?: number,
    details?: any,
    retryable: boolean = false,
    field?: string
  )
}

class AuthenticationError extends SnackBaseError {
  constructor(message: string = "Authentication failed", details?: any)
}

try {
  await client.auth.loginWithPassword({
    email: "[email protected]",
    password: "wrong-password",
  });
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.error("Authentication failed");
  }
}

class AuthorizationError extends SnackBaseError {
  constructor(message: string = "Not authorized", details?: any)
}

try {
  await client.records.delete("posts", "post-id");
} catch (error) {
  if (error instanceof AuthorizationError) {
    console.error("Permission denied");
  }
}

class NotFoundError extends SnackBaseError {
  constructor(message: string = "Resource not found", details?: any)
}

try {
  const post = await client.records.get("posts", "invalid-id");
} catch (error) {
  if (error instanceof NotFoundError) {
    console.error("Post not found");
  }
}

class ConflictError extends SnackBaseError {
  constructor(message: string = "Resource conflict", details?: any)
}

try {
  await client.users.create({
    email: "[email protected]",
    password: "password",
  });
} catch (error) {
  if (error instanceof ConflictError) {
    console.error("User already exists");
  }
}

class ValidationError extends SnackBaseError {
  public readonly fields?: Record<string, string[]>;

  constructor(message: string = "Validation failed", details?: any)
}

try {
  await client.records.create("posts", {
    title: "",  // Required field
  });
} catch (error) {
  if (error instanceof ValidationError) {
    console.error("Validation errors:", error.fields);
    // { title: ["This field is required"] }
  }
}

class RateLimitError extends SnackBaseError {
  public readonly retryAfter?: number;

  constructor(
    message: string = "Rate limit exceeded",
    details?: any,
    retryAfter?: number
  )
}

try {
  await client.records.list("posts");
} catch (error) {
  if (error instanceof RateLimitError) {
    console.error("Rate limited. Wait", error.retryAfter, "seconds");
  }
}

class NetworkError extends SnackBaseError {
  constructor(message: string = "Network error", details?: any)
}

try {
  await client.records.list("posts");
} catch (error) {
  if (error instanceof NetworkError) {
    console.error("Network error - check connection");
  }
}

class TimeoutError extends SnackBaseError {
  constructor(message: string = "Request timed out", details?: any)
}

try {
  await client.records.list("posts");
} catch (error) {
  if (error instanceof TimeoutError) {
    console.error("Request timed out");
  }
}

class ServerError extends SnackBaseError {
  constructor(
    message: string = "Internal server error",
    status: number = 500,
    details?: any
  )
}

try {
  await client.records.list("posts");
} catch (error) {
  if (error instanceof ServerError) {
    console.error("Server error:", error.status);
  }
}

function isAuthError(error: unknown): error is AuthenticationError {
  return error instanceof AuthenticationError;
}

function isValidationError(error: unknown): error is ValidationError {
  return error instanceof ValidationError;
}

function isRetryableError(error: unknown): error is SnackBaseError & { retryable: true } {
  return error instanceof SnackBaseError && error.retryable;
}

// Usage
try {
  await client.records.create("posts", data);
} catch (error) {
  if (isAuthError(error)) {
    // Handle auth error
  } else if (isValidationError(error)) {
    // Handle validation error
  } else if (isRetryableError(error)) {
    // Retry request
  }
}

function logError(error: unknown) {
  if (error instanceof SnackBaseError) {
    console.error({
      type: error.name,
      code: error.code,
      message: error.message,
      status: error.status,
      details: error.details,
      field: error.field,
      retryable: error.retryable,
    });
  } else {
    console.error("Unknown error:", error);
  }
}