@atproto/lex-schema 0.0.4 → 0.0.6

package/src/schema/boolean.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { BooleanSchema } from './boolean.js'
 
 describe('BooleanSchema', () => {

package/src/schema/boolean.ts

@@ -1,4 +1,4 @@
-import { Schema, ValidationResult, ValidatorContext } from '../validation.js'
+import { Schema, ValidationResult, ValidatorContext } from '../core.js'
 
 export type BooleanSchemaOptions = {
   default?: boolean

package/src/schema/bytes.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { BytesSchema } from './bytes.js'
 
 describe('BytesSchema', () => {

package/src/schema/bytes.ts

@@ -1,5 +1,5 @@
 import { asUint8Array } from '@atproto/lex-data'
-import { Schema, ValidationResult, ValidatorContext } from '../validation.js'
+import { Schema, ValidationResult, ValidatorContext } from '../core.js'
 
 export type BytesSchemaOptions = {
   minLength?: number

package/src/schema/cid.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { parseCid } from '@atproto/lex-data'
 import { CidSchema } from './cid.js'
 

package/src/schema/cid.ts

@@ -1,5 +1,5 @@
 import { Cid, isCid } from '@atproto/lex-data'
-import { Schema, ValidationResult, ValidatorContext } from '../validation.js'
+import { Schema, ValidationResult, ValidatorContext } from '../core.js'
 
 export type { Cid }
 

package/src/schema/custom.test.ts

@@ -1,4 +1,5 @@
-import { IssueCustom } from '../validation.js'
+import { describe, expect, it, vi } from 'vitest'
+import { IssueCustom } from '../core.js'
 import { CustomSchema } from './custom.js'
 
 describe('CustomSchema', () => {
@@ -32,7 +33,7 @@ describe('CustomSchema', () => {
       const result = schema.safeParse(123)
       expect(result.success).toBe(false)
       if (!result.success) {
-        expect(result.error.message).toContain('Custom error message')
+        expect(result.reason.message).toContain('Custom error message')
       }
     })
   })
@@ -143,7 +144,7 @@ describe('CustomSchema', () => {
       const result = schema.safeParse(123)
       expect(result.success).toBe(false)
       if (!result.success) {
-        expect(result.error.message).toContain('customField')
+        expect(result.reason.message).toContain('customField')
       }
     })
 
@@ -157,8 +158,8 @@ describe('CustomSchema', () => {
       const result = schema.safeParse(123)
       expect(result.success).toBe(false)
       if (!result.success) {
-        expect(result.error.message).toContain('nested')
-        expect(result.error.message).toContain('field')
+        expect(result.reason.message).toContain('nested')
+        expect(result.reason.message).toContain('field')
       }
     })
   })
@@ -371,7 +372,7 @@ describe('CustomSchema', () => {
 
   describe('assertion context behavior', () => {
     it('calls assertion with null as this', () => {
-      const assertion = jest.fn(function (
+      const assertion = vi.fn(function (
         this: unknown,
         input: unknown,
       ): input is string {
@@ -392,7 +393,7 @@ describe('CustomSchema', () => {
 
       expect(schema.safeParse('test')).toMatchObject({
         success: false,
-        error: {
+        reason: {
           issues: [
             { message: 'This is a custom issue' },
             { message: 'Must be a string' },

package/src/schema/custom.ts

@@ -5,7 +5,7 @@ import {
   Schema,
   ValidationResult,
   ValidatorContext,
-} from '../validation.js'
+} from '../core.js'
 
 export type CustomAssertionContext = {
   path: PropertyKey[]
@@ -33,6 +33,6 @@ export class CustomSchema<T = unknown> extends Schema<T> {
   ): ValidationResult<T> {
     if (this.assertion.call(null, input, ctx)) return ctx.success(input as T)
     const path = ctx.concatPath(this.path)
-    return ctx.failure(new IssueCustom(path, input, this.message))
+    return ctx.issue(new IssueCustom(path, input, this.message))
   }
 }

package/src/schema/dict.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { BooleanSchema } from './boolean.js'
 import { DictSchema } from './dict.js'
 import { EnumSchema } from './enum.js'

package/src/schema/dict.ts

@@ -5,7 +5,7 @@ import {
   ValidationResult,
   Validator,
   ValidatorContext,
-} from '../validation.js'
+} from '../core.js'
 
 export type DictSchemaOutput<
   KeySchema extends Validator<string>,

package/src/schema/discriminated-union.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { DiscriminatedUnionSchema } from './discriminated-union.js'
 import { EnumSchema } from './enum.js'
 import { IntegerSchema } from './integer.js'

package/src/schema/discriminated-union.ts

@@ -5,7 +5,7 @@ import {
   ValidationResult,
   Validator,
   ValidatorContext,
-} from '../validation.js'
+} from '../core.js'
 import { EnumSchema } from './enum.js'
 import { LiteralSchema } from './literal.js'
 import { ObjectSchema } from './object.js'

package/src/schema/enum.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { EnumSchema } from './enum.js'
 
 describe('EnumSchema', () => {

package/src/schema/enum.ts

@@ -1,4 +1,4 @@
-import { Schema, ValidationResult, ValidatorContext } from '../validation.js'
+import { Schema, ValidationResult, ValidatorContext } from '../core.js'
 
 export type EnumSchemaOptions<T extends null | string | number | boolean> = {
   default?: T

package/src/schema/integer.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { IntegerSchema } from './integer.js'
 
 describe('IntegerSchema', () => {

package/src/schema/integer.ts

@@ -1,4 +1,4 @@
-import { Schema, ValidationResult, ValidatorContext } from '../validation.js'
+import { Schema, ValidationResult, ValidatorContext } from '../core.js'
 
 export type IntegerSchemaOptions = {
   default?: number
@@ -32,8 +32,8 @@ export class IntegerSchema extends Schema<number> {
 }
 
 /**
- * Simple wrapper around {@link Number.isInteger} that acts as a type guard.
+ * Simple wrapper around {@link Number.isSafeInteger} that acts as a type guard.
  */
 function isInteger(input: unknown): input is number {
-  return Number.isInteger(input)
+  return Number.isSafeInteger(input)
 }

package/src/schema/intersection.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { BooleanSchema } from './boolean.js'
 import { DictSchema } from './dict.js'
 import { EnumSchema } from './enum.js'

package/src/schema/intersection.ts

@@ -1,10 +1,10 @@
-import { Simplify } from '../core.js'
 import {
   Infer,
   Schema,
+  Simplify,
   ValidationResult,
   ValidatorContext,
-} from '../validation.js'
+} from '../core.js'
 import { DictSchema } from './dict.js'
 import { ObjectSchema } from './object.js'
 

package/src/schema/literal.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { LiteralSchema } from './literal.js'
 
 describe('LiteralSchema', () => {

package/src/schema/literal.ts

@@ -1,4 +1,4 @@
-import { Schema, ValidationResult, ValidatorContext } from '../validation.js'
+import { Schema, ValidationResult, ValidatorContext } from '../core.js'
 
 export type LiteralSchemaOptions<T extends null | string | number | boolean> = {
   default?: T

package/src/schema/never.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { NeverSchema } from './never.js'
 
 describe('NeverSchema', () => {

package/src/schema/never.ts

@@ -1,4 +1,4 @@
-import { Schema, ValidationFailure, ValidatorContext } from '../validation.js'
+import { Schema, ValidationFailure, ValidatorContext } from '../core.js'
 
 export class NeverSchema extends Schema<never> {
   validateInContext(input: unknown, ctx: ValidatorContext): ValidationFailure {

package/src/schema/null.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { NullSchema } from './null.js'
 
 describe('NullSchema', () => {

package/src/schema/null.ts

@@ -1,4 +1,4 @@
-import { Schema, ValidationResult, ValidatorContext } from '../validation.js'
+import { Schema, ValidationResult, ValidatorContext } from '../core.js'
 
 export class NullSchema extends Schema<null> {
   constructor() {

package/src/schema/nullable.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { EnumSchema } from './enum.js'
 import { IntegerSchema } from './integer.js'
 import { NullableSchema } from './nullable.js'

package/src/schema/nullable.ts

@@ -3,7 +3,7 @@ import {
   ValidationResult,
   Validator,
   ValidatorContext,
-} from '../validation.js'
+} from '../core.js'
 
 export class NullableSchema<V> extends Schema<V | null> {
   constructor(readonly schema: Validator<V>) {

package/src/schema/object.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { EnumSchema } from './enum.js'
 import { IntegerSchema } from './integer.js'
 import { NullableSchema } from './nullable.js'

package/src/schema/object.ts

@@ -1,13 +1,13 @@
 import { isPlainObject } from '@atproto/lex-data'
-import { WithOptionalProperties } from '../core.js'
-import { lazyProperty } from '../util/lazy-property.js'
 import {
   Infer,
   Schema,
   ValidationResult,
   Validator,
   ValidatorContext,
-} from '../validation.js'
+  WithOptionalProperties,
+} from '../core.js'
+import { lazyProperty } from '../util/lazy-property.js'
 
 export type ObjectSchemaShape = Record<string, Validator>
 

package/src/schema/optional.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { BooleanSchema } from './boolean.js'
 import { IntegerSchema } from './integer.js'
 import { OptionalSchema } from './optional.js'

package/src/schema/optional.ts

@@ -3,7 +3,7 @@ import {
   ValidationResult,
   Validator,
   ValidatorContext,
-} from '../validation.js'
+} from '../core.js'
 
 export class OptionalSchema<V> extends Schema<V | undefined> {
   constructor(readonly schema: Validator<V>) {

package/src/schema/params.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { ArraySchema } from './array.js'
 import { BooleanSchema } from './boolean.js'
 import { IntegerSchema } from './integer.js'

package/src/schema/params.ts

@@ -1,13 +1,13 @@
 import { isPlainObject } from '@atproto/lex-data'
-import { WithOptionalProperties } from '../core.js'
-import { lazyProperty } from '../util/lazy-property.js'
 import {
   Infer,
   Schema,
   ValidationResult,
   Validator,
   ValidatorContext,
-} from '../validation.js'
+  WithOptionalProperties,
+} from '../core.js'
+import { lazyProperty } from '../util/lazy-property.js'
 import { Param, ParamScalar, paramSchema } from './_parameters.js'
 import { StringSchema } from './string.js'
 
@@ -18,13 +18,6 @@ export type ParamsSchemaOutput<Shape extends ParamsSchemaShape> =
     [K in keyof Shape]: Infer<Shape[K]>
   }>
 
-export type InferParamsSchema<T> =
-  T extends ParamsSchema<infer P>
-    ? NonNullable<unknown> extends ParamsSchemaOutput<P>
-      ? ParamsSchemaOutput<P> | undefined // Allow undefined if all params are optional
-      : ParamsSchemaOutput<P>
-    : never
-
 export class ParamsSchema<
   const Shape extends ParamsSchemaShape = ParamsSchemaShape,
 > extends Schema<ParamsSchemaOutput<Shape>> {

package/src/schema/payload.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from 'vitest'
 import { IntegerSchema } from './integer.js'
 import { ObjectSchema } from './object.js'
 import { Payload } from './payload.js'

package/src/schema/payload.ts

@@ -1,53 +1,86 @@
 import { LexValue } from '@atproto/lex-data'
-import { Infer, Validator } from '../validation.js'
+import { Infer, Schema } from '../core.js'
 
-export type LexBody<E extends string = any> = E extends `text/${string}`
-  ? string // Text encodings always yield string bodies
-  : E extends 'application/json'
-    ? LexValue
-    : Uint8Array
+export type InferPayload<
+  P extends Payload,
+  B,
+> = P['encoding'] extends infer E extends string
+  ? {
+      encoding: SchemaEncodingToDataEncoding<E>
+      body: InferPayloadBody<P, B>
+    }
+  : void | undefined
+
+export type SchemaEncodingToDataEncoding<E extends string> = E extends '*/*'
+  ? `${string}/${string}`
+  : E extends `${infer T extends string}/*`
+    ? `${T}/${string}`
+    : E
 
 export type InferPayloadEncoding<P extends Payload> =
-  P extends Payload<infer E, any> ? E : undefined
-
-export type InferPayloadBody<P extends Payload> =
-  P extends Payload<any, infer S>
-    ? S extends Validator
-      ? Infer<S>
-      : P extends Payload<infer E extends string>
-        ? LexBody<E>
-        : undefined
+  P['encoding'] extends string
+    ? SchemaEncodingToDataEncoding<P['encoding']>
     : undefined
 
-export type PayloadOutput<
-  E extends string | undefined = any,
-  S extends Validator | undefined = any,
-> = E extends string
-  ? S extends Validator
-    ? {
-        encoding: E
-        body: Infer<S>
-      }
-    : {
-        encoding: E
-        body: LexBody<E>
-      }
-  : void
-
-export type PayloadBody<E extends string | undefined> = E extends undefined
+export type InferPayloadBody<
+  P extends Payload,
+  B,
+> = P['encoding'] extends undefined
+  ? undefined // No encoding, no payload
+  : P['schema'] extends Schema
+    ? Infer<P['schema']>
+    : P['encoding'] extends `application/json`
+      ? LexValue
+      : B
+
+export type PayloadSchema<E extends string | undefined> = E extends undefined
   ? undefined
-  : Validator | undefined
+  : Schema | undefined
 
 export class Payload<
   const Encoding extends string | undefined = string | undefined,
-  const Body extends PayloadBody<Encoding> = PayloadBody<Encoding>,
+  const Schema extends PayloadSchema<Encoding> = PayloadSchema<Encoding>,
 > {
   constructor(
     readonly encoding: Encoding,
-    readonly schema: Body,
+    readonly schema: Schema,
   ) {
     if (encoding === undefined && schema !== undefined) {
       throw new TypeError('schema cannot be defined when encoding is undefined')
     }
   }
+
+  /**
+   * Checks whether the given content-type matches the expected payload schema's
+   * encoding.
+   */
+  matchesEncoding(contentType: string | undefined): boolean {
+    const mime = contentType?.split(';', 1)[0].trim()
+
+    const { encoding } = this
+
+    // Handle undefined cases
+    if (encoding === undefined) {
+      // Expecting no body
+      return mime === undefined
+    } else if (mime === undefined) {
+      // Expecting a body, but got no content-type
+      return false
+    }
+
+    if (encoding === '*/*') {
+      return true
+    }
+
+    if (encoding.endsWith('/*')) {
+      return mime.startsWith(encoding.slice(0, -1))
+    }
+
+    // Invalid: Lexicon can only specify "*/*" or "type/*" wildcards
+    if (encoding.includes('*')) {
+      return false
+    }
+
+    return encoding === mime
+  }
 }