@atproto/lex-client 0.0.5 → 0.0.6

package/src/lexicons/com/atproto/repo/putRecord.defs.ts

@@ -14,36 +14,30 @@ const main =
   /*#__PURE__*/
   l.procedure(
     $nsid,
-    /*#__PURE__*/ l.params({}),
-    /*#__PURE__*/ l.payload(
-      'application/json',
-      /*#__PURE__*/ l.object({
-        repo: /*#__PURE__*/ l.string({ format: 'at-identifier' }),
-        collection: /*#__PURE__*/ l.string({ format: 'nsid' }),
-        rkey: /*#__PURE__*/ l.string({ format: 'record-key', maxLength: 512 }),
-        validate: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.boolean()),
-        record: /*#__PURE__*/ l.unknownObject(),
-        swapRecord: /*#__PURE__*/ l.optional(
-          /*#__PURE__*/ l.nullable(/*#__PURE__*/ l.string({ format: 'cid' })),
+    /*#__PURE__*/ l.params(),
+    /*#__PURE__*/ l.jsonPayload({
+      repo: /*#__PURE__*/ l.string({ format: 'at-identifier' }),
+      collection: /*#__PURE__*/ l.string({ format: 'nsid' }),
+      rkey: /*#__PURE__*/ l.string({ format: 'record-key', maxLength: 512 }),
+      validate: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.boolean()),
+      record: /*#__PURE__*/ l.unknownObject(),
+      swapRecord: /*#__PURE__*/ l.optional(
+        /*#__PURE__*/ l.nullable(/*#__PURE__*/ l.string({ format: 'cid' })),
+      ),
+      swapCommit: /*#__PURE__*/ l.optional(
+        /*#__PURE__*/ l.string({ format: 'cid' }),
+      ),
+    }),
+    /*#__PURE__*/ l.jsonPayload({
+      uri: /*#__PURE__*/ l.string({ format: 'at-uri' }),
+      cid: /*#__PURE__*/ l.string({ format: 'cid' }),
+      commit: /*#__PURE__*/ l.optional(
+        /*#__PURE__*/ l.ref<RepoDefs.CommitMeta>(
+          (() => RepoDefs.commitMeta) as any,
         ),
-        swapCommit: /*#__PURE__*/ l.optional(
-          /*#__PURE__*/ l.string({ format: 'cid' }),
-        ),
-      }),
-    ),
-    /*#__PURE__*/ l.payload(
-      'application/json',
-      /*#__PURE__*/ l.object({
-        uri: /*#__PURE__*/ l.string({ format: 'at-uri' }),
-        cid: /*#__PURE__*/ l.string({ format: 'cid' }),
-        commit: /*#__PURE__*/ l.optional(
-          /*#__PURE__*/ l.ref<RepoDefs.CommitMeta>(
-            (() => RepoDefs.commitMeta) as any,
-          ),
-        ),
-        validationStatus: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.string()),
-      }),
-    ),
+      ),
+      validationStatus: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.string()),
+    }),
     ['InvalidSwap'],
   )
 export { main }

package/src/lexicons/com/atproto/repo/uploadBlob.defs.ts

@@ -13,14 +13,11 @@ const main =
   /*#__PURE__*/
   l.procedure(
     $nsid,
-    /*#__PURE__*/ l.params({}),
+    /*#__PURE__*/ l.params(),
     /*#__PURE__*/ l.payload('*/*'),
-    /*#__PURE__*/ l.payload(
-      'application/json',
-      /*#__PURE__*/ l.object({
-        blob: /*#__PURE__*/ l.blob({ allowLegacy: false }),
-      }),
-    ),
+    /*#__PURE__*/ l.jsonPayload({
+      blob: /*#__PURE__*/ l.blob({ allowLegacy: false }),
+    }),
   )
 export { main }
 

package/src/{xrpc-response.ts → response.ts}

@@ -6,28 +6,28 @@ import {
   Query,
   ResultSuccess,
 } from '@atproto/lex-schema'
-import { Payload } from './util.js'
 import {
-  XrpcInvalidResponseError,
-  XrpcResponseError,
-  isXrpcErrorPayload,
-} from './xrpc-error.js'
+  LexRpcResponseError,
+  LexRpcUpstreamError,
+  isLexRpcErrorPayload,
+} from './errors.js'
+import { Payload } from './util.js'
 
