@atproto/lex-client 0.1.5 → 0.2.1

package/src/util.test.ts

@@ -1,333 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  buildXrpcRequestHeaders,
-  isAsyncIterable,
-  isBlobLike,
-  toReadableStream,
-  toReadableStreamPonyfill,
-} from './util.js'
-
-// ============================================================================
-// isBlobLike
-// ============================================================================
-
-describe(isBlobLike, () => {
-  it('returns true for native Blob', () => {
-    expect(isBlobLike(new Blob(['hello']))).toBe(true)
-  })
-
-  it('returns true for native File', () => {
-    expect(isBlobLike(new File(['hello'], 'test.txt'))).toBe(true)
-  })
-
-  it('returns false for null', () => {
-    expect(isBlobLike(null)).toBe(false)
-  })
-
-  it('returns false for undefined', () => {
-    expect(isBlobLike(undefined)).toBe(false)
-  })
-
-  it('returns false for primitives', () => {
-    expect(isBlobLike(42)).toBe(false)
-    expect(isBlobLike('string')).toBe(false)
-    expect(isBlobLike(true)).toBe(false)
-  })
-
-  it('returns false for plain objects', () => {
-    expect(isBlobLike({})).toBe(false)
-    expect(isBlobLike({ stream: () => {} })).toBe(false)
-  })
-
-  it('returns true for Blob-like objects with [Symbol.toStringTag] = "Blob"', () => {
-    const blobLike = {
-      [Symbol.toStringTag]: 'Blob',
-      stream: () => new ReadableStream(),
-    }
-    expect(isBlobLike(blobLike)).toBe(true)
-  })
-
-  it('returns true for File-like objects with [Symbol.toStringTag] = "File"', () => {
-    const fileLike = {
-      [Symbol.toStringTag]: 'File',
-      stream: () => new ReadableStream(),
-    }
-    expect(isBlobLike(fileLike)).toBe(true)
-  })
-
-  it('returns false for objects with Blob tag but no stream method', () => {
-    const notBlob = {
-      [Symbol.toStringTag]: 'Blob',
-    }
-    expect(isBlobLike(notBlob)).toBe(false)
-  })
-
-  it('returns false for objects with Blob tag but non-function stream', () => {
-    const notBlob = {
-      [Symbol.toStringTag]: 'Blob',
-      stream: 'not a function',
-    }
-    expect(isBlobLike(notBlob)).toBe(false)
-  })
-})
-
-// ============================================================================
-// isAsyncIterable
-// ============================================================================
-
-describe(isAsyncIterable, () => {
-  it('returns true for async generators', () => {
-    async function* gen() {
-      yield 1
-    }
-    expect(isAsyncIterable(gen())).toBe(true)
-  })
-
-  it('returns true for objects with Symbol.asyncIterator', () => {
-    const iterable = {
-      [Symbol.asyncIterator]() {
-        return { next: async () => ({ done: true, value: undefined }) }
-      },
-    }
-    expect(isAsyncIterable(iterable)).toBe(true)
-  })
-
-  it('returns false for null', () => {
-    expect(isAsyncIterable(null)).toBe(false)
-  })
-
-  it('returns false for undefined', () => {
-    expect(isAsyncIterable(undefined)).toBe(false)
-  })
-
-  it('returns false for plain objects', () => {
-    expect(isAsyncIterable({})).toBe(false)
-  })
-
-  it('returns false for sync iterables', () => {
-    expect(isAsyncIterable([1, 2, 3])).toBe(false)
-    expect(isAsyncIterable('string')).toBe(false)
-  })
-})
-
-// ============================================================================
-// buildXrpcRequestHeaders
-// ============================================================================
-
-describe(buildXrpcRequestHeaders, () => {
-  it('returns empty headers when no options are set', () => {
-    const headers = buildXrpcRequestHeaders({})
-    expect([...headers.entries()]).toEqual([])
-  })
-
-  it('sets atproto-proxy header from service option', () => {
-    const headers = buildXrpcRequestHeaders({
-      service: 'did:plc:1234#atproto_labeler',
-    })
-    expect(headers.get('atproto-proxy')).toBe('did:plc:1234#atproto_labeler')
-  })
-
-  it('does not override existing atproto-proxy header', () => {
-    const headers = buildXrpcRequestHeaders({
-      headers: { 'atproto-proxy': 'did:plc:existing#service' },
-      service: 'did:plc:new#service',
-    })
-    expect(headers.get('atproto-proxy')).toBe('did:plc:existing#service')
-  })
-
-  it('sets atproto-accept-labelers from labelers option', () => {
-    const headers = buildXrpcRequestHeaders({
-      labelers: ['did:plc:labeler1', 'did:plc:labeler2'] as const,
-    })
-    expect(headers.get('atproto-accept-labelers')).toBe(
-      'did:plc:labeler1, did:plc:labeler2',
-    )
-  })
-
-  it('appends to existing atproto-accept-labelers header', () => {
-    const headers = buildXrpcRequestHeaders({
-      headers: { 'atproto-accept-labelers': 'did:plc:existing' },
-      labelers: ['did:plc:new'] as const,
-    })
-    expect(headers.get('atproto-accept-labelers')).toBe(
-      'did:plc:new, did:plc:existing',
-    )
-  })
-
-  it('passes through base headers', () => {
-    const headers = buildXrpcRequestHeaders({
-      headers: { Authorization: 'Bearer token123' },
-    })
-    expect(headers.get('Authorization')).toBe('Bearer token123')
-  })
-
-  it('accepts Headers instance as base headers', () => {
-    const base = new Headers({ 'X-Custom': 'value' })
-    const headers = buildXrpcRequestHeaders({ headers: base })
-    expect(headers.get('X-Custom')).toBe('value')
-  })
-
-  it('sets empty header for empty labelers iterable', () => {
-    const headers = buildXrpcRequestHeaders({ labelers: [] })
-    // An empty array still sets the header (to empty string), distinguishing
-    // "no labelers requested" from "labelers option not provided"
-    expect(headers.has('atproto-accept-labelers')).toBe(true)
-    expect(headers.get('atproto-accept-labelers')).toBe('')
-  })
-})
-
-// ============================================================================
-// toReadableStream
-// ============================================================================
-
-describe(toReadableStream, () => {
-  it('converts async iterable to ReadableStream', async () => {
-    async function* gen() {
-      yield new Uint8Array([1, 2])
-      yield new Uint8Array([3, 4])
-    }
-
-    const stream = toReadableStream(gen())
-    const reader = stream.getReader()
-
-    const chunk1 = await reader.read()
-    expect(chunk1.done).toBe(false)
-    expect(chunk1.value).toEqual(new Uint8Array([1, 2]))
-
-    const chunk2 = await reader.read()
-    expect(chunk2.done).toBe(false)
-    expect(chunk2.value).toEqual(new Uint8Array([3, 4]))
-
-    const end = await reader.read()
-    expect(end.done).toBe(true)
-  })
-
-  it('handles empty async iterable', async () => {
-    async function* gen() {
-      // yields nothing
-    }
-
-    const stream = toReadableStream(gen())
-    const reader = stream.getReader()
-
-    const result = await reader.read()
-    expect(result.done).toBe(true)
-  })
-
-  it('can be consumed with Response API', async () => {
-    async function* gen() {
-      yield new TextEncoder().encode('hello ')
-      yield new TextEncoder().encode('world')
-    }
-
-    const stream = toReadableStream(gen())
-    const response = new Response(stream)
-    const text = await response.text()
-    expect(text).toBe('hello world')
-  })
-
-  it('propagates errors from the async iterable', async () => {
-    async function* gen() {
-      yield new Uint8Array([1])
-      throw new Error('stream error')
-    }
-
-    const stream = toReadableStream(gen())
-    const reader = stream.getReader()
-
-    // First chunk succeeds
-    await reader.read()
-
-    // Second read should reject
-    await expect(reader.read()).rejects.toThrow('stream error')
-  })
-})
-
-// ============================================================================
-// toReadableStreamPonyfill
-// ============================================================================
-
-describe(toReadableStreamPonyfill, () => {
-  it('converts async iterable to ReadableStream', async () => {
-    async function* gen() {
-      yield new Uint8Array([1, 2])
-      yield new Uint8Array([3, 4])
-    }
-
-    const stream = toReadableStreamPonyfill(gen())
-    const reader = stream.getReader()
-
-    const chunk1 = await reader.read()
-    expect(chunk1.done).toBe(false)
-    expect(chunk1.value).toEqual(new Uint8Array([1, 2]))
-
-    const chunk2 = await reader.read()
-    expect(chunk2.done).toBe(false)
-    expect(chunk2.value).toEqual(new Uint8Array([3, 4]))
-
-    const end = await reader.read()
-    expect(end.done).toBe(true)
-  })
-
-  it('handles empty async iterable', async () => {
-    async function* gen() {
-      // yields nothing
-    }
-
-    const stream = toReadableStreamPonyfill(gen())
-    const reader = stream.getReader()
-
-    const result = await reader.read()
-    expect(result.done).toBe(true)
-  })
-
-  it('can be consumed with Response API', async () => {
-    async function* gen() {
-      yield new TextEncoder().encode('hello ')
-      yield new TextEncoder().encode('world')
-    }
-
-    const stream = toReadableStreamPonyfill(gen())
-    const response = new Response(stream)
-    const text = await response.text()
-    expect(text).toBe('hello world')
-  })
-
-  it('propagates errors from the async iterable', async () => {
-    async function* gen() {
-      yield new Uint8Array([1])
-      throw new Error('stream error')
-    }
-
-    const stream = toReadableStreamPonyfill(gen())
-    const reader = stream.getReader()
-
-    await reader.read()
-    await expect(reader.read()).rejects.toThrow('stream error')
-  })
-
-  it('calls iterator.return() on cancel', async () => {
-    let returned = false
-    const iterable: AsyncIterable<Uint8Array> = {
-      [Symbol.asyncIterator]() {
-        return {
-          async next() {
-            return { done: false, value: new Uint8Array([1]) }
-          },
-          async return() {
-            returned = true
-            return { done: true, value: undefined }
-          },
-        }
-      },
-    }
-
-    const stream = toReadableStreamPonyfill(iterable)
-    const reader = stream.getReader()
-
-    await reader.read()
-    await reader.cancel()
-
-    expect(returned).toBe(true)
-  })
-})

