@atproto/lex-client 0.0.9 → 0.0.10

package/src/errors.ts

@@ -1,19 +1,17 @@
 import { LexError, LexErrorCode, LexErrorData } from '@atproto/lex-data'
 import { l } from '@atproto/lex-schema'
-import { Payload } from './util.js'
+import { XrpcPayload } from './util.js'
 
 export { LexError }
 export type { LexErrorCode, LexErrorData }
 
-export type LexRpcErrorPayload<N extends LexErrorCode = LexErrorCode> = Payload<
-  LexErrorData<N>,
-  'application/json'
->
+export type XrpcErrorPayload<N extends LexErrorCode = LexErrorCode> =
+  XrpcPayload<LexErrorData<N>, 'application/json'>
 
-export class LexRpcError<
+export class XrpcError<
   N extends LexErrorCode = LexErrorCode,
 > extends LexError<N> {
-  name = 'LexRpcError'
+  name = 'XrpcError'
 
   constructor(
     error: N,
@@ -36,9 +34,9 @@ export class LexRpcError<
  *
  * This function checks whether a given payload matches this schema.
  */
-export function isLexRpcErrorPayload(
-  payload: Payload | null,
-): payload is LexRpcErrorPayload {
+export function isXrpcErrorPayload(
+  payload: XrpcPayload | null,
+): payload is XrpcErrorPayload {
   return (
     payload !== null &&
     payload.encoding === 'application/json' &&
@@ -59,20 +57,20 @@ type LexRpcFailureResult<N extends LexErrorCode, E> = l.ResultFailure<E> & {
  * Class used to represent an HTTP request that resulted in an XRPC method error
  * That is, a non-2xx response with a valid XRPC error payload.
  */
-export class LexRpcResponseError<
+export class XrpcResponseError<
     M extends l.Procedure | l.Query = l.Procedure | l.Query,
     N extends LexErrorCode = LexErrorCode,
   >
-  extends LexRpcError<N>
-  implements LexRpcFailureResult<N, LexRpcResponseError<M, N>>
+  extends XrpcError<N>
+  implements LexRpcFailureResult<N, XrpcResponseError<M, N>>
 {
-  name = 'LexRpcResponseError'
+  name = 'XrpcResponseError'
 
   constructor(
     readonly method: M,
     readonly status: number,
     readonly headers: Headers,
-    readonly payload: LexRpcErrorPayload<N>,
+    readonly payload: XrpcErrorPayload<N>,
     options?: ErrorOptions,
   ) {
     const { error, message } = payload.body
@@ -92,7 +90,7 @@ export class LexRpcResponseError<
   matchesSchema(): this is M extends {
     errors: readonly (infer E extends string)[]
   }
-    ? LexRpcResponseError<M, E>
+    ? XrpcResponseError<M, E>
     : never {
     return this.method.errors?.includes(this.error) ?? false
   }
@@ -117,28 +115,28 @@ export class LexRpcResponseError<
 /**
  * This class represents an invalid XRPC response from the server.
  */
-export class LexRpcUpstreamError<
+export class XrpcUpstreamError<
     N extends 'InvalidResponse' | 'UpstreamFailure' =
       | 'InvalidResponse'
       | 'UpstreamFailure',
   >
-  extends LexRpcError<N>
-  implements LexRpcFailureResult<N, LexRpcUpstreamError<N>>
+  extends XrpcError<N>
+  implements LexRpcFailureResult<N, XrpcUpstreamError<N>>
 {
-  name = 'LexRpcUpstreamError' as const
+  name = 'XrpcUpstreamError' as const
 
   // For debugging purposes, we keep the response details here
   readonly response: {
     status: number
     headers: Headers
-    payload: Payload | null
+    payload: XrpcPayload | null
   }
 
   constructor(
     error: N,
     message: string,
     response: { status: number; headers: Headers },
-    payload: Payload | null,
+    payload: XrpcPayload | null,
     options?: ErrorOptions,
   ) {
     super(error, message, { cause: options?.cause })
@@ -169,11 +167,11 @@ export class LexRpcUpstreamError<
   }
 }
 
-export class LexRpcUnexpectedError
-  extends LexRpcError<'InternalServerError'>
+export class XrpcUnexpectedError
+  extends XrpcError<'InternalServerError'>
   implements LexRpcFailureResult<'InternalServerError', unknown>
 {
-  name = 'LexRpcUnexpectedError' as const
+  name = 'XrpcUnexpectedError' as const
 
   protected constructor(message: string, options: Required<ErrorOptions>) {
     super('InternalServerError', message, options)
@@ -202,8 +200,8 @@ export class LexRpcUnexpectedError
     message: string = cause instanceof LexError
       ? cause.message
       : 'XRPC request failed',
-  ): LexRpcUnexpectedError {
-    if (cause instanceof LexRpcUnexpectedError) return cause
-    return new LexRpcUnexpectedError(message, { cause })
+  ): XrpcUnexpectedError {
+    if (cause instanceof XrpcUnexpectedError) return cause
+    return new XrpcUnexpectedError(message, { cause })
   }
 }

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

@@ -17,7 +17,10 @@ const main =
       repo: /*#__PURE__*/ l.string({ format: 'at-identifier' }),
       collection: /*#__PURE__*/ l.string({ format: 'nsid' }),
       limit: /*#__PURE__*/ l.optional(
-        /*#__PURE__*/ l.integer({ minimum: 1, maximum: 100, default: 50 }),
+        /*#__PURE__*/ l.withDefault(
+          /*#__PURE__*/ l.integer({ minimum: 1, maximum: 100 }),
+          50,
+        ),
       ),
       cursor: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.string()),
       reverse: /*#__PURE__*/ l.optional(/*#__PURE__*/ l.boolean()),

package/src/response.ts

@@ -7,27 +7,27 @@ import {
   ResultSuccess,
 } from '@atproto/lex-schema'
 import {
-  LexRpcResponseError,
-  LexRpcUpstreamError,
-  isLexRpcErrorPayload,
+  XrpcResponseError,
+  XrpcUpstreamError,
+  isXrpcErrorPayload,
 } from './errors.js'
-import { Payload } from './util.js'
+import { XrpcPayload } from './util.js'
 
-export type LexRpcResponseBody<M extends Procedure | Query> =
+export type XrpcResponseBody<M extends Procedure | Query> =
   InferMethodOutputBody<M, Uint8Array>
 
-export type LexRpcResponsePayload<M extends Procedure | Query> =
+export type XrpcResponsePayload<M extends Procedure | Query> =
   InferMethodOutputEncoding<M> extends infer E extends string
-    ? Payload<LexRpcResponseBody<M>, E>
+    ? XrpcPayload<XrpcResponseBody<M>, E>
     : null
 
 /**
  * Small container for XRPC response data.
  *
- * @implements {ResultSuccess<LexRpcResponse<M>>} for convenience in result handling contexts.
+ * @implements {ResultSuccess<XrpcResponse<M>>} for convenience in result handling contexts.
  */
-export class LexRpcResponse<const M extends Procedure | Query>
-  implements ResultSuccess<LexRpcResponse<M>>
+export class XrpcResponse<const M extends Procedure | Query>
+  implements ResultSuccess<XrpcResponse<M>>
 {
   /** @see {@link ResultSuccess.success} */
   readonly success = true as const
@@ -41,7 +41,7 @@ export class LexRpcResponse<const M extends Procedure | Query>
     readonly method: M,
     readonly status: number,
     readonly headers: Headers,
-    readonly payload: LexRpcResponsePayload<M>,
+    readonly payload: XrpcResponsePayload<M>,
   ) {}
 
   /**
@@ -57,21 +57,21 @@ export class LexRpcResponse<const M extends Procedure | Query>
   }
 
   get body() {
-    return this.payload?.body as LexRpcResponseBody<M>
+    return this.payload?.body as XrpcResponseBody<M>
   }
 
   /**
-   * @throws {LexRpcResponseError} in case of (valid) XRPC error responses. Use
-   * {@link LexRpcResponseError.matchesSchema} to narrow the error type based on
+   * @throws {XrpcResponseError} in case of (valid) XRPC error responses. Use
+   * {@link XrpcResponseError.matchesSchema} to narrow the error type based on
    * the method's declared error schema.
-   * @throws {LexRpcUpstreamError} when the response is not a valid XRPC
+   * @throws {XrpcUpstreamError} 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<LexRpcResponse<M>> {
+  ): Promise<XrpcResponse<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.
@@ -81,8 +81,8 @@ export class LexRpcResponse<const M extends Procedure | Query>
       // Always parse json for error responses
       const payload = await readPayload(response, { parse: true })
 
-      if (response.status >= 400 && isLexRpcErrorPayload(payload)) {
-        throw new LexRpcResponseError(
+      if (response.status >= 400 && isXrpcErrorPayload(payload)) {
+        throw new XrpcResponseError(
           method,
           response.status,
           response.headers,
@@ -91,7 +91,7 @@ export class LexRpcResponse<const M extends Procedure | Query>
       }
 
       if (response.status >= 500) {
-        throw new LexRpcUpstreamError(
+        throw new XrpcUpstreamError(
           'UpstreamFailure',
           `Upstream server encountered an error`,
           response,
@@ -99,7 +99,7 @@ export class LexRpcResponse<const M extends Procedure | Query>
         )
       }
 
-      throw new LexRpcUpstreamError(
+      throw new XrpcUpstreamError(
         'InvalidResponse',
         response.status >= 400
           ? `Upstream server returned an invalid response payload`
@@ -118,7 +118,7 @@ export class LexRpcResponse<const M extends Procedure | Query>
     if (method.output.encoding == null) {
       // Schema expects no payload
       if (payload) {
-        throw new LexRpcUpstreamError(
+        throw new XrpcUpstreamError(
           'InvalidResponse',
           `Expected response with no body, got ${payload.encoding}`,
           response,
@@ -128,7 +128,7 @@ export class LexRpcResponse<const M extends Procedure | Query>
     } else {
       // Schema expects a payload
       if (!payload || !method.output.matchesEncoding(payload.encoding)) {
-        throw new LexRpcUpstreamError(
+        throw new XrpcUpstreamError(
           'InvalidResponse',
           payload
             ? `Expected ${method.output.encoding} response, got ${payload.encoding}`
@@ -140,12 +140,10 @@ export class LexRpcResponse<const M extends Procedure | Query>
 
       // Assert valid response body.
       if (method.output.schema && options?.validateResponse !== false) {
-        const result = method.output.schema.safeParse(payload.body, {
-          allowTransform: false,
-        })
+        const result = method.output.schema.safeParse(payload.body)
 
         if (!result.success) {
-          throw new LexRpcUpstreamError(
+          throw new XrpcUpstreamError(
             'InvalidResponse',
             `Response validation failed: ${result.reason.message}`,
             response,
@@ -156,11 +154,11 @@ export class LexRpcResponse<const M extends Procedure | Query>
       }
     }
 
-    return new LexRpcResponse<M>(
+    return new XrpcResponse<M>(
       method,
       response.status,
       response.headers,
-      payload as LexRpcResponsePayload<M>,
+      payload as XrpcResponsePayload<M>,
     )
   }
 }
@@ -175,7 +173,7 @@ function shouldParse(method: Procedure | Query) {
 async function readPayload(
   response: Response,
   options?: { parse?: boolean },
-): Promise<Payload | null> {
+): Promise<XrpcPayload | null> {
   // @TODO Should we limit the maximum response size here (this could also be
   // done by the FetchHandler)?
 
@@ -214,7 +212,7 @@ async function readPayload(
       // @TODO verify statement above
       return { encoding, body: lexParse(text) }
     } catch (cause) {
-      throw new LexRpcUpstreamError(
+      throw new XrpcUpstreamError(
         'InvalidResponse',
         'Invalid JSON response body',
         response,

package/src/util.ts

@@ -1,6 +1,6 @@
 import { DidString } from '@atproto/lex-schema'
 
-export type Payload<B = unknown, E extends string = string> = {
+export type XrpcPayload<B = unknown, E extends string = string> = {
   body: B
   encoding: E
 }

package/src/xrpc.ts

@@ -1,12 +1,11 @@
 import { LexValue, isLexScalar, isPlainObject } from '@atproto/lex-data'
 import { lexStringify } from '@atproto/lex-json'
 import {
-  InferMethodInput,
-  InferMethodParams,
+  InferInput,
+  InferPayload,
   Main,
   Params,
-  ParamsSchema,
-  Payload as LexPayload,
+  Payload,
   Procedure,
   Query,
   Restricted,
@@ -15,14 +14,14 @@ import {
 } from '@atproto/lex-schema'
 import { Agent } from './agent.js'
 import {
-  LexRpcResponseError,
-  LexRpcUnexpectedError,
-  LexRpcUpstreamError,
+  XrpcResponseError,
+  XrpcUnexpectedError,
+  XrpcUpstreamError,
 } from './errors.js'
-import { LexRpcResponse } from './response.js'
+import { XrpcResponse } from './response.js'
 import { BinaryBodyInit, CallOptions } from './types.js'
 import {
-  Payload,
+  XrpcPayload,
   buildAtprotoHeaders,
   isAsyncIterable,
   isBlobLike,
@@ -30,106 +29,108 @@ import {
 } from './util.js'
 
 // If all params are optional, allow omitting the params object
-type LexRpcParamsOptions<P extends Params> =
+type XrpcParamsOptions<P extends Params> =
   NonNullable<unknown> extends P ? { params?: P } : { params: P }
 
-type LexRpcRequestPayload<M extends Procedure | Query> = InferMethodInput<
-  M,
-  BinaryBodyInit
->
+export type XrpcRequestParams<M extends Procedure | Query | Subscription> =
+  InferInput<M['parameters']>
+
+type XrpcRequestPayload<M extends Procedure | Query> = M extends Procedure
+  ? InferPayload<M['input'], BinaryBodyInit>
+  : undefined
 
-type LexRpcInputOptions<In> = In extends { body: infer B; encoding: infer E }
+type XrpcInputOptions<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 LexRpcOptions<M extends Procedure | Query = Procedure | Query> =
+export type XrpcOptions<M extends Procedure | Query = Procedure | Query> =
   CallOptions &
-    LexRpcInputOptions<LexRpcRequestPayload<M>> &
-    LexRpcParamsOptions<InferMethodParams<M>>
+    XrpcInputOptions<XrpcRequestPayload<M>> &
+    XrpcParamsOptions<XrpcRequestParams<M>>
 
-export type LexRpcFailure<M extends Procedure | Query> =
+export type XrpcFailure<M extends Procedure | Query> =
   // The server returned a valid XRPC error response
-  | LexRpcResponseError<M>
+  | XrpcResponseError<M>
   // The response was not a valid XRPC response, or it does not match the schema
-  | LexRpcUpstreamError
+  | XrpcUpstreamError
   // Something went wrong (network error, etc.)
-  | LexRpcUnexpectedError
+  | XrpcUnexpectedError
 
-export type LexRpcResult<M extends Procedure | Query> =
-  | LexRpcResponse<M>
-  | LexRpcFailure<M>
+export type XrpcResult<M extends Procedure | Query> =
+  | XrpcResponse<M>
+  | XrpcFailure<M>
 
 /**
  * Utility method to type cast the error thrown by {@link xrpc} to an
- * {@link LexRpcFailure} matching the provided method. Only use this function
+ * {@link XrpcFailure} 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.
  */
-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)
+export function asXrpcFailure<M extends Procedure | Query = Procedure | Query>(
+  err: unknown,
+): XrpcFailure<M> {
+  if (err instanceof XrpcResponseError) return err
+  if (err instanceof XrpcUpstreamError) return err
+  return XrpcUnexpectedError.from(err)
 }
 
 /**
- * @throws LexRpcFailure<M>
+ * @throws XrpcFailure<M>
  */
 export async function xrpc<const M extends Query | Procedure>(
   agent: Agent,
-  ns: NonNullable<unknown> extends LexRpcOptions<M>
+  ns: NonNullable<unknown> extends XrpcOptions<M>
     ? Main<M>
     : Restricted<'This XRPC method requires an "options" argument'>,
-): Promise<LexRpcResponse<M>>
+): Promise<XrpcResponse<M>>
 export async function xrpc<const M extends Query | Procedure>(
   agent: Agent,
   ns: Main<M>,
-  options: LexRpcOptions<M>,
-): Promise<LexRpcResponse<M>>
+  options: XrpcOptions<M>,
+): Promise<XrpcResponse<M>>
 export async function xrpc<const M extends Query | Procedure>(
   agent: Agent,
   ns: Main<M>,
-  options: LexRpcOptions<M> = {} as LexRpcOptions<M>,
-): Promise<LexRpcResponse<M>> {
+  options: XrpcOptions<M> = {} as XrpcOptions<M>,
+): Promise<XrpcResponse<M>> {
   try {
     return await lexRpcRequest<M>(agent, ns, options)
   } catch (err) {
-    throw asLexRpcFailure<M>(err)
+    throw asXrpcFailure<M>(err)
   }
 }
 
 export async function xrpcSafe<const M extends Query | Procedure>(
   agent: Agent,
-  ns: NonNullable<unknown> extends LexRpcOptions<M>
+  ns: NonNullable<unknown> extends XrpcOptions<M>
     ? Main<M>
     : Restricted<'This XRPC method requires an "options" argument'>,
-): Promise<LexRpcResult<M>>
+): Promise<XrpcResult<M>>
 export async function xrpcSafe<const M extends Query | Procedure>(
   agent: Agent,
   ns: Main<M>,
-  options: LexRpcOptions<M>,
-): Promise<LexRpcResult<M>>
+  options: XrpcOptions<M>,
+): Promise<XrpcResult<M>>
 export async function xrpcSafe<const M extends Query | Procedure>(
   agent: Agent,
   ns: Main<M>,
-  options: LexRpcOptions<M> = {} as LexRpcOptions<M>,
-): Promise<LexRpcResult<M>> {
-  return lexRpcRequest<M>(agent, ns, options).catch(asLexRpcFailure<M>)
+  options: XrpcOptions<M> = {} as XrpcOptions<M>,
+): Promise<XrpcResult<M>> {
+  return lexRpcRequest<M>(agent, ns, options).catch(asXrpcFailure<M>)
 }
 
 async function lexRpcRequest<const M extends Query | Procedure>(
   agent: Agent,
   ns: Main<M>,
-  options: LexRpcOptions<M> = {} as LexRpcOptions<M>,
-): Promise<LexRpcResponse<M>> {
+  options: XrpcOptions<M> = {} as XrpcOptions<M>,
+): Promise<XrpcResponse<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 LexRpcResponse.fromFetchResponse<M>(method, response, options)
+  return XrpcResponse.fromFetchResponse<M>(method, response, options)
 }
 
 function xrpcRequestUrl<M extends Procedure | Query | Subscription>(
@@ -138,24 +139,13 @@ function xrpcRequestUrl<M extends Procedure | Query | Subscription>(
 ) {
   const path = `/xrpc/${method.nsid}`
 
-  const queryString = options.params
-    ? xrpcRequestParams(method.parameters, options.params, options)
-    : undefined
+  const queryString = method.parameters
+    ?.toURLSearchParams(options.params ?? {})
+    .toString()
 
   return queryString ? `${path}?${queryString}` : path
 }
 
-function xrpcRequestParams(
-  schema: ParamsSchema | undefined,
-  params: Params | undefined,
-  options: CallOptions,
-): undefined | string {
-  const urlSearchParams = schema?.toURLSearchParams(
-    options.validateRequest ? schema.parse(params) : (params as any),
-  )
-  return urlSearchParams?.size ? urlSearchParams.toString() : undefined
-}
-
 function xrpcRequestInit<T extends Procedure | Query>(
   schema: T,
   options: CallOptions & {
@@ -215,7 +205,7 @@ function xrpcProcedureInput(
   method: Procedure,
   options: CallOptions & { body?: LexValue | BinaryBodyInit },
   encodingHint?: string,
-): null | Payload<BodyInit> {
+): null | XrpcPayload<BodyInit> {
   const { input } = method
   const { body } = options
 
@@ -261,10 +251,10 @@ function xrpcProcedureInput(
 }
 
 function buildPayload(
-  schema: LexPayload,
+  schema: Payload,
   body: undefined | BodyInit,
   encodingHint?: string,
-): null | Payload<BodyInit> {
+): null | XrpcPayload<BodyInit> {
   if (schema.encoding === undefined) {
     if (body !== undefined) {
       throw new TypeError(
@@ -286,7 +276,7 @@ function buildPayload(
   return { encoding, body }
 }
 
-function buildEncoding(schema: LexPayload, encodingHint?: string): string {
+function buildEncoding(schema: Payload, encodingHint?: string): string {
   // Should never happen (required for type safety)
   if (!schema.encoding) {
     throw new TypeError('Unexpected payload')