@atproto/lex-client 0.0.4 → 0.0.6

package/src/xrpc.ts

@@ -1,62 +1,140 @@
-import { LexValue } from '@atproto/lex-data'
-import { lexParse, lexStringify } from '@atproto/lex-json'
+import { LexValue, isLexScalar, isPlainObject } from '@atproto/lex-data'
+import { lexStringify } from '@atproto/lex-json'
 import {
-  DidString,
-  InferParamsSchema,
-  InferPayloadBody,
+  InferMethodInput,
+  InferMethodParams,
+  Main,
   Params,
   ParamsSchema,
+  Payload as LexPayload,
   Procedure,
   Query,
   Restricted,
   Subscription,
+  getMain,
 } from '@atproto/lex-schema'
 import { Agent } from './agent.js'
 import {
-  KnownError,
-  XrpcResponseError,
-  XrpcServiceError,
-  xrpcErrorBodySchema,
-} from './error.js'
-import { XrpcResponse, XrpcResponseBody } from './response.js'
-import { CallOptions, Namespace, Service, getMain } from './types.js'
-
-export type XrpcOptions<M extends Procedure | Query = Procedure | Query> =
-  CallOptions & XrpcRequestUrlOptions<M> & XrpcRequestInitOptions<M>
+  LexRpcResponseError,
+  LexRpcUnexpectedError,
+  LexRpcUpstreamError,
+} from './errors.js'
+import { LexRpcResponse } from './response.js'
+import { BinaryBodyInit, CallOptions } from './types.js'
+import {
+  Payload,
+  buildAtprotoHeaders,
+  isAsyncIterable,
+  isBlobLike,
+  toReadableStream,
+} from './util.js'
+
+// If all params are optional, allow omitting the params object
+type LexRpcParamsOptions<P extends Params> =
+  NonNullable<unknown> extends P ? { params?: P } : { params: P }
+
+type LexRpcRequestPayload<M extends Procedure | Query> = InferMethodInput<
+  M,
+  BinaryBodyInit
+>
+
+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 LexRpcOptions<M extends Procedure | Query = Procedure | Query> =
+  CallOptions &
+    LexRpcInputOptions<LexRpcRequestPayload<M>> &
+    LexRpcParamsOptions<InferMethodParams<M>>
+
+export type LexRpcFailure<M extends Procedure | Query> =
+  // The server returned a valid XRPC error response
+  | LexRpcResponseError<M>
+  // The response was not a valid XRPC response, or it does not match the schema
+  | LexRpcUpstreamError
+  // Something went wrong (network error, etc.)
+  | LexRpcUnexpectedError
+
+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 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.
+ */
+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 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>> {
-  options.signal?.throwIfAborted()
+  ns: Main<M>,
+  options: LexRpcOptions<M> = {} as LexRpcOptions<M>,
+): Promise<LexRpcResponse<M>> {
+  try {
+    return await lexRpcRequest<M>(agent, ns, options)
+  } catch (err) {
+    throw asLexRpcFailure<M>(err)
+  }
+}
+
+export async function xrpcSafe<const M extends Query | Procedure>(
+  agent: Agent,
+  ns: NonNullable<unknown> extends LexRpcOptions<M>
+    ? Main<M>
+    : Restricted<'This XRPC method requires an "options" argument'>,
+): Promise<LexRpcResult<M>>
+export async function xrpcSafe<const M extends Query | Procedure>(
+  agent: Agent,
+  ns: Main<M>,
+  options: LexRpcOptions<M>,
+): Promise<LexRpcResult<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>)
+}
+
+async function lexRpcRequest<const M extends Query | Procedure>(
+  agent: Agent,
+  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 xrpcResponseHandler<M>(response, method, options)
+  return LexRpcResponse.fromFetchResponse<M>(method, response, options)
 }
 
