Error Handling

interface ApiError {
  _tag: string           // Unique error type identifier
  message: string        // Human-readable error message
  detail?: string        // Additional context (optional)
  [key: string]: any     // Error-specific fields
}

Effect.catchTags({
  UnauthorizedError: (error) => handleUnauthorized(error),
  MessageNotFoundError: (error) => handleNotFound(error),
  InternalServerError: (error) => handleServerError(error)
})

{
  _tag: "UnauthorizedError",
  message: "Permission denied",
  detail: "You don't have access to this resource"
}

Effect.catchTag("UnauthorizedError", (error) =>
  Effect.gen(function* () {
    // Show permission denied message
    yield* showErrorToast("You don't have permission for this action")
    // Optionally redirect
    yield* Effect.sync(() => router.push("/channels"))
  })
)

{
  _tag: "SessionNotProvidedError",
  message: "No session cookie or Authorization header",
  detail: "Authentication required"
}

Effect.catchTag("SessionNotProvidedError", () =>
  // Redirect to login
  Effect.sync(() => window.location.href = "/auth/login")
)

{
  _tag: "SessionExpiredError",
  message: "Session has expired",
  detail: "Please re-authenticate"
}

Effect.catchTag("SessionExpiredError", () =>
  Effect.gen(function* () {
    // Attempt session refresh
    const refreshed = yield* refreshSession()
    if (refreshed) {
      // Retry original request
      return yield* originalRequest
    } else {
      // Redirect to login
      yield* Effect.sync(() => window.location.href = "/auth/login")
    }
  })
)

{
  _tag: "InvalidBearerTokenError",
  message: "JWT verification failed",
  detail: "Invalid signature or expired token"
}

{
  _tag: "InvalidJwtPayloadError",
  message: "Token missing user ID",
  detail: "The provided token is missing the user ID"
}

{
  _tag: "SessionAuthenticationError",
  message: "Authentication failed",
  detail: "Unable to verify session"
}

{
  _tag: "MessageNotFoundError",
  messageId: "msg_123" // The ID that wasn't found
}

Effect.catchTag("MessageNotFoundError", (error) =>
  Effect.gen(function* () {
    yield* showErrorToast(`Message ${error.messageId} not found`)
    // Optionally refresh message list
    yield* refreshMessages()
  })
)

{
  _tag: "ChannelNotFoundError",
  channelId: "ch_456" // The ID that wasn't found
}

{
  _tag: "ThreadChannelNotFoundError",
  message: string,
  channelId: string
}

{
  _tag: "OriginalMessageNotFoundError",
  message: string,
  threadId: string
}

{
  _tag: "NestedThreadError",
  channelId: "ch_thread_123" // The thread channel ID
}

Effect.catchTag("NestedThreadError", () =>
  showErrorToast("Cannot create threads within threads")
)

{
  _tag: "DmChannelAlreadyExistsError",
  message: "DM channel already exists",
  detail?: string // Optional additional info
}

Effect.catchTag("DmChannelAlreadyExistsError", () =>
  Effect.gen(function* () {
    // Find existing DM and navigate to it
    const existingDm = yield* findExistingDm(userId)
    yield* navigateToChannel(existingDm.id)
  })
)

{
  _tag: "OAuthCodeExpiredError",
  message: "Authorization code expired"
}

{
  _tag: "RateLimitExceededError",
  message: "Rate limit exceeded",
  retryAfterMs: 5000,     // Wait before retry (milliseconds)
  limit: 60,              // Total limit
  remaining: 0            // Requests remaining
}

Effect.catchTag("RateLimitExceededError", (error) =>
  Effect.gen(function* () {
    // Show user-friendly message
    yield* showErrorToast(
      `Too many requests. Please wait ${error.retryAfterMs / 1000}s`
    )
    
    // Wait and retry
    yield* Effect.sleep(error.retryAfterMs)
    return yield* Effect.retry(originalRequest, {
      schedule: "exponential",
      times: 3
    })
  })
)

{
  _tag: "InternalServerError",
  message: string,        // High-level error description
  detail?: string,        // Additional context
  cause?: any            // Underlying cause (if available)
}

Effect.catchTag("InternalServerError", (error) =>
  Effect.gen(function* () {
    // Log for debugging
    console.error("Server error:", error)
    
    // Show user-friendly message
    yield* showErrorToast("Something went wrong. Please try again.")
    
    // Report to error tracking (Sentry, etc.)
    yield* reportError(error)
  })
)