package/src/util.ts

@@ -1,182 +0,0 @@
-import {
-  InferRecordKey,
-  LexiconRecordKey,
-  RecordSchema,
-} from '@atproto/lex-schema'
-import type { DidString, Service } from './types.js'
-
-export function applyDefaults<
-  TDefaults extends Record<string, unknown>,
-  TOptions extends {
-    [K in keyof TDefaults]?: TDefaults[K]
-  },
->(options: TOptions, defaults: TDefaults): TOptions & TDefaults {
-  const combined: Partial<TDefaults> = { ...options }
-
-  // @NOTE We make sure that options with an explicit `undefined` value get the
-  // default, since spreading doesn't override with `undefined`.
-  for (const key of Object.keys(defaults) as (keyof typeof defaults)[]) {
-    if (options[key] === undefined) {
-      combined[key] = defaults[key]
-    }
-  }
-
-  return combined as TOptions & TDefaults
-}
-
-/**
- * Type guard to check if a value is {@link Blob}-like.
- *
- * Handles both native Blobs and polyfilled Blob implementations
- * (e.g., fetch-blob from node-fetch).
- *
- * @param value - The value to check
- * @returns `true` if the value is a Blob or Blob-like object
- */
-export function isBlobLike(value: unknown): value is Blob {
-  if (value == null) return false
-  if (typeof value !== 'object') return false
-  if (typeof Blob === 'function' && value instanceof Blob) return true
-
-  // Support for Blobs provided by libraries that don't use the native Blob
-  // (e.g. fetch-blob from node-fetch).
-  // https://github.com/node-fetch/fetch-blob/blob/a1a182e5978811407bef4ea1632b517567dda01f/index.js#L233-L244
-
-  const tag = (value as any)[Symbol.toStringTag]
-  if (tag === 'Blob' || tag === 'File') {
-    return 'stream' in value && typeof value.stream === 'function'
-  }
-
-  return false
-}
-
-export function isAsyncIterable<T>(
-  value: T,
-): value is unknown extends T
-  ? T & AsyncIterable<unknown>
-  : Extract<T, AsyncIterable<any>> {
-  return (
-    value != null && typeof (value as any)[Symbol.asyncIterator] === 'function'
-  )
-}
-
-export function asUint8ArrayArrayBuffer(
-  bytes: Uint8Array,
-): Uint8Array<ArrayBuffer> {
-  // If the Uint8Array is already backed by a non-shared ArrayBuffer, we can use
-  // it directly.
-  if (bytes.buffer instanceof ArrayBuffer) {
-    return bytes as Uint8Array<ArrayBuffer>
-  }
-
-  // Otherwise, we need to create a new ArrayBuffer and copy the data.
-  return new Uint8Array(bytes)
-}
-
-export type XrpcRequestHeadersOptions = {
-  /** Additional HTTP headers to include in the request. */
-  headers?: HeadersInit
-
-  /** Labeler DIDs to request labels from for content moderation. */
-  labelers?: Iterable<DidString>
-
-  /** Service proxy identifier for routing requests through a specific service. */
-  service?: Service
-}
-
-/**
- * Builds HTTP headers for AT Protocol requests.
- *
- * Adds the following headers when applicable:
- * - `atproto-proxy`: Service routing header (if service is specified)
- * - `atproto-accept-labelers`: Comma-separated list of labeler DIDs
- *
- * @see {@link XrpcRequestHeadersOptions}
- * @returns A new Headers object with AT Protocol headers added
- */
-export function buildXrpcRequestHeaders(
-  options: XrpcRequestHeadersOptions,
-): Headers {
-  const headers = new Headers(options?.headers)
-
-  if (options.service && !headers.has('atproto-proxy')) {
-    headers.set('atproto-proxy', options.service)
-  }
-
-  if (options.labelers) {
-    headers.set(
-      'atproto-accept-labelers',
-      [...options.labelers, headers.get('atproto-accept-labelers')?.trim()]
-        .filter(Boolean)
-        .join(', '),
-    )
-  }
-
-  return headers
-}
-
-export function toReadableStream(
-  data: AsyncIterable<Uint8Array>,
-): ReadableStream<Uint8Array> {
-  // Use the native ReadableStream.from() if available.
-
-  /* v8 ignore next -- @preserve */
-  if ('from' in ReadableStream && typeof ReadableStream.from === 'function') {
-    return ReadableStream.from(data)
-  }
-
-  /* v8 ignore next -- @preserve */
-  return toReadableStreamPonyfill(data)
-}
-
-export function toReadableStreamPonyfill(
-  data: AsyncIterable<Uint8Array>,
-): ReadableStream<Uint8Array> {
-  let iterator: AsyncIterator<Uint8Array> | undefined
-  return new ReadableStream<Uint8Array>({
-    async pull(controller) {
-      try {
-        iterator ??= data[Symbol.asyncIterator]()
-        const result = await iterator!.next()
-        if (result.done) controller.close()
-        else controller.enqueue(result.value)
-      } catch (err) {
-        controller.error(err)
-        iterator = undefined
-      }
-    },
-    async cancel() {
-      await iterator?.return?.()
-      iterator = undefined
-    },
-  })
-}
-
-export type RecordKeyOptions<
-  T extends RecordSchema,
-  AlsoOptionalWhenRecordKeyIs extends LexiconRecordKey = never,
-> = T['key'] extends `literal:${string}` | AlsoOptionalWhenRecordKeyIs
-  ? { rkey?: InferRecordKey<T> }
-  : { rkey: InferRecordKey<T> }
-
-export function getDefaultRecordKey<const T extends RecordSchema>(
-  schema: T,
-): undefined | InferRecordKey<T> {
-  // Let the server generate the TID
-  if (schema.key === 'tid') return undefined
-  if (schema.key === 'any') return undefined
-
-  return getLiteralRecordKey(schema)
-}
-
-export function getLiteralRecordKey<const T extends RecordSchema>(
-  schema: T,
-): InferRecordKey<T> {
-  if (schema.key.startsWith('literal:')) {
-    return schema.key.slice(8) as InferRecordKey<T>
-  }
-
-  throw new TypeError(
-    `An "rkey" must be provided for record key type "${schema.key}" (${schema.$type})`,
-  )
-}