-export type XrpcRequestUrlOptions<M extends Query | Procedure | Subscription> =
-  CallOptions &
-    (undefined extends InferParamsSchema<M['parameters']>
-      ? { params?: InferParamsSchema<M['parameters']> }
-      : { params: InferParamsSchema<M['parameters']> })
-
-export function xrpcRequestUrl<M extends Procedure | Query | Subscription>(
+function xrpcRequestUrl<M extends Procedure | Query | Subscription>(
   method: M,
-  options: XrpcRequestUrlOptions<M>,
+  options: CallOptions & { params?: Params },
 ) {
   const path = `/xrpc/${method.nsid}`
 
@@ -67,7 +145,7 @@ export function xrpcRequestUrl<M extends Procedure | Query | Subscription>(
   return queryString ? `${path}?${queryString}` : path
 }
 
-export function xrpcRequestParams(
+function xrpcRequestParams(
   schema: ParamsSchema | undefined,
   params: Params | undefined,
   options: CallOptions,
@@ -78,32 +156,37 @@ export function xrpcRequestParams(
   return urlSearchParams?.size ? urlSearchParams.toString() : undefined
 }
 
-export type XrpcRequestInitOptions<T extends Query | Procedure> = CallOptions &
-  (T extends Procedure
-    ? never extends InferPayloadBody<T['input']>
-      ? { body?: InferPayloadBody<T['input']> }
-      : { body: InferPayloadBody<T['input']> }
-    : { body?: never })
-
-export function xrpcRequestInit<T extends Procedure | Query>(
+function xrpcRequestInit<T extends Procedure | Query>(
   schema: T,
-  options: XrpcRequestInitOptions<T>,
+  options: CallOptions & {
+    body?: LexValue | BinaryBodyInit
+    encoding?: string
+  },
 ): RequestInit & { duplex?: 'half' } {
-  const headers = xrpcRequestHeaders(options)
+  const headers = buildAtprotoHeaders(options)
+
+  // Tell the server what type of response we're expecting
+  if (schema.output.encoding) {
+    headers.set('accept', schema.output.encoding)
+  }
+
+  // Caller should not set content-type header
+  if (headers.has('content-type')) {
+    const contentType = headers.get('content-type')
+    throw new TypeError(`Unexpected content-type header (${contentType})`)
+  }
 
   // Requests with body
-  if ('input' in schema && schema.input?.encoding) {
-    if (
-      options.validateRequest &&
-      schema.input == null &&
-      options.body !== undefined
-    ) {
-      throw new TypeError(
-        `XRPC method ${schema.nsid} does not accept a request body`,
-      )
+  if ('input' in schema) {
+    const encodingHint = options.encoding
+    const input = xrpcProcedureInput(schema, options, encodingHint)
+
+    if (input) {
+      headers.set('content-type', input.encoding)
+    } else if (encodingHint != null) {
+      throw new TypeError(`Unexpected encoding hint (${encodingHint})`)
     }
 
-    headers.set('content-type', schema.input.encoding)
     return {
       duplex: 'half',
       redirect: 'follow',
@@ -112,12 +195,7 @@ export function xrpcRequestInit<T extends Procedure | Query>(
       signal: options.signal,
       method: 'POST',
       headers,
-      body: xrpcRequestBody(
-        schema.input?.encoding,
-        options.validateRequest
-          ? schema.input?.body.parse(options.body)
-          : options.body,
-      ),
+      body: input?.body,
     }
   }
 
@@ -128,208 +206,118 @@ export function xrpcRequestInit<T extends Procedure | Query>(
     referrerPolicy: 'strict-origin-when-cross-origin', // (default)
     mode: 'cors', // (default)
     signal: options.signal,
-    method: schema instanceof Query ? 'GET' : 'POST',
+    method: 'GET',
     headers,
   }
 }
 
-export function xrpcRequestHeaders(options: {
-  headers?: HeadersInit
-  service?: Service
-  labelers?: Iterable<DidString>
-}): Headers {
-  const headers = new Headers(options.headers)
+function xrpcProcedureInput(
+  method: Procedure,
+  options: CallOptions & { body?: LexValue | BinaryBodyInit },
+  encodingHint?: string,
+): null | Payload<BodyInit> {
+  const { input } = method
+  const { body } = options
 
-  if (options.service && !headers.has('atproto-proxy')) {
-    headers.set('atproto-proxy', options.service)
+  if (options.validateRequest) {
+    input.schema?.check(body)
   }
 
-  if (options.labelers) {
-    headers.set(
-      'atproto-accept-labelers',
-      [...options.labelers, headers.get('atproto-accept-labelers')?.trim()]
-        .filter(Boolean)
-        .join(', '),
-    )
-  }
-
-  return headers
-}
+  // Special handling for endpoints expecting application/json input
+  if (input.encoding === 'application/json') {
+    // @NOTE **NOT** using isLexValue here to avoid deep checks in order to
+    // distinguish between LexValue and BinaryBodyInit.
+    if (!isLexScalar(body) && !isPlainObject(body) && !Array.isArray(body)) {
+      throw new TypeError(`Expected LexValue body, got ${typeof body}`)
+    }
 
-function xrpcRequestBody(
-  encoding: string | undefined,
-  body: LexValue | undefined,
-): BodyInit | null {
-  if (encoding === undefined) {
-    return null
+    return buildPayload(input, lexStringify(body), encodingHint)
   }
 
-  if (encoding === 'application/json') {
-    if (body !== undefined) return lexStringify(body)
-  } else if (encoding.startsWith('text/')) {
-    if (typeof body === 'string') return body
-  } else {
-    if (ArrayBuffer.isView(body) || body instanceof ArrayBuffer) return body
+  // Other encodings will be sent unaltered (ie. as binary data)
+  switch (typeof body) {
+    case 'undefined':
+    case 'string':
+      return buildPayload(input, body, encodingHint)
+    case 'object': {
+      if (body === null) break
+      if (
+        ArrayBuffer.isView(body) ||
+        body instanceof ArrayBuffer ||
+        body instanceof ReadableStream
+      ) {
+        return buildPayload(input, body, encodingHint)
+      } else if (isAsyncIterable(body)) {
+        return buildPayload(input, toReadableStream(body), encodingHint)
+      } else if (isBlobLike(body)) {
+        return buildPayload(input, body, encodingHint || body.type)
+      }
+    }
   }
 
-  throw new TypeError(`Invalid ${typeof body} body for ${encoding} encoding`)
+  throw new TypeError(
+    `Invalid ${typeof body} body for ${input.encoding} encoding`,
+  )
 }
 
-export async function xrpcResponseHandler<M extends Procedure | Query>(
-  response: Response,
-  schema: M,
-  options?: { validateResponse?: boolean },
-): Promise<XrpcResponse<M>> {
-  // @NOTE The body MUST either be read or canceled to avoid resource leaks.
-  // Since nothing should cause an exception before "readXrpcResponseBody" is
-  // called, we can safely not use a try/finally here.
-
-  const encoding = extractEncoding(response.headers)
-
-  const body = await readResponseBody(response, encoding).catch((cause) => {
-    throw new XrpcServiceError(
-      KnownError.InvalidResponse,
-      response.status,
-      response.headers,
-      undefined,
-      'Failed to read XRPC response',
-      { cause },
-    )
-  })
-
-  // @NOTE redirect is set to 'follow', so we shouldn't get 3xx responses here
-  if (response.status < 200 || response.status >= 300) {
-    // All unsuccessful responses should follow a standard error response
-    // schema. The Content-Type should be application/json, and the payload
-    // should be a JSON object with the following fields:
-    // - error (string, required): type name of the error (generic ASCII
-    //   constant, no whitespace)
-    // - message (string, optional): description of the error, appropriate for
-    //   display to humans
-    if (
-      body != null &&
-      encoding === 'application/json' &&
-      xrpcErrorBodySchema.matches(body)
-    ) {
-      throw new XrpcResponseError(
-        response.status,
-        response.headers,
-        encoding,
-        body,
+function buildPayload(
+  schema: LexPayload,
+  body: undefined | BodyInit,
+  encodingHint?: string,
+): null | Payload<BodyInit> {
+  if (schema.encoding === undefined) {
+    if (body !== undefined) {
+      throw new TypeError(
+        `Cannot send a ${typeof body} body with undefined encoding`,
       )
     }
 
-    throw new XrpcServiceError(
-      response.status >= 500
-        ? KnownError.InternalServerError
-        : KnownError.InvalidResponse,
-      response.status,
-      response.headers,
-      body,
-    )
+    return null
   }
 
-  // Check response encoding
-  if (schema.output.encoding !== encoding) {
-    throw new XrpcServiceError(
-      KnownError.InvalidResponse,
-      response.status,
-      response.headers,
-      body,
-      `Expected response with content-type ${schema.output.encoding}, got ${encoding}`,
-    )
+  if (body === undefined) {
+    // This error would be returned by the server, but we can catch it earlier
+    // to avoid un-necessary requests. Note that a content-length of 0 does not
+    // necessary mean that the body is "empty" (e.g. an empty txt file).
+    throw new TypeError(`A request body is expected but none was provided`)
   }
 
-  if (schema.output.encoding == null) {
-    if (body !== undefined) {
-      throw new XrpcServiceError(
-        KnownError.InvalidResponse,
-        response.status,
-        response.headers,
-        body,
-        `Expected empty response body`,
-      )
-    }
+  const encoding = buildEncoding(schema, encodingHint)
+  return { encoding, body }
+}
+
+function buildEncoding(schema: LexPayload, encodingHint?: string): string {
+  // Should never happen (required for type safety)
+  if (!schema.encoding) {
+    throw new TypeError('Unexpected payload')
+  }
 
-    return new XrpcResponse<M>(
-      schema,
-      response.status,
-      response.headers,
-      undefined as XrpcResponseBody<M>,
-    )
-  } else {
-    // @NOTE this should already be enforced by readXrpcResponseBody
-    if (body === undefined) {
-      throw new XrpcServiceError(
-        KnownError.InvalidResponse,
-        response.status,
-        response.headers,
-        body,
-        `Expected non-empty response body`,
+  if (encodingHint?.length) {
+    if (!schema.matchesEncoding(encodingHint)) {
+      throw new TypeError(
+        `Cannot send a body with content-type "${encodingHint}" for "${schema.encoding}" encoding`,
       )
     }
-
-    return new XrpcResponse<M>(
-      schema,
-      response.status,
-      response.headers,
-      schema.output.schema == null || options?.validateResponse === false
-        ? (body as XrpcResponseBody<M>)
-        : (schema.output.schema.parse(body) as XrpcResponseBody<M>),
-    )
+    return encodingHint
   }
-}
-
-export function extractEncoding(headers: Headers): string | undefined {
-  const contentType = headers.get('content-type')
-  if (!contentType) return undefined
-  return contentType.split(';')[0].trim()
-}
 
-export async function readResponseBody(
-  response: Response,
-  encoding: string,
-): Promise<LexValue>
-export async function readResponseBody(
-  response: Response,
-  encoding: string | undefined,
-): Promise<LexValue | undefined>
-export async function readResponseBody(
-  response: Response,
-  encoding: string | undefined,
-): Promise<LexValue | undefined> {
-  // When encoding is undefined or empty, we expect no body
-  if (encoding == null) {
-    if (response.body == null) return undefined
-
-    // Let's make sure the body is empty (while avoiding reading it all).
-    if (!('getReader' in response.body)) {
-      // Some environments may not support body.getReader(), fall back to
-      // reading the whole body.
-      const buffer = await response.arrayBuffer()
-      if (buffer.byteLength === 0) return undefined
-    } else {
-      const reader = response.body.getReader()
-      const next = await reader.read()
-      if (next.done) return undefined
-      await reader.cancel() // Drain the rest of the (non-empty) body stream
-    }
+  // Fallback
 
-    throw new SyntaxError('Content-type is undefined but body is not empty')
+  if (schema.encoding === '*/*') {
+    return 'application/octet-stream'
   }
 
-  if (encoding === 'application/json') {
-    // @NOTE Using `lexParse(text)` (instead of `jsonToLex(json)`) here as using
-    // a reviver function during JSON.parse should be faster than parsing to
-    // JSON then converting to Lex (?)
-
-    // @TODO verify statement above
-    return lexParse(await response.text())
+  if (schema.encoding.startsWith('text/')) {
+    return schema.encoding.includes('*')
+      ? 'text/plain; charset=utf-8'
+      : `${schema.encoding}; charset=utf-8`
   }
 
-  if (encoding.startsWith('text/')) {
-    return response.text()
+  if (!schema.encoding.includes('*')) {
+    return schema.encoding
   }
 
-  return new Uint8Array(await response.arrayBuffer())
+  throw new TypeError(
+    `Unable to determine payload encoding. Please provide a 'content-type' header matching ${schema.encoding}.`,
+  )
 }

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/error.d.ts

@@ -1,66 +0,0 @@
-import { LexValue } from '@atproto/lex-data';
-import { l } from '@atproto/lex-schema';
-export declare enum KnownError {
-    Unknown = "Unknown",
-    AuthenticationRequired = "AuthenticationRequired",
-    Forbidden = "Forbidden",
-    InternalServerError = "InternalServerError",
-    InvalidRequest = "InvalidRequest",
-    InvalidResponse = "InvalidResponse",
-    MethodNotImplemented = "MethodNotImplemented",
-    NotAcceptable = "NotAcceptable",
-    NotEnoughResources = "NotEnoughResources",
-    PayloadTooLarge = "PayloadTooLarge",
-    RateLimitExceeded = "RateLimitExceeded",
-    UnsupportedMediaType = "UnsupportedMediaType",
-    UpstreamFailure = "UpstreamFailure",
-    UpstreamTimeout = "UpstreamTimeout",
-    XRPCNotSupported = "XRPCNotSupported"
-}
-export type XrpcFailure<N extends string, E> = l.ResultFailure<E> & {
-    name: N;
-};
-export type XrpcErrorName = l.UnknownString | KnownError;
-export declare const xrpcErrorNameSchema: l.StringSchema<{
-    readonly minLength: 1;
-}>;
-export type XrpcErrorBody<N extends XrpcErrorName = XrpcErrorName> = {
-    error: N;
-    message?: string;
-};
-export declare const xrpcErrorBodySchema: l.ObjectSchema<{
-    readonly error: l.StringSchema<{
-        readonly minLength: 1;
-    }>;
-    readonly message: l.OptionalSchema<string>;
-}>;
-/**
- * @implements {XrpcFailure<N, XrpcError<N>>} for convenience in result handling contexts.
- */
-export declare class XrpcError<N extends XrpcErrorName = XrpcErrorName> extends Error implements XrpcFailure<N, XrpcError<N>> {
-    readonly name: N;
-    constructor(name: N, message?: string, options?: ErrorOptions);
-    /** @see {@link l.ResultFailure.success} */
-    readonly success: false;
-    /** @see {@link l.ResultFailure.error} */
-    get error(): this;
-    static from(cause: unknown, message?: string): XrpcError;
-}
-export declare class XrpcServiceError<N extends XrpcErrorName = XrpcErrorName> extends XrpcError<N> {
-    readonly status: number;
-    readonly headers: Headers;
-    readonly body: undefined | LexValue;
-    constructor(name: N, status: number, headers: Headers, body: undefined | LexValue, message?: string, options?: ErrorOptions);
-}
-export declare class XrpcResponseError<N extends XrpcErrorName = XrpcErrorName, B extends XrpcErrorBody<N> = XrpcErrorBody<N>> extends XrpcError<N> {
-    readonly status: number;
-    readonly headers: Headers;
-    readonly encoding: undefined | string;
-    readonly body: B;
-    constructor(status: number, headers: Headers, encoding: undefined | string, body: B, options?: ErrorOptions);
-}
-export type XrpcRequestFailure<M extends l.Procedure | l.Query> = (M extends {
-    errors: readonly (infer N extends string)[];
-} ? XrpcResponseError<N> : never) | XrpcFailure<'Unknown', XrpcResponseError<string>> | XrpcFailure<'UnexpectedError', unknown>;
-export declare function asXrpcRequestFailureFor<M extends l.Procedure | l.Query>(schema: M): (error: unknown) => XrpcRequestFailure<M>;
-//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

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