@atproto/lex-schema 0.1.5 → 0.1.6

package/src/helpers.ts

@@ -1,222 +0,0 @@
-import { LexErrorData } from '@atproto/lex-data'
-import {
-  AtIdentifierString,
-  InferOutput,
-  NsidString,
-  RecordKeyValue,
-  Restricted,
-  Schema,
-  assertAtIdentifierString,
-  assertStringFormat,
-} from './core.js'
-import {
-  InferPayload,
-  InferPayloadBody,
-  InferPayloadEncoding,
-  InferRecordKey,
-  Procedure,
-  Query,
-  RecordSchema,
-  Subscription,
-  object,
-  optional,
-  regexp,
-  string,
-} from './schema.js'
-
-export type Main<T> = T | { main: T }
-
-export function getMain<T extends object>(ns: Main<T>): T {
-  return 'main' in ns ? ns.main : ns
-}
-
-/**
- * Every XRPC implementation should translate `application/json` and `text/*`
- * payloads into their native equivalent ({@link LexValue} or string). Binary
- * data payloads, however, can be represented differently depending on the
- * environment and use case (e.g. `Uint8Array`, `Blob`, `Buffer`,
- * `ReadableStream`, etc.). This type is a placeholder to represent binary data
- * when not explicitly provided.
- */
-export type BinaryData = Restricted<'Binary data'>
-
-export type InferMethodParams<
-  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
-> =
-  M extends Procedure<any, infer TParams, any, any, any>
-    ? InferOutput<TParams>
-    : M extends Query<any, infer TParams, any, any>
-      ? InferOutput<TParams>
-      : M extends Subscription<any, infer TParams, any, any>
-        ? InferOutput<TParams>
-        : never
-
-export type InferMethodInput<
-  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
-  B = BinaryData,
-> =
-  M extends Procedure<any, any, infer TInput, any, any>
-    ? InferPayload<TInput, B>
-    : undefined
-
-export type InferMethodInputBody<
-  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
-  B = BinaryData,
-> =
-  M extends Procedure<any, any, infer TInput, any, any>
-    ? InferPayloadBody<TInput, B>
-    : undefined
-
-export type InferMethodInputEncoding<
-  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
-> =
-  M extends Procedure<any, any, infer TInput, any, any>
-    ? InferPayloadEncoding<TInput>
-    : undefined
-
-export type InferMethodOutput<
-  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
-  B = BinaryData,
-> =
-  M extends Procedure<any, any, any, infer TOutput, any>
-    ? InferPayload<TOutput, B>
-    : M extends Query<any, any, infer TOutput, any>
-      ? InferPayload<TOutput, B>
-      : undefined
-
-export type InferMethodOutputBody<
-  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
-  B = BinaryData,
-> =
-  M extends Procedure<any, any, any, infer TOutput, any>
-    ? InferPayloadBody<TOutput, B>
-    : M extends Query<any, any, infer TOutput, any>
-      ? InferPayloadBody<TOutput, B>
-      : undefined
-
-export type InferMethodOutputEncoding<
-  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
-> =
-  M extends Procedure<any, any, any, infer TOutput, any>
-    ? InferPayloadEncoding<TOutput>
-    : M extends Query<any, any, infer TOutput, any>
-      ? InferPayloadEncoding<TOutput>
-      : undefined
-
-export type InferMethodMessage<
-  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
-> =
-  M extends Subscription<any, any, infer TMessage, any>
-    ? InferOutput<TMessage>
-    : undefined
-
-export type InferMethodError<
-  //
-  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
-> = M extends { errors: readonly (infer E extends string)[] } ? E : never
-
-/**
- * @see {@link https://atproto.com/specs/xrpc#error-responses}
- */
-export const lexErrorDataSchema = object({
-  // type name of the error (generic ASCII constant, no whitespace)
-  error: regexp(/^[\w_-]+$/, 'Expected ASCII constant with no whitespace'),
-  // description of the error, appropriate for display to humans
-  message: optional(string()),
-}) satisfies Schema<LexErrorData>
-
-/**
- * Helper function to construct AT Protocol URIs with compile-time & runtime
- * validation of their components. This function supports different use cases,
- * including constructing URIs from raw strings or from RecordSchema instances,
- * ensuring that the resulting URI adheres to the expected format.
- *
- * @throws {TypeError} If the arguments do not match the interface
- * @throws {Error} If AT-URI components are invalid
- *
- * @example
- * ```typescript
- * import { atUri } from '@atproto/lex'
- * import { app } from '#/lexicons/index.js'
- *
- * // Constructing a URI from raw components
- * const uri1 = atUri('did:example:123', 'app.bsky.feed.post', 'my-post')
- *
- * // Constructing a URI from a RecordSchema instance
- * const uri2 = atUri('did:example:123', app.bsky.feed.post, 'my-post')
- *
- * // Literal rkey can be omitted
- * const uri3 = atUri('did:example:123', app.bsky.actor.profile) // rkey 'self' is implied
- *
- * // Invalid URIs will throw errors
- * atUri('invalid authority', 'app.bsky.feed.post', 'my-post') // throws
- * atUri('did:example:123', 'invalid collection', 'my-post') // throws
- * atUri('did:example:123', 'app.bsky.feed.post', '..') // throws
- * ```
- */
-export function atUri<const TAuthority extends AtIdentifierString>(
-  authority: TAuthority,
-): `at://${TAuthority}`
-export function atUri<
-  const TAuthority extends AtIdentifierString,
-  const TCollection extends NsidString,
-  const TRecordKey extends RecordKeyValue,
->(
-  authority: TAuthority,
-  nsid: TCollection,
-  rkey: TRecordKey extends '..' | '.' ? never : TRecordKey,
-): `at://${TAuthority}/${TCollection}/${TRecordKey}`
-export function atUri<
-  const TAuthority extends AtIdentifierString,
-  const TRecord extends RecordSchema,
->(
-  authority: TAuthority,
-  record: TRecord['key'] extends `literal:${string}` ? Main<TRecord> : never,
-): `at://${TAuthority}/${TRecord['$type']}/${InferRecordKey<TRecord>}`
-export function atUri<
-  const TAuthority extends AtIdentifierString,
-  const TRecord extends RecordSchema,
-  const TRecordKey extends InferRecordKey<TRecord>,
->(
-  authority: TAuthority,
-  record: Main<TRecord>,
-  rkey: TRecordKey extends '..' | '.' ? never : TRecordKey,
-): `at://${TAuthority}/${TRecord['$type']}/${TRecordKey}`
-export function atUri(
-  authority: AtIdentifierString,
-  record?: string | Main<RecordSchema>,
-  rkey?: string,
-) {
-  /**
-   * @NOTE because we are encoding potentially untrusted input into a URI, we
-   * validate the input against the AT Protocol constraints, ensuring that no
-   * invalid URIs can be generated.
-   */
-  switch (typeof record) {
-    case 'undefined': {
-      assertAtIdentifierString(authority)
-      return `at://${authority}`
-    }
-
-    case 'string': {
-      if (!rkey) {
-        throw new TypeError('Record key is required when record is a string')
-      }
-      assertAtIdentifierString(authority)
-      assertStringFormat(record, 'nsid')
-      assertStringFormat(rkey, 'record-key')
-      return `at://${authority}/${record}/${rkey}`
-    }
-
-    default: {
-      // @NOTE The use of a schema assumes that the collection ($type) is a
-      // valid NSID that can safely be included in the URI without additional
-      // checks.
-      assertAtIdentifierString(authority)
-      const schema = getMain(record)
-      // @NOTE parsing will apply defaults, so that literal keys will be
-      // properly validated and included in the URI.
-      return `at://${authority}/${schema.$type}/${schema.keySchema.parse(rkey)}`
-    }
-  }
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-import * as l from './external.js'
-export * from './external.js'
-export { l }

package/src/schema/array.test.ts

@@ -1,251 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { array } from './array.js'
-import { integer } from './integer.js'
-import { object } from './object.js'
-import { string } from './string.js'
-
-describe('ArraySchema', () => {
-  describe('validation', () => {
-    it('validates arrays with string items', () => {
-      const schema = array(string())
-      const result = schema.safeValidate(['hello', 'world'])
-      expect(result).toMatchObject({ success: true })
-    })
-
-    it('validates arrays with integer items', () => {
-      const schema = array(integer())
-      const result = schema.safeValidate([1, 2, 3])
-      expect(result).toMatchObject({ success: true })
-    })
-
-    it('validates arrays with object items', () => {
-      const schema = array(
-        object({
-          name: string(),
-          age: integer(),
-        }),
-      )
-      const result = schema.safeValidate([
-        { name: 'Alice', age: 30 },
-        { name: 'Bob', age: 25 },
-      ])
-      expect(result).toMatchObject({ success: true })
-    })
-
-    it('validates empty arrays', () => {
-      const schema = array(string())
-      const result = schema.safeValidate([])
-      expect(result).toMatchObject({ success: true })
-    })
-
-    it('rejects non-array values', () => {
-      const schema = array(string())
-      const result = schema.safeValidate('not an array')
-      expect(result).toMatchObject({ success: false })
-    })
-
-    it('rejects null values', () => {
-      const schema = array(string())
-      const result = schema.safeValidate(null)
-      expect(result).toMatchObject({ success: false })
-    })
-
-    it('rejects undefined values', () => {
-      const schema = array(string())
-      const result = schema.safeValidate(undefined)
-      expect(result).toMatchObject({ success: false })
-    })
-
-    it('rejects objects that look like arrays', () => {
-      const schema = array(string())
-      const result = schema.safeValidate({ 0: 'a', 1: 'b', length: 2 })
-      expect(result).toMatchObject({ success: false })
-    })
-
-    it('rejects arrays with invalid items', () => {
-      const schema = array(integer())
-      const result = schema.safeValidate([1, 2, 'three'])
-      expect(result).toMatchObject({ success: false })
-    })
-
-    it('rejects arrays with some invalid items', () => {
-      const schema = array(string())
-      const result = schema.safeValidate(['valid', null, 'also valid'])
-      expect(result).toMatchObject({ success: false })
-    })
-
-    it('rejects single values', () => {
-      const schema = array(string())
-      const result = schema.safeValidate(3)
-      expect(result).toMatchObject({
-        success: false,
-        reason: expect.objectContaining({
-          message: expect.stringContaining(
-            'Expected array value type (got 3) at $',
-          ),
-        }),
-      })
-    })
-  })
-
-  describe('minLength constraint', () => {
-    it('validates arrays meeting minLength', () => {
-      const schema = array(string(), { minLength: 2 })
-      const result = schema.safeParse(['a', 'b'])
-      expect(result).toMatchObject({ success: true })
-    })
-
-    it('validates arrays exceeding minLength', () => {
-      const schema = array(string(), { minLength: 2 })
-      const result = schema.safeParse(['a', 'b', 'c'])
-      expect(result).toMatchObject({ success: true })
-    })
-
-    it('rejects arrays below minLength', () => {
-      const schema = array(string(), { minLength: 3 })
-      const result = schema.safeParse(['a', 'b'])
-      expect(result).toMatchObject({ success: false })
-    })
-
-    it('rejects empty arrays when minLength is set', () => {
-      const schema = array(string(), { minLength: 1 })
-      const result = schema.safeParse([])
-      expect(result).toMatchObject({ success: false })
-    })
-
-    it('validates empty arrays when minLength is 0', () => {
-      const schema = array(string(), { minLength: 0 })
-      const result = schema.safeParse([])
-      expect(result).toMatchObject({ success: true })
-    })
-  })
-
-  describe('maxLength constraint', () => {
-    it('validates arrays meeting maxLength', () => {
-      const schema = array(string(), { maxLength: 3 })
-      const result = schema.safeParse(['a', 'b', 'c'])
-      expect(result).toMatchObject({ success: true })
-    })
-
-    it('validates arrays below maxLength', () => {
-      const schema = array(string(), { maxLength: 3 })
-      const result = schema.safeParse(['a', 'b'])
-      expect(result).toMatchObject({ success: true })
-    })
-
-    it('rejects arrays exceeding maxLength', () => {
-      const schema = array(string(), { maxLength: 2 })
-      const result = schema.safeParse(['a', 'b', 'c'])
-      expect(result).toMatchObject({ success: false })
-    })
-
-    it('validates empty arrays with maxLength', () => {
-      const schema = array(string(), { maxLength: 5 })
-      const result = schema.safeParse([])
-      expect(result).toMatchObject({ success: true })
-    })
-
-    it('rejects empty arrays when maxLength is 0', () => {
-      const schema = array(string(), { maxLength: 0 })
-      const result = schema.safeParse(['a'])
-      expect(result).toMatchObject({ success: false })
-    })
-
-    it('validates empty arrays when maxLength is 0', () => {
-      const schema = array(string(), { maxLength: 0 })
-      const result = schema.safeParse([])
-      expect(result).toMatchObject({ success: true })
-    })
-  })
-
-  describe('minLength and maxLength together', () => {
-    it('validates arrays within range', () => {
-      const schema = array(string(), {
-        minLength: 2,
-        maxLength: 4,
-      })
-      const result = schema.safeParse(['a', 'b', 'c'])
-      expect(result).toMatchObject({ success: true })
-    })
-
-    it('validates arrays at min boundary', () => {
-      const schema = array(string(), {
-        minLength: 2,
-        maxLength: 4,
-      })
-      const result = schema.safeParse(['a', 'b'])
-      expect(result).toMatchObject({ success: true })
-    })
-
-    it('validates arrays at max boundary', () => {
-      const schema = array(string(), {
-        minLength: 2,
-        maxLength: 4,
-      })
-      const result = schema.safeParse(['a', 'b', 'c', 'd'])
-      expect(result).toMatchObject({ success: true })
-    })
-
-    it('rejects arrays below minLength', () => {
-      const schema = array(string(), {
-        minLength: 2,
-        maxLength: 4,
-      })
-      const result = schema.safeParse(['a'])
-      expect(result).toMatchObject({ success: false })
-    })
-
-    it('rejects arrays above maxLength', () => {
-      const schema = array(string(), {
-        minLength: 2,
-        maxLength: 4,
-      })
-      const result = schema.safeParse(['a', 'b', 'c', 'd', 'e'])
-      expect(result).toMatchObject({ success: false })
-    })
-
-    it('validates single-length range', () => {
-      const schema = array(string(), {
-        minLength: 3,
-        maxLength: 3,
-      })
-      const result = schema.safeParse(['a', 'b', 'c'])
-      expect(result).toMatchObject({ success: true })
-    })
-
-    it('rejects arrays not matching exact length', () => {
-      const schema = array(string(), {
-        minLength: 3,
-        maxLength: 3,
-      })
-      const result = schema.safeParse(['a', 'b'])
-      expect(result).toMatchObject({ success: false })
-    })
-  })
-
-  describe('nested arrays', () => {
-    it('validates arrays of arrays', () => {
-      const schema = array(array(string()))
-      const result = schema.safeParse([
-        ['a', 'b'],
-        ['c', 'd'],
-      ])
-      expect(result).toMatchObject({ success: true })
-    })
-
-    it('rejects invalid nested arrays', () => {
-      const schema = array(array(integer()))
-      const result = schema.safeParse([
-        [1, 2],
-        [3, 'four'],
-      ])
-      expect(result).toMatchObject({ success: false })
-    })
-
-    it('validates deeply nested arrays', () => {
-      const schema = array(array(array(integer())))
-      const result = schema.safeParse([[[1, 2], [3]], [[4, 5, 6]]])
-      expect(result).toMatchObject({ success: true })
-    })
-  })
-})

package/src/schema/array.ts

@@ -1,126 +0,0 @@
-import {
-  InferInput,
-  InferOutput,
-  Schema,
-  ValidationContext,
-  Validator,
-} from '../core.js'
-import { memoizedTransformer } from '../util/memoize.js'
-
-/**
- * Configuration options for array schema validation.
- *
- * @property minLength - Minimum number of items in the array
- * @property maxLength - Maximum number of items in the array
- */
-export type ArraySchemaOptions = {
-  minLength?: number
-  maxLength?: number
-}
-
-/**
- * Schema for validating arrays where all items match a given schema.
- *
- * Validates that the input is an array, checks length constraints, and
- * validates each item against the provided item schema.
- *
- * @template TItem - The validator type for array items
- *
- * @example
- * ```ts
- * const schema = new ArraySchema(l.string(), { maxLength: 10 })
- * const result = schema.validate(['a', 'b', 'c'])
- * ```
- */
-export class ArraySchema<const TItem extends Validator> extends Schema<
-  Array<InferInput<TItem>>,
-  Array<InferOutput<TItem>>
-> {
-  readonly type = 'array' as const
-
-  constructor(
-    readonly validator: TItem,
-    readonly options: ArraySchemaOptions = {},
-  ) {
-    super()
-  }
-
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    if (!Array.isArray(input)) {
-      return ctx.issueUnexpectedType(input, 'array')
-    }
-
-    const { minLength, maxLength } = this.options
-
-    if (minLength != null && input.length < minLength) {
-      return ctx.issueTooSmall(input, 'array', minLength, input.length)
-    }
-
-    if (maxLength != null && input.length > maxLength) {
-      return ctx.issueTooBig(input, 'array', maxLength, input.length)
-    }
-
-    let copy: undefined | unknown[]
-
-    for (let i = 0; i < input.length; i++) {
-      const result = ctx.validateChild(input, i, this.validator)
-      if (!result.success) return result
-
-      if (result.value !== input[i]) {
-        if (ctx.options.mode === 'validate') {
-          // In "validate" mode, we can't modify the input, so we issue an error
-          return ctx.issueInvalidPropertyValue(input, i, [result.value])
-        }
-
-        // Copy on write (but only if we did not already make a copy)
-        copy ??= Array.from(input)
-        copy[i] = result.value
-      }
-    }
-
-    return ctx.success(copy ?? input)
-  }
-}
-
-/**
- * Creates an array schema that validates each item against the provided schema.
- *
- * @param items - Schema to validate each array item against
- * @param options - Optional length constraints
- * @returns A new {@link ArraySchema} instance
- *
- * @example
- * ```ts
- * // Array of strings
- * const tagsSchema = l.array(l.string())
- *
- * // Array with length constraints
- * const limitedSchema = l.array(l.integer(), { maxLength: 100 })
- *
- * // Array of objects
- * const usersSchema = l.array(l.object({
- *   name: l.string(),
- *   age: l.integer(),
- * }))
- *
- * // Non-empty array
- * const nonEmptySchema = l.array(l.string(), { minLength: 1 })
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-function arraySchema<const TValidator extends Validator>(
-  items: TValidator,
-  options?: ArraySchemaOptions,
-): ArraySchema<TValidator>
-function arraySchema<
-  const TValue,
-  const TValidator extends Validator<TValue> = Validator<TValue>,
->(items: TValidator, options?: ArraySchemaOptions): ArraySchema<TValidator>
-function arraySchema<const TValidator extends Validator>(
-  items: TValidator,
-  options?: ArraySchemaOptions,
-) {
-  return new ArraySchema<TValidator>(items, options)
-}
-
-export const array = /*#__PURE__*/ memoizedTransformer(arraySchema)