package/src/write-operation-builder.ts

@@ -1,110 +0,0 @@
-import {
-  $Typed,
-  InferInput,
-  Main,
-  RecordSchema,
-  Restricted,
-  getMain,
-} from '@atproto/lex-schema'
-import { com } from './lexicons/index.js'
-import {
-  RecordKeyOptions,
-  getDefaultRecordKey,
-  getLiteralRecordKey,
-} from './util.js'
-
-export type WriteOperation =
-  | $Typed<com.atproto.repo.applyWrites.Create>
-  | $Typed<com.atproto.repo.applyWrites.Update>
-  | $Typed<com.atproto.repo.applyWrites.Delete>
-
-export type WriteOperationCreateOptions<T extends RecordSchema> =
-  RecordKeyOptions<T, 'tid' | 'any'>
-
-export type WriteOperationUpdateOptions<T extends RecordSchema> =
-  RecordKeyOptions<T>
-
-export type WriteOperationDeleteOptions<T extends RecordSchema> =
-  RecordKeyOptions<T>
-
-export type WriteOperationsFactory = (
-  helper: WriteOperationHelper,
-) => Iterable<WriteOperation>
-
-export class WriteOperationHelper {
-  private constructor() {}
-
-  create<const T extends RecordSchema>(
-    ns: NonNullable<unknown> extends WriteOperationCreateOptions<T>
-      ? Main<T>
-      : Restricted<'This record type requires an "options" argument'>,
-    input: Omit<InferInput<T>, '$type'>,
-  ): $Typed<com.atproto.repo.applyWrites.Create>
-  create<const T extends RecordSchema>(
-    ns: Main<T>,
-    input: Omit<InferInput<T>, '$type'>,
-    options: WriteOperationCreateOptions<T>,
-  ): $Typed<com.atproto.repo.applyWrites.Create>
-  create<const T extends RecordSchema>(
-    ns: Main<T>,
-    input: Omit<InferInput<T>, '$type'>,
-    options: WriteOperationCreateOptions<T> = {} as WriteOperationCreateOptions<T>,
-  ): $Typed<com.atproto.repo.applyWrites.Create> {
-    const schema: T = getMain(ns)
-    const value = schema.build(input)
-    return com.atproto.repo.applyWrites.create.$build({
-      collection: schema.$type,
-      value,
-      rkey: options?.rkey ?? getDefaultRecordKey(schema),
-    })
-  }
-
-  update<const T extends RecordSchema>(
-    ns: NonNullable<unknown> extends WriteOperationUpdateOptions<T>
-      ? Main<T>
-      : Restricted<'This record type requires an "options" argument'>,
-    input: Omit<InferInput<T>, '$type'>,
-  ): $Typed<com.atproto.repo.applyWrites.Update>
-  update<const T extends RecordSchema>(
-    ns: Main<T>,
-    input: Omit<InferInput<T>, '$type'>,
-    options: WriteOperationUpdateOptions<T>,
-  ): $Typed<com.atproto.repo.applyWrites.Update>
-  update<const T extends RecordSchema>(
-    ns: Main<T>,
-    input: Omit<InferInput<T>, '$type'>,
-    options: WriteOperationUpdateOptions<T> = {} as WriteOperationUpdateOptions<T>,
-  ): $Typed<com.atproto.repo.applyWrites.Update> {
-    const schema: T = getMain(ns)
-    const value = schema.build(input)
-    return com.atproto.repo.applyWrites.update.$build({
-      collection: schema.$type,
-      value,
-      rkey: options?.rkey ?? getLiteralRecordKey(schema),
-    })
-  }
-
-  delete<const T extends RecordSchema>(
-    ns: NonNullable<unknown> extends WriteOperationDeleteOptions<T>
-      ? Main<T>
-      : Restricted<'This record type requires an "options" argument'>,
-  ): $Typed<com.atproto.repo.applyWrites.Delete>
-  delete<const T extends RecordSchema>(
-    ns: Main<T>,
-    options: WriteOperationDeleteOptions<T>,
-  ): $Typed<com.atproto.repo.applyWrites.Delete>
-  delete<const T extends RecordSchema>(
-    ns: Main<T>,
-    options: WriteOperationDeleteOptions<T> = {} as WriteOperationDeleteOptions<T>,
-  ): $Typed<com.atproto.repo.applyWrites.Delete> {
-    const schema: T = getMain(ns)
-    return com.atproto.repo.applyWrites.delete.$build({
-      collection: schema.$type,
-      rkey: options?.rkey ?? getLiteralRecordKey(schema),
-    })
-  }
-
-  static build(factory: WriteOperationsFactory): WriteOperation[] {
-    return Array.from(factory(new WriteOperationHelper()))
-  }
-}