@atproto/lex-schema 0.1.5 → 0.1.6

package/src/schema/token.test.ts

@@ -1,152 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { token } from './token.js'
-
-describe('TokenSchema', () => {
-  describe('basic validation', () => {
-    const schema = token('my.to.ken')
-
-    it('validates exact token match', () => {
-      expect(schema.safeParse('my.to.ken')).toMatchObject({
-        success: true,
-        value: 'my.to.ken',
-      })
-    })
-
-    it('rejects different strings', () => {
-      const result = schema.safeParse('other.to.ken')
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects similar strings with different case', () => {
-      const result = schema.safeParse('My.To.Ken')
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects partial matches', () => {
-      const result = schema.safeParse('my.to')
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects empty string', () => {
-      const result = schema.safeParse('')
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects symbols', () => {
-      const result = schema.safeParse(Symbol.for(schema.toString()))
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects functions', () => {
-      const result = schema.safeParse(() => schema)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects dates', () => {
-      const result = schema.safeParse(new Date())
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects regular expressions', () => {
-      const result = schema.safeParse(/mytoken/)
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('TokenSchema instance validation', () => {
-    const schema = token('my.to.ken')
-
-    it('accepts TokenSchema instance with same value', () => {
-      const otherInstance = token('my.to.ken')
-      const result = schema.safeParse(otherInstance)
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.value).toBe('my.to.ken')
-      }
-    })
-
-    it('rejects TokenSchema instance with different value', () => {
-      const otherInstance = token('other.to.ken')
-      const result = schema.safeParse(otherInstance)
-      expect(result.success).toBe(false)
-    })
-
-    it('accepts itself as input', () => {
-      expect(schema.safeParse(schema)).toMatchObject({
-        success: true,
-        value: 'my.to.ken',
-      })
-    })
-  })
-
-  describe('type validation', () => {
-    const schema = token('my.to.ken')
-
-    it('rejects null', () => {
-      const result = schema.safeParse(null)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects undefined', () => {
-      const result = schema.safeParse(undefined)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects numbers', () => {
-      const result = schema.safeParse(123)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects booleans', () => {
-      const result = schema.safeParse(true)
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects objects', () => {
-      const result = schema.safeParse({ token: 'mytoken' })
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects arrays', () => {
-      const result = schema.safeParse(['mytoken'])
-      expect(result.success).toBe(false)
-    })
-
-    it('rejects String objects', () => {
-      const result = schema.safeParse(new String('mytoken'))
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('serialization methods', () => {
-    const schema = token('my.to.ken', 'foo')
-
-    it('toJSON returns the token value', () => {
-      expect(schema.toJSON()).toBe('my.to.ken#foo')
-    })
-
-    it('toString returns the token value', () => {
-      expect(schema.toString()).toBe('my.to.ken#foo')
-    })
-
-    it('toJSON and toString return the same value', () => {
-      expect(schema.toJSON()).toBe(schema.toString())
-    })
-
-    it('serializes to primitive string in JSON', () => {
-      expect(JSON.stringify({ token: schema })).toBe(
-        '{"token":"my.to.ken#foo"}',
-      )
-    })
-  })
-
-  describe('value property', () => {
-    const schema = token('my.to.ken')
-
-    it('exposes the token value through serialization', () => {
-      // value is protected, so we verify it through toString/toJSON
-      expect(schema.toString()).toBe('my.to.ken')
-      expect(schema.toJSON()).toBe('my.to.ken')
-    })
-  })
-})

package/src/schema/token.ts

@@ -1,103 +0,0 @@
-import { $type, NsidString, Schema, ValidationContext } from '../core.js'
-
-/**
- * Schema for Lexicon token values.
- *
- * Tokens are named constants in Lexicon, identified by their NSID and hash.
- * They validate to their string value (e.g., 'app.bsky.feed.defs#requestLess').
- * TokenSchema instances can also be used as values themselves.
- *
- * @template TValue - The token string literal type
- *
- * @example
- * ```ts
- * const schema = new TokenSchema('app.bsky.feed.defs#requestLess')
- * schema.validate('app.bsky.feed.defs#requestLess') // success
- * ```
- */
-export class TokenSchema<
-  const TValue extends string = string,
-> extends Schema<TValue> {
-  readonly type = 'token' as const
-
-  constructor(readonly value: TValue) {
-    super()
-  }
-
-  get $token(): TValue {
-    return this.value
-  }
-
-  validateInContext(input: unknown, ctx: ValidationContext) {
-    if (input === this.value) {
-      return ctx.success(this.value)
-    }
-
-    // @NOTE: allow using the token instance itself (but convert to the actual
-    // token value)
-    if (
-      ctx.options.mode === 'parse' &&
-      input instanceof TokenSchema &&
-      input.value === this.value
-    ) {
-      return ctx.success(this.value)
-    }
-
-    if (typeof input !== 'string') {
-      return ctx.issueUnexpectedType(input, 'token')
-    }
-
-    return ctx.issueInvalidValue(input, [this.value])
-  }
-
-  // When using the TokenSchema instance as data, let's serialize it to the
-  // token value
-
-  toJSON(): string {
-    return this.value
-  }
-
-  toString(): string {
-    return this.value
-  }
-}
-
-/**
- * Creates a token schema for Lexicon named constants.
- *
- * Tokens are used in Lexicon as named constants or enum-like values.
- * The token instance can be used both as a schema validator and as
- * the token value itself (it serializes to its string value).
- *
- * @param nsid - The NSID part of the token
- * @param hash - The hash part of the token (defaults to 'main')
- * @returns A new {@link TokenSchema} instance
- *
- * @example
- * ```ts
- * // Define tokens
- * const requestLess = l.token('app.bsky.feed.defs', 'requestLess')
- * const requestMore = l.token('app.bsky.feed.defs', 'requestMore')
- *
- * // Use as a value
- * console.log(requestLess.toString()) // 'app.bsky.feed.defs#requestLess'
- *
- * // Use in union for validation
- * const feedbackSchema = l.union([requestLess, requestMore])
- *
- * // Validate
- * feedbackSchema.parse('app.bsky.feed.defs#requestLess') // success
- *
- * // Token instances can be used as values in other schemas
- * const feedbackRequest = l.object({
- *   feedback: requestLess, // Accepts the token value
- * })
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-export function token<
-  const N extends NsidString,
-  const H extends string = 'main',
->(nsid: N, hash: H = 'main' as H) {
-  return new TokenSchema($type(nsid, hash))
-}