-export type XrpcResponseBody<M extends Procedure | Query> =
+export type LexRpcResponseBody<M extends Procedure | Query> =
   InferMethodOutputBody<M, Uint8Array>
 
-export type XrpcResponsePayload<M extends Procedure | Query> =
+export type LexRpcResponsePayload<M extends Procedure | Query> =
   InferMethodOutputEncoding<M> extends infer E extends string
-    ? Payload<XrpcResponseBody<M>, E>
+    ? Payload<LexRpcResponseBody<M>, E>
     : null
 
 /**
  * Small container for XRPC response data.
  *
- * @implements {ResultSuccess<XrpcResponse<M>>} for convenience in result handling contexts.
+ * @implements {ResultSuccess<LexRpcResponse<M>>} for convenience in result handling contexts.
  */
-export class XrpcResponse<const M extends Procedure | Query>
-  implements ResultSuccess<XrpcResponse<M>>
+export class LexRpcResponse<const M extends Procedure | Query>
+  implements ResultSuccess<LexRpcResponse<M>>
 {
   /** @see {@link ResultSuccess.success} */
   readonly success = true as const
@@ -41,7 +41,7 @@ export class XrpcResponse<const M extends Procedure | Query>
     readonly method: M,
     readonly status: number,
     readonly headers: Headers,
-    readonly payload: XrpcResponsePayload<M>,
+    readonly payload: LexRpcResponsePayload<M>,
   ) {}
 
   /**
@@ -57,18 +57,21 @@ export class XrpcResponse<const M extends Procedure | Query>
   }
 
   get body() {
-    return this.payload?.body as XrpcResponseBody<M>
+    return this.payload?.body as LexRpcResponseBody<M>
   }
 
   /**
-   * @throws {XrpcInvalidResponseError} when the response is invalid according
-   * to the method schema.
+   * @throws {LexRpcResponseError} in case of (valid) XRPC error responses. Use
+   * {@link LexRpcResponseError.matchesSchema} to narrow the error type based on
+   * the method's declared error schema.
+   * @throws {LexRpcUpstreamError} when the response is not a valid XRPC
+   * response, or if the response does not conform to the method's schema.
    */
   static async fromFetchResponse<const M extends Procedure | Query>(
     method: M,
     response: Response,
     options?: { validateResponse?: boolean },
-  ): Promise<XrpcResponse<M>> {
+  ): Promise<LexRpcResponse<M>> {
     // @NOTE The body MUST either be read or canceled to avoid resource leaks.
     // Since nothing should cause an exception before "readPayload" is
     // called, we can safely not use a try/finally here.
@@ -78,8 +81,8 @@ export class XrpcResponse<const M extends Procedure | Query>
       // Always parse json for error responses
       const payload = await readPayload(response, { parse: true })
 
-      if (response.status >= 400 && isXrpcErrorPayload(payload)) {
-        throw new XrpcResponseError(
+      if (response.status >= 400 && isLexRpcErrorPayload(payload)) {
+        throw new LexRpcResponseError(
           method,
           response.status,
           response.headers,
@@ -87,12 +90,20 @@ export class XrpcResponse<const M extends Procedure | Query>
         )
       }
 
-      throw new XrpcInvalidResponseError(
-        response.status >= 500
-          ? `Upstream server encountered an error`
-          : response.status >= 400
-            ? `Upstream server returned an invalid response payload`
-            : `Upstream server returned an invalid status code`,
+      if (response.status >= 500) {
+        throw new LexRpcUpstreamError(
+          'UpstreamFailure',
+          `Upstream server encountered an error`,
+          response,
+          payload,
+        )
+      }
+
+      throw new LexRpcUpstreamError(
+        'InvalidResponse',
+        response.status >= 400
+          ? `Upstream server returned an invalid response payload`
+          : `Upstream server returned an invalid status code`,
         response,
         payload,
       )
@@ -107,7 +118,8 @@ export class XrpcResponse<const M extends Procedure | Query>
     if (method.output.encoding == null) {
       // Schema expects no payload
       if (payload) {
-        throw new XrpcInvalidResponseError(
+        throw new LexRpcUpstreamError(
+          'InvalidResponse',
           `Expected response with no body, got ${payload.encoding}`,
           response,
           payload,
@@ -116,7 +128,8 @@ export class XrpcResponse<const M extends Procedure | Query>
     } else {
       // Schema expects a payload
       if (!payload || !method.output.matchesEncoding(payload.encoding)) {
-        throw new XrpcInvalidResponseError(
+        throw new LexRpcUpstreamError(
+          'InvalidResponse',
           payload
             ? `Expected ${method.output.encoding} response, got ${payload.encoding}`
             : `Expected non-empty response with content-type ${method.output.encoding}`,
@@ -132,7 +145,8 @@ export class XrpcResponse<const M extends Procedure | Query>
         })
 
         if (!result.success) {
-          throw new XrpcInvalidResponseError(
+          throw new LexRpcUpstreamError(
+            'InvalidResponse',
             `Response validation failed: ${result.reason.message}`,
             response,
             payload,
@@ -142,11 +156,11 @@ export class XrpcResponse<const M extends Procedure | Query>
       }
     }
 
-    return new XrpcResponse<M>(
+    return new LexRpcResponse<M>(
       method,
       response.status,
       response.headers,
-      payload as XrpcResponsePayload<M>,
+      payload as LexRpcResponsePayload<M>,
     )
   }
 }
@@ -200,7 +214,8 @@ async function readPayload(
       // @TODO verify statement above
       return { encoding, body: lexParse(text) }
     } catch (cause) {
-      throw new XrpcInvalidResponseError(
+      throw new LexRpcUpstreamError(
+        'InvalidResponse',
         'Invalid JSON response body',
         response,
         null,

package/src/types.ts

@@ -40,9 +40,3 @@ export type BinaryBodyInit =
   | ReadableStream<Uint8Array>
   | AsyncIterable<Uint8Array>
   | string
-
-export type Namespace<T> = T | { main: T }
-
-export function getMain<T extends object>(ns: Namespace<T>): T {
-  return 'main' in ns ? ns.main : ns
-}

package/src/xrpc.ts

@@ -3,6 +3,7 @@ import { lexStringify } from '@atproto/lex-json'
 import {
   InferMethodInput,
   InferMethodParams,
+  Main,
   Params,
   ParamsSchema,
   Payload as LexPayload,
@@ -10,9 +11,16 @@ import {
   Query,
   Restricted,
   Subscription,
+  getMain,
 } from '@atproto/lex-schema'
 import { Agent } from './agent.js'
-import { BinaryBodyInit, CallOptions, Namespace, getMain } from './types.js'
+import {
+  LexRpcResponseError,
+  LexRpcUnexpectedError,
+  LexRpcUpstreamError,
+} from './errors.js'
+import { LexRpcResponse } from './response.js'
+import { BinaryBodyInit, CallOptions } from './types.js'
 import {
   Payload,
   buildAtprotoHeaders,
@@ -20,117 +28,108 @@ import {
   isBlobLike,
   toReadableStream,
 } from './util.js'
-import {
-  XrpcInvalidResponseError,
-  XrpcResponseError,
-  XrpcUnexpectedError,
-} from './xrpc-error.js'
-import { XrpcResponse } from './xrpc-response.js'
-
-export * from './xrpc-error.js'
-export * from './xrpc-response.js'
 
 // If all params are optional, allow omitting the params object
-type XrpcParamsOptions<P extends Params> =
+type LexRpcParamsOptions<P extends Params> =
   NonNullable<unknown> extends P ? { params?: P } : { params: P }
 
-type XrpcRequestPayload<M extends Procedure | Query> = InferMethodInput<
+type LexRpcRequestPayload<M extends Procedure | Query> = InferMethodInput<
   M,
   BinaryBodyInit
 >
 
-type XrpcInputOptions<In> = In extends { body: infer B; encoding: infer E }
+type LexRpcInputOptions<In> = In extends { body: infer B; encoding: infer E }
   ? // encoding will be inferred from the schema at runtime if not provided
     { body: B; encoding?: E }
   : { body?: undefined; encoding?: undefined }
 
-export type XrpcOptions<M extends Procedure | Query = Procedure | Query> =
+export type LexRpcOptions<M extends Procedure | Query = Procedure | Query> =
   CallOptions &
-    XrpcInputOptions<XrpcRequestPayload<M>> &
-    XrpcParamsOptions<InferMethodParams<M>>
+    LexRpcInputOptions<LexRpcRequestPayload<M>> &
+    LexRpcParamsOptions<InferMethodParams<M>>
 
-export type XrpcFailure<M extends Procedure | Query> =
+export type LexRpcFailure<M extends Procedure | Query> =
   // The server returned a valid XRPC error response
-  | XrpcResponseError<M>
+  | LexRpcResponseError<M>
   // The response was not a valid XRPC response, or it does not match the schema
-  | XrpcInvalidResponseError
+  | LexRpcUpstreamError
   // Something went wrong (network error, etc.)
-  | XrpcUnexpectedError
+  | LexRpcUnexpectedError
 
-export type XrpcResult<M extends Procedure | Query> =
-  | XrpcResponse<M>
-  | XrpcFailure<M>
+export type LexRpcResult<M extends Procedure | Query> =
+  | LexRpcResponse<M>
+  | LexRpcFailure<M>
 
 /**
  * Utility method to type cast the error thrown by {@link xrpc} to an
- * {@link XrpcFailure} matching the provided method. Only use this function
+ * {@link LexRpcFailure} matching the provided method. Only use this function
  * inside a catch block right after calling {@link xrpc}, and use the same
  * method type parameter as used in the {@link xrpc} call.
  */
-function asXrpcFailure<M extends Procedure | Query>(
-  err: unknown,
-): XrpcFailure<M> {
-  if (err instanceof XrpcResponseError) return err
-  if (err instanceof XrpcInvalidResponseError) return err
-  return XrpcUnexpectedError.from(err)
+export function asLexRpcFailure<
+  M extends Procedure | Query = Procedure | Query,
+>(err: unknown): LexRpcFailure<M> {
+  if (err instanceof LexRpcResponseError) return err
+  if (err instanceof LexRpcUpstreamError) return err
+  return LexRpcUnexpectedError.from(err)
 }
 
 /**
- * @throws XrpcFailure<M>
+ * @throws LexRpcFailure<M>
  */
 export async function xrpc<const M extends Query | Procedure>(
   agent: Agent,
-  ns: NonNullable<unknown> extends XrpcOptions<M>
-    ? Namespace<M>
+  ns: NonNullable<unknown> extends LexRpcOptions<M>
+    ? Main<M>
     : Restricted<'This XRPC method requires an "options" argument'>,
-): Promise<XrpcResponse<M>>
+): Promise<LexRpcResponse<M>>
 export async function xrpc<const M extends Query | Procedure>(
   agent: Agent,
-  ns: Namespace<M>,
-  options: XrpcOptions<M>,
-): Promise<XrpcResponse<M>>
+  ns: Main<M>,
+  options: LexRpcOptions<M>,
+): Promise<LexRpcResponse<M>>
 export async function xrpc<const M extends Query | Procedure>(
   agent: Agent,
-  ns: Namespace<M>,
-  options: XrpcOptions<M> = {} as XrpcOptions<M>,
-): Promise<XrpcResponse<M>> {
+  ns: Main<M>,
+  options: LexRpcOptions<M> = {} as LexRpcOptions<M>,
+): Promise<LexRpcResponse<M>> {
   try {
-    return await xrpcRequest<M>(agent, ns, options)
+    return await lexRpcRequest<M>(agent, ns, options)
   } catch (err) {
-    throw asXrpcFailure<M>(err)
+    throw asLexRpcFailure<M>(err)
   }
 }
 
 export async function xrpcSafe<const M extends Query | Procedure>(
   agent: Agent,
-  ns: NonNullable<unknown> extends XrpcOptions<M>
-    ? Namespace<M>
+  ns: NonNullable<unknown> extends LexRpcOptions<M>
+    ? Main<M>
     : Restricted<'This XRPC method requires an "options" argument'>,
-): Promise<XrpcResult<M>>
+): Promise<LexRpcResult<M>>
 export async function xrpcSafe<const M extends Query | Procedure>(
   agent: Agent,
-  ns: Namespace<M>,
-  options: XrpcOptions<M>,
-): Promise<XrpcResult<M>>
+  ns: Main<M>,
+  options: LexRpcOptions<M>,
+): Promise<LexRpcResult<M>>
 export async function xrpcSafe<const M extends Query | Procedure>(
   agent: Agent,
-  ns: Namespace<M>,
-  options: XrpcOptions<M> = {} as XrpcOptions<M>,
-): Promise<XrpcResult<M>> {
-  return xrpcRequest<M>(agent, ns, options).catch(asXrpcFailure<M>)
+  ns: Main<M>,
+  options: LexRpcOptions<M> = {} as LexRpcOptions<M>,
+): Promise<LexRpcResult<M>> {
+  return lexRpcRequest<M>(agent, ns, options).catch(asLexRpcFailure<M>)
 }
 
-async function xrpcRequest<const M extends Query | Procedure>(
+async function lexRpcRequest<const M extends Query | Procedure>(
   agent: Agent,
-  ns: Namespace<M>,
-  options: XrpcOptions<M> = {} as XrpcOptions<M>,
-): Promise<XrpcResponse<M>> {
+  ns: Main<M>,
+  options: LexRpcOptions<M> = {} as LexRpcOptions<M>,
+): Promise<LexRpcResponse<M>> {
   const method = getMain(ns)
   options.signal?.throwIfAborted()
   const url = xrpcRequestUrl(method, options)
   const request = xrpcRequestInit(method, options)
   const response = await agent.fetchHandler(url, request)
-  return XrpcResponse.fromFetchResponse<M>(method, response, options)
+  return LexRpcResponse.fromFetchResponse<M>(method, response, options)
 }
 
 function xrpcRequestUrl<M extends Procedure | Query | Subscription>(

package/tsconfig.tests.json

@@ -1,12 +1,9 @@
 {
-  "extends": "../../../tsconfig/tests.json",
-  "include": ["./tests"],
+  "extends": "../../../tsconfig/vitest.json",
+  "include": ["./tests", "./src/**/*.test.ts"],
   "compilerOptions": {
     "noImplicitAny": true,
-    "rootDir": "./tests",
-    "baseUrl": "./tests",
-    "paths": {
-      "@atproto/lex-client": ["./dist/index.js"]
-    }
+    "rootDir": "./",
+    "baseUrl": "./"
   }
 }

package/dist/xrpc-error.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"xrpc-error.d.ts","sourceRoot":"","sources":["../src/xrpc-error.ts"],"names":[],"mappings":"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"}

package/dist/xrpc-error.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"xrpc-error.js","sourceRoot":"","sources":["../src/xrpc-error.ts"],"names":[],"mappings":"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","sourcesContent":["import { l } from '@atproto/lex-schema'\nimport { Payload } from './util.js'\n\nexport type XrpcErrorCode = string\nexport const xrpcErrorCodeSchema: l.Schema<XrpcErrorCode> = l.string({\n  minLength: 1,\n})\n\nexport class XrpcError<N extends XrpcErrorCode = XrpcErrorCode> extends Error {\n  name = 'XrpcError'\n\n  constructor(\n    readonly error: N,\n    message: string = `An ${error} XRPC error occurred.`,\n    options?: ErrorOptions,\n  ) {\n    super(message, options)\n  }\n}\n\nexport type XrpcErrorBody<N extends XrpcErrorCode = XrpcErrorCode> = {\n  error: N\n  message?: string\n}\nexport type XrpcErrorPayload<N extends XrpcErrorCode = XrpcErrorCode> = {\n  encoding: 'application/json'\n  body: XrpcErrorBody<N>\n}\n\nconst xrpcErrorBodySchema: l.Schema<XrpcErrorBody> = l.object({\n  error: xrpcErrorCodeSchema,\n  message: l.optional(l.string()),\n})\n\n/**\n * All unsuccessful responses should follow a standard error response\n * schema. The Content-Type should be application/json, and the payload\n * should be a JSON object with the following fields:\n *\n * - `error` (string, required): type name of the error (generic ASCII\n *   constant, no whitespace)\n * - `message` (string, optional): description of the error, appropriate for\n *   display to humans\n *\n * This function checks whether a given payload matches this schema.\n */\nexport function isXrpcErrorPayload(\n  payload: Payload | null,\n): payload is XrpcErrorPayload {\n  return (\n    payload !== null &&\n    payload.encoding === 'application/json' &&\n    xrpcErrorBodySchema.matches(payload.body)\n  )\n}\n\n/**\n * Interface representing a failed XRPC request result.\n */\ntype XrpcFailureResult<N extends XrpcErrorCode, E> = l.ResultFailure<E> & {\n  readonly error: N\n  shouldRetry(): boolean\n  matchesSchema(): boolean\n}\n\n/**\n * Class used to represent an HTTP request that resulted in an XRPC method error\n * That is, a non-2xx response with a valid XRPC error payload.\n */\nexport class XrpcResponseError<\n    M extends l.Procedure | l.Query = l.Procedure | l.Query,\n    N extends XrpcErrorCode = XrpcErrorCode,\n  >\n  extends XrpcError<N>\n  implements XrpcFailureResult<N, XrpcResponseError<M, N>>\n{\n  name = 'XrpcResponseError' as const\n\n  constructor(\n    readonly method: M,\n    readonly status: number,\n    readonly headers: Headers,\n    readonly payload: XrpcErrorPayload<N>,\n    options?: ErrorOptions,\n  ) {\n    const { error, message } = payload.body\n    super(error, message, options)\n  }\n\n  readonly success = false\n\n  get reason(): this {\n    return this as this\n  }\n\n  get body(): XrpcErrorBody {\n    return this.payload.body\n  }\n\n  matchesSchema(): this is M extends {\n    errors: readonly (infer E extends string)[]\n  }\n    ? XrpcResponseError<M, E>\n    : never {\n    return this.method.errors?.includes(this.error) ?? false\n  }\n\n  shouldRetry(): boolean {\n    // Do not retry client errors\n    if (this.status < 500) return false\n\n    return true\n  }\n}\n\n/**\n * This class represents an invalid XRPC response from the server.\n */\nexport class XrpcInvalidResponseError\n  extends XrpcError<'UpstreamFailure'>\n  implements XrpcFailureResult<'UpstreamFailure', XrpcInvalidResponseError>\n{\n  name = 'XrpcInvalidResponseError' as const\n\n  // For debugging purposes, we keep the response details here\n  readonly response: {\n    status: number\n    headers: Headers\n    payload: Payload | null\n  }\n\n  constructor(\n    message: string,\n    response: { status: number; headers: Headers },\n    payload: Payload | null,\n    options?: ErrorOptions,\n  ) {\n    super('UpstreamFailure', message, { cause: options?.cause })\n    this.response = {\n      status: response.status,\n      headers: response.headers,\n      payload,\n    }\n  }\n\n  readonly success = false as const\n\n  get reason(): this {\n    return this\n  }\n\n  matchesSchema(): false {\n    return false\n  }\n\n  shouldRetry(): boolean {\n    // Do not retry client errors\n    return this.response.status >= 500\n  }\n}\n\nexport class XrpcUnexpectedError\n  extends XrpcError<'InternalServerError'>\n  implements XrpcFailureResult<'InternalServerError', unknown>\n{\n  name = 'XrpcUnexpectedError' as const\n\n  protected constructor(message: string, options: Required<ErrorOptions>) {\n    super('InternalServerError', message, options)\n  }\n\n  readonly success = false\n\n  get reason() {\n    return this.cause\n  }\n\n  matchesSchema(): false {\n    return false\n  }\n\n  shouldRetry(): boolean {\n    return true\n  }\n\n  static from(\n    cause: unknown,\n    message: string = cause instanceof XrpcError\n      ? cause.message\n      : 'XRPC request failed',\n  ): XrpcUnexpectedError {\n    if (cause instanceof XrpcUnexpectedError) return cause\n    return new XrpcUnexpectedError(message, { cause })\n  }\n}\n"]}

package/dist/xrpc-response.d.ts

@@ -1,35 +0,0 @@
-import { InferMethodOutputBody, InferMethodOutputEncoding, Procedure, Query, ResultSuccess } from '@atproto/lex-schema';
-import { Payload } from './util.js';
-export type XrpcResponseBody<M extends Procedure | Query> = InferMethodOutputBody<M, Uint8Array>;
-export type XrpcResponsePayload<M extends Procedure | Query> = InferMethodOutputEncoding<M> extends infer E extends string ? Payload<XrpcResponseBody<M>, E> : null;
-/**
- * Small container for XRPC response data.
- *
- * @implements {ResultSuccess<XrpcResponse<M>>} for convenience in result handling contexts.
- */
-export declare class XrpcResponse<const M extends Procedure | Query> implements ResultSuccess<XrpcResponse<M>> {
-    readonly method: M;
-    readonly status: number;
-    readonly headers: Headers;
-    readonly payload: XrpcResponsePayload<M>;
-    /** @see {@link ResultSuccess.success} */
-    readonly success: true;
-    /** @see {@link ResultSuccess.value} */
-    get value(): this;
-    constructor(method: M, status: number, headers: Headers, payload: XrpcResponsePayload<M>);
-    /**
-     * Whether the response payload was parsed as {@link LexValue} (`true`) or is
-     * in binary form {@link Uint8Array} (`false`).
-     */
-    get isParsed(): boolean;
-    get encoding(): InferMethodOutputEncoding<M>;
-    get body(): XrpcResponseBody<M>;
-    /**
-     * @throws {XrpcInvalidResponseError} when the response is invalid according
-     * to the method schema.
-     */
-    static fromFetchResponse<const M extends Procedure | Query>(method: M, response: Response, options?: {
-        validateResponse?: boolean;
-    }): Promise<XrpcResponse<M>>;
-}
-//# sourceMappingURL=xrpc-response.d.ts.map

package/dist/xrpc-response.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"xrpc-response.d.ts","sourceRoot":"","sources":["../src/xrpc-response.ts"],"names":[],"mappings":"AACA,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,SAAS,EACT,KAAK,EACL,aAAa,EACd,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAOnC,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,SAAS,GAAG,KAAK,IACtD,qBAAqB,CAAC,CAAC,EAAE,UAAU,CAAC,CAAA;AAEtC,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,SAAS,GAAG,KAAK,IACzD,yBAAyB,CAAC,CAAC,CAAC,SAAS,MAAM,CAAC,SAAS,MAAM,GACvD,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAC/B,IAAI,CAAA;AAEV;;;;GAIG;AACH,qBAAa,YAAY,CAAC,KAAK,CAAC,CAAC,SAAS,SAAS,GAAG,KAAK,CACzD,YAAW,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAWvC,QAAQ,CAAC,MAAM,EAAE,CAAC;IAClB,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO;IACzB,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAZ1C,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAG,IAAI,CAAS;IAEhC,uCAAuC;IACvC,IAAI,KAAK,IAAI,IAAI,CAEhB;gBAGU,MAAM,EAAE,CAAC,EACT,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAG1C;;;OAGG;IACH,IAAI,QAAQ,YAEX;IAED,IAAI,QAAQ,IACuB,yBAAyB,CAAC,CAAC,CAAC,CAC9D;IAED,IAAI,IAAI,IACuB,gBAAgB,CAAC,CAAC,CAAC,CACjD;IAED;;;OAGG;WACU,iBAAiB,CAAC,KAAK,CAAC,CAAC,SAAS,SAAS,GAAG,KAAK,EAC9D,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE;QAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;KAAE,GACvC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;CAiF5B"}

package/dist/xrpc-response.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"xrpc-response.js","sourceRoot":"","sources":["../src/xrpc-response.ts"],"names":[],"mappings":"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","sourcesContent":["import { lexParse } from '@atproto/lex-json'\nimport {\n  InferMethodOutputBody,\n  InferMethodOutputEncoding,\n  Procedure,\n  Query,\n  ResultSuccess,\n} from '@atproto/lex-schema'\nimport { Payload } from './util.js'\nimport {\n  XrpcInvalidResponseError,\n  XrpcResponseError,\n  isXrpcErrorPayload,\n} from './xrpc-error.js'\n\nexport type XrpcResponseBody<M extends Procedure | Query> =\n  InferMethodOutputBody<M, Uint8Array>\n\nexport type XrpcResponsePayload<M extends Procedure | Query> =\n  InferMethodOutputEncoding<M> extends infer E extends string\n    ? Payload<XrpcResponseBody<M>, E>\n    : null\n\n/**\n * Small container for XRPC response data.\n *\n * @implements {ResultSuccess<XrpcResponse<M>>} for convenience in result handling contexts.\n */\nexport class XrpcResponse<const M extends Procedure | Query>\n  implements ResultSuccess<XrpcResponse<M>>\n{\n  /** @see {@link ResultSuccess.success} */\n  readonly success = true as const\n\n  /** @see {@link ResultSuccess.value} */\n  get value(): this {\n    return this\n  }\n\n  constructor(\n    readonly method: M,\n    readonly status: number,\n    readonly headers: Headers,\n    readonly payload: XrpcResponsePayload<M>,\n  ) {}\n\n  /**\n   * Whether the response payload was parsed as {@link LexValue} (`true`) or is\n   * in binary form {@link Uint8Array} (`false`).\n   */\n  get isParsed() {\n    return this.encoding === 'application/json' && shouldParse(this.method)\n  }\n\n  get encoding() {\n    return this.payload?.encoding as InferMethodOutputEncoding<M>\n  }\n\n  get body() {\n    return this.payload?.body as XrpcResponseBody<M>\n  }\n\n  /**\n   * @throws {XrpcInvalidResponseError} when the response is invalid according\n   * to the method schema.\n   */\n  static async fromFetchResponse<const M extends Procedure | Query>(\n    method: M,\n    response: Response,\n    options?: { validateResponse?: boolean },\n  ): Promise<XrpcResponse<M>> {\n    // @NOTE The body MUST either be read or canceled to avoid resource leaks.\n    // Since nothing should cause an exception before \"readPayload\" is\n    // called, we can safely not use a try/finally here.\n\n    // @NOTE redirect is set to 'follow', so we shouldn't get 3xx responses here\n    if (response.status < 200 || response.status >= 300) {\n      // Always parse json for error responses\n      const payload = await readPayload(response, { parse: true })\n\n      if (response.status >= 400 && isXrpcErrorPayload(payload)) {\n        throw new XrpcResponseError(\n          method,\n          response.status,\n          response.headers,\n          payload,\n        )\n      }\n\n      throw new XrpcInvalidResponseError(\n        response.status >= 500\n          ? `Upstream server encountered an error`\n          : response.status >= 400\n            ? `Upstream server returned an invalid response payload`\n            : `Upstream server returned an invalid status code`,\n        response,\n        payload,\n      )\n    }\n\n    // Only parse json if the schema expects it\n    const payload = await readPayload(response, {\n      parse: shouldParse(method),\n    })\n\n    // Response is successful (2xx). Validate payload (data and encoding) against schema.\n    if (method.output.encoding == null) {\n      // Schema expects no payload\n      if (payload) {\n        throw new XrpcInvalidResponseError(\n          `Expected response with no body, got ${payload.encoding}`,\n          response,\n          payload,\n        )\n      }\n    } else {\n      // Schema expects a payload\n      if (!payload || !method.output.matchesEncoding(payload.encoding)) {\n        throw new XrpcInvalidResponseError(\n          payload\n            ? `Expected ${method.output.encoding} response, got ${payload.encoding}`\n            : `Expected non-empty response with content-type ${method.output.encoding}`,\n          response,\n          payload,\n        )\n      }\n\n      // Assert valid response body.\n      if (method.output.schema && options?.validateResponse !== false) {\n        const result = method.output.schema.safeParse(payload.body, {\n          allowTransform: false,\n        })\n\n        if (!result.success) {\n          throw new XrpcInvalidResponseError(\n            `Response validation failed: ${result.reason.message}`,\n            response,\n            payload,\n            { cause: result.reason },\n          )\n        }\n      }\n    }\n\n    return new XrpcResponse<M>(\n      method,\n      response.status,\n      response.headers,\n      payload as XrpcResponsePayload<M>,\n    )\n  }\n}\n\nfunction shouldParse(method: Procedure | Query) {\n  return method.output.encoding === 'application/json'\n}\n\n/**\n * @note this function always consumes the response body\n */\nasync function readPayload(\n  response: Response,\n  options?: { parse?: boolean },\n): Promise<Payload | null> {\n  // @TODO Should we limit the maximum response size here (this could also be\n  // done by the FetchHandler)?\n\n  const encoding = response.headers\n    .get('content-type')\n    ?.split(';')[0]\n    .trim()\n    .toLowerCase()\n\n  // Response content-type is undefined\n  if (!encoding) {\n    // If the body is empty, return null (= no payload)\n    const body = await response.arrayBuffer()\n    if (body.byteLength === 0) return null\n\n    // If we got data despite no content-type, treat it as binary\n    return {\n      encoding: 'application/octet-stream',\n      body: new Uint8Array(body),\n    }\n  }\n\n  if (options?.parse && encoding === 'application/json') {\n    // @NOTE It might be worth returning the raw bytes here (Uint8Array) and\n    // perform the lex parsing using cborg/json, allowing to do\n    // bytes->LexValue in one step instead of bytes->text->JSON->LexValue.\n    // This would require adding encode/decode utilities to lex-json (similar\n    // to @ipld/dag-json)\n    const text = await response.text()\n\n    try {\n      // @NOTE Using `lexParse(text)` (instead of `jsonToLex(json)`) here as\n      // using a reviver function during JSON.parse should be faster than\n      // parsing to JSON then converting to Lex (?)\n\n      // @TODO verify statement above\n      return { encoding, body: lexParse(text) }\n    } catch (cause) {\n      throw new XrpcInvalidResponseError(\n        'Invalid JSON response body',\n        response,\n        null,\n        { cause },\n      )\n    }\n  }\n\n  return { encoding, body: new Uint8Array(await response.arrayBuffer()) }\n}\n"]}