Something went wrong. Try again.
Bluesky app fork with some witchin' additions 💫
Something went wrong. Try again.
3.9 kB · 111 lines
TypeScript
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112import { getMain, type InferMethodError, LexError, type Main, type Procedure, type Query, XrpcError, XrpcResponseError,} from '@atproto/lex'
import {com} from '#/lexicons'
/** * True for an XRPC error from a lex `Client` (`XrpcError` is the abstract base * of `XrpcResponseError`/`XrpcInvalidResponseError`/`XrpcInternalError`). */export function isXrpcError(e: unknown): e is XrpcError { return e instanceof XrpcError}
/** * HTTP status, or undefined when `e` is not an XRPC error carrying a response. * Only `XrpcResponseError` (a genuine server response) has a status; the * internal/fetch lex errors do not. */export function getErrorStatus(e: unknown): number | undefined { return e instanceof XrpcResponseError ? e.status : undefined}
/** * The lexicon error code (`err.error`), or undefined when `e` carries none. * Gated on `LexError` (the base of every `XrpcError`) rather than `XrpcError`, * so the non-XRPC lex errors are covered too. * * Prefer {@link matchXrpcError} where the method that threw is known: it * constrains the compared name to that method's declared errors. Use this only * where the source method is genuinely ambiguous. */export function getErrorName(e: unknown): string | undefined { return e instanceof LexError ? e.error : undefined}
/** * Same nsid means `e` was thrown for this method schema, so `e` can be * treated as an `XrpcResponseError<M>` - which is what lets the SDK's * `matchesSchemaErrors()` narrow `e.error` to M's declared errors. */function isThrownFor<M extends Procedure | Query>( e: XrpcResponseError, schema: M,): e is XrpcResponseError<M> { return e.method.nsid === schema.nsid}
/** * The lexicon error code carried by `e`, narrowed to the errors DECLARED by * `method`, or `undefined` when `e` is not such an error. * * `XrpcResponseError.error` is the open `LexErrorCode` union, so comparing it * as a plain string lets a typo silently never match. Narrowing the return type * to `InferMethodError<M>` makes a `switch` over the result reject an * undeclared or misspelled `case` at compile time: * * ```ts * switch (matchXrpcError(e, com.atproto.server.createAccount)) { * case 'InvalidHandle': * ... * } * ``` * * Matching is scoped to `method`: `XrpcError` records the method schema it was * thrown for, so a declared code arriving from a DIFFERENT call does not match. * Undeclared codes, non-XRPC errors, and the internal/fetch lex errors (which * carry no server error code) all return `undefined`. * * `method` accepts the same value passed to `client.call` - either the * generated method namespace (`com.atproto.server.createAccount`) or its * `.main` schema - via lex's `Main<M>`. */export function matchXrpcError<M extends Procedure | Query>( e: unknown, method: Main<M>,): InferMethodError<M> | undefined { if (!(e instanceof XrpcResponseError)) { return undefined } const schema = getMain(method) if (isThrownFor(e, schema) && e.matchesSchemaErrors()) { return e.error } return undefined}
/** * Whether `e` is a `com.atproto.repo.getRecord` failure meaning the record is * absent, so the caller can treat the read as "no record" instead of an error. * * `getRecord` declares `RecordNotFound` and both the PDS and the appview throw * it by that name, so the declared code is the primary check. The message * substring is kept as a fallback because that is what the pre-SDK call sites * matched on, and an older PDS in the network may still answer with an * unnamed error whose message carries the text. Dropping it would silently * turn a previously-handled absence into a thrown error. */export function isRecordNotFoundError(e: unknown): boolean { if (matchXrpcError(e, com.atproto.repo.getRecord) === 'RecordNotFound') { return true } return e instanceof Error && e.message.includes('Could not locate record:')}