{
  _tag: "WorkflowInitializationError",
  message: string,
  cause?: any
}

{
  _tag: "SessionLoadError",
  message: "Failed to load session",
  detail: "Database connection error"
}

Effect.catchTag("SessionLoadError", () =>
  Effect.retry(originalRequest, {
    schedule: "exponential",
    times: 3,
    delay: "1 second"
  })
)

{
  _tag: "WorkflowServiceUnavailableError",
  message: "Workflow service unavailable",
  cause?: string | null
}

Effect.catchTag("WorkflowServiceUnavailableError", () =>
  Effect.gen(function* () {
    yield* showErrorToast("AI service temporarily unavailable")
    // Fallback: Allow manual naming
    yield* promptForManualName()
  })
)

{
  _tag: "WorkOSUserFetchError",
  message: "Failed to fetch user from WorkOS",
  detail: string
}

{
  _tag: "AIProviderUnavailableError",
  message: string,
  provider?: string  // e.g., "openai"
}

{
  _tag: "AIRateLimitError",
  message: string,
  retryAfter?: number
}

{
  _tag: "AIResponseParseError",
  message: string,
  response?: string
}

{
  _tag: "ThreadContextQueryError",
  message: string,
  cause?: any
}

{
  _tag: "ThreadNameUpdateError",
  message: string,
  cause?: any
}

const result = yield* client["message.create"](payload).pipe(
  Effect.catchTags({
    UnauthorizedError: handleUnauthorized,
    MessageNotFoundError: handleNotFound,
    RateLimitExceededError: handleRateLimit,
    InternalServerError: handleServerError
  })
)

const result = yield* client["message.create"](payload).pipe(
  Effect.retry({
    schedule: "exponential",
    times: 3,
    delay: "1 second"
  }),
  Effect.catchTag("RateLimitExceededError", (error) =>
    Effect.sleep(error.retryAfterMs).pipe(
      Effect.andThen(Effect.retry(operation, { times: 1 }))
    )
  )
)

const result = yield* client["channel.generateName"]({
  channelId: "thread-id"
}).pipe(
  Effect.catchTags({
    WorkflowServiceUnavailableError: () => 
      // Fallback: Use default thread name
      Effect.succeed({ success: false }),
    AIProviderUnavailableError: () =>
      // Fallback: Generate simple name
      Effect.succeed({ success: false })
  })
)

if (!result.success) {
  // Use fallback thread name
  yield* setThreadName(channelId, "New Thread")
}

const uploadResult = yield* client["attachment.create"](file).pipe(
  Effect.catchTag("InternalServerError", () =>
    Effect.gen(function* () {
      // Degrade: Send message without attachment
      yield* showWarning("Failed to upload attachment")
      return yield* client["message.create"]({
        ...payload,
        attachmentIds: [] // Send without attachment
      })
    })
  )
)

import * as Sentry from "@sentry/browser"

const reportError = (error: ApiError) =>
  Effect.sync(() => {
    Sentry.captureException(error, {
      tags: {
        errorType: error._tag,
        errorMessage: error.message
      },
      extra: {
        detail: error.detail,
        ...error // Include all error fields
      }
    })
  })

// Use in error handling
Effect.catchTag("InternalServerError", (error) =>
  Effect.gen(function* () {
    yield* reportError(error)
    yield* showErrorToast("Something went wrong")
  })
)

Effect.catchTags({
  // Specific errors first
  RateLimitExceededError: handleRateLimit,
  MessageNotFoundError: handleNotFound,
  
  // Generic fallback last
  InternalServerError: handleGenericError
})

const friendlyMessages = {
  UnauthorizedError: "You don't have permission for this action",
  MessageNotFoundError: "This message no longer exists",
  RateLimitExceededError: "You're doing that too quickly",
  InternalServerError: "Something went wrong. Please try again."
}

Effect.catchTag("InternalServerError", (error) =>
  Effect.gen(function* () {
    // Log full error details
    console.error("API Error:", {
      tag: error._tag,
      message: error.message,
      detail: error.detail,
      cause: error.cause
    })
    
    // Show simple message to user
    yield* showErrorToast("Something went wrong")
  })
)

const withRetry = <A, E>(effect: Effect.Effect<A, E>) =>
  effect.pipe(
    Effect.retry({
      schedule: "exponential",
      times: 3,
      delay: "1 second"
    }),
    Effect.catchAll((error) =>
      Effect.gen(function* () {
        yield* reportError(error)
        return yield* Effect.fail(error)
      })
    )
  )