@atproto/lex-schema 0.0.8 → 0.0.10

package/src/schema/typed-object.test.ts

@@ -1,20 +1,23 @@
 import { describe, expect, it } from 'vitest'
-import { EnumSchema } from './enum.js'
-import { IntegerSchema } from './integer.js'
-import { NullableSchema } from './nullable.js'
-import { ObjectSchema } from './object.js'
-import { OptionalSchema } from './optional.js'
-import { StringSchema } from './string.js'
-import { TypedObjectSchema } from './typed-object.js'
+import { Infer, Unknown$Type, Unknown$TypedObject } from '../core.js'
+import { enumSchema } from './enum.js'
+import { integer } from './integer.js'
+import { nullable } from './nullable.js'
+import { object } from './object.js'
+import { optional } from './optional.js'
+import { string } from './string.js'
+import { typedObject } from './typed-object.js'
 
 describe('TypedObjectSchema', () => {
-  const schema = new TypedObjectSchema(
-    'app.bsky.feed.post#main',
-    new ObjectSchema({
-      text: new StringSchema({}),
-      likes: new OptionalSchema(new IntegerSchema({})),
+  const schema = typedObject(
+    'app.bsky.feed.post',
+    'main',
+    object({
+      text: string(),
+      likes: optional(integer()),
     }),
   )
+  type Schema = Infer<typeof schema>
 
   describe('basic validation', () => {
     it('validates plain objects without $type', () => {
@@ -27,7 +30,7 @@ describe('TypedObjectSchema', () => {
 
     it('validates plain objects with matching $type', () => {
       const result = schema.safeParse({
-        $type: 'app.bsky.feed.post#main',
+        $type: 'app.bsky.feed.post',
         text: 'Hello world',
         likes: 5,
       })
@@ -36,7 +39,7 @@ describe('TypedObjectSchema', () => {
 
     it('rejects objects with non-matching $type', () => {
       const result = schema.safeParse({
-        $type: 'app.bsky.feed.like#main',
+        $type: 'app.bsky.feed.like',
         text: 'Hello world',
         likes: 5,
       })
@@ -142,15 +145,15 @@ describe('TypedObjectSchema', () => {
 
     it('rejects object $type', () => {
       const result = schema.safeParse({
-        $type: { type: 'app.bsky.feed.post#main' },
+        $type: { type: 'app.bsky.feed.post' },
         text: 'Hello world',
       })
       expect(result.success).toBe(false)
     })
 
-    it('rejects partial match $type', () => {
+    it('rejects non-normalized $type', () => {
       const result = schema.safeParse({
-        $type: 'app.bsky.feed.post',
+        $type: 'app.bsky.feed.post#main',
         text: 'Hello world',
       })
       expect(result.success).toBe(false)
@@ -185,12 +188,12 @@ describe('TypedObjectSchema', () => {
     })
 
     it('returns true for objects with matching $type', () => {
-      const obj = { $type: 'app.bsky.feed.post#main', text: 'Hello' }
+      const obj = { $type: 'app.bsky.feed.post', text: 'Hello' }
       expect(schema.isTypeOf(obj)).toBe(true)
     })
 
     it('returns false for objects with non-matching $type', () => {
-      const obj = { $type: 'app.bsky.feed.like#main', text: 'Hello' }
+      const obj = { $type: 'app.bsky.feed.like', text: 'Hello' }
       expect(schema.isTypeOf(obj)).toBe(false)
     })
 
@@ -203,6 +206,30 @@ describe('TypedObjectSchema', () => {
       const obj = { $type: 123, text: 'Hello' }
       expect(schema.isTypeOf(obj)).toBe(false)
     })
+
+    it('properly discriminates Unknown$TypeObject', () => {
+      function foo(value: Unknown$TypedObject | Schema) {
+        if (schema.isTypeOf(value)) {
+          value.text
+        } else {
+          // @ts-expect-error
+          value.text
+        }
+      }
+
+      foo({
+        $type: 'app.bsky.feed.post',
+        text: 'aze',
+        // @ts-expect-error
+        unknownProperty: 'should not be allowed !',
+      })
+
+      foo({
+        $type: 'blah' as Unknown$Type,
+        // @ts-expect-error
+        unknownProperty: 'should not be allowed !',
+      })
+    })
   })
 
   describe('$isTypeOf method', () => {
@@ -212,19 +239,19 @@ describe('TypedObjectSchema', () => {
     })
 
     it('returns true for objects with matching $type', () => {
-      const obj = { $type: 'app.bsky.feed.post#main', text: 'Hello' }
+      const obj = { $type: 'app.bsky.feed.post', text: 'Hello' }
       expect(schema.$isTypeOf(obj)).toBe(true)
     })
 
     it('returns false for objects with non-matching $type', () => {
-      const obj = { $type: 'app.bsky.feed.like#main', text: 'Hello' }
+      const obj = { $type: 'app.bsky.feed.like', text: 'Hello' }
       expect(schema.$isTypeOf(obj)).toBe(false)
     })
 
     it('behaves identically to isTypeOf', () => {
       const obj1 = { text: 'Hello' }
-      const obj2 = { $type: 'app.bsky.feed.post#main', text: 'Hello' }
-      const obj3 = { $type: 'app.bsky.feed.like#main', text: 'Hello' }
+      const obj2 = { $type: 'app.bsky.feed.post', text: 'Hello' }
+      const obj3 = { $type: 'app.bsky.feed.like', text: 'Hello' }
 
       expect(schema.$isTypeOf(obj1)).toBe(schema.isTypeOf(obj1))
       expect(schema.$isTypeOf(obj2)).toBe(schema.isTypeOf(obj2))
@@ -239,7 +266,7 @@ describe('TypedObjectSchema', () => {
       expect(result).toEqual({
         text: 'Hello world',
         likes: 5,
-        $type: 'app.bsky.feed.post#main',
+        $type: 'app.bsky.feed.post',
       })
     })
 
@@ -248,7 +275,7 @@ describe('TypedObjectSchema', () => {
       const result = schema.build(input)
       expect(result).toEqual({
         text: 'Hello world',
-        $type: 'app.bsky.feed.post#main',
+        $type: 'app.bsky.feed.post',
       })
     })
 
@@ -259,7 +286,7 @@ describe('TypedObjectSchema', () => {
         text: 'Hello',
         likes: 10,
         extra: 'value',
-        $type: 'app.bsky.feed.post#main',
+        $type: 'app.bsky.feed.post',
       })
     })
 
@@ -271,13 +298,10 @@ describe('TypedObjectSchema', () => {
     })
 
     it('adds $type to empty object', () => {
-      const emptySchema = new TypedObjectSchema(
-        'app.bsky.test#main',
-        new ObjectSchema({}),
-      )
+      const emptySchema = typedObject('app.bsky.test', 'main', object({}))
       const input = {}
       const result = emptySchema.build(input)
-      expect(result).toEqual({ $type: 'app.bsky.test#main' })
+      expect(result).toEqual({ $type: 'app.bsky.test' })
     })
   })
 
@@ -288,7 +312,7 @@ describe('TypedObjectSchema', () => {
       expect(result).toEqual({
         text: 'Hello world',
         likes: 5,
-        $type: 'app.bsky.feed.post#main',
+        $type: 'app.bsky.feed.post',
       })
     })
 
@@ -309,15 +333,14 @@ describe('TypedObjectSchema', () => {
   })
 
   describe('with complex nested schemas', () => {
-    const complexSchema = new TypedObjectSchema(
-      'app.bsky.actor.profile#main',
-      new ObjectSchema({
-        displayName: new StringSchema({}),
-        bio: new OptionalSchema(new StringSchema({ maxLength: 256 })),
-        followerCount: new OptionalSchema(new IntegerSchema({ minimum: 0 })),
-        verified: new OptionalSchema(
-          new NullableSchema(new EnumSchema([true, false])),
-        ),
+    const complexSchema = typedObject(
+      'app.bsky.actor.profile',
+      'main',
+      object({
+        displayName: string(),
+        bio: optional(string({ maxLength: 256 })),
+        followerCount: optional(integer({ minimum: 0 })),
+        verified: optional(nullable(enumSchema([true, false]))),
       }),
     )
 
@@ -357,7 +380,7 @@ describe('TypedObjectSchema', () => {
 
     it('validates with matching $type', () => {
       const result = complexSchema.safeParse({
-        $type: 'app.bsky.actor.profile#main',
+        $type: 'app.bsky.actor.profile',
         displayName: 'John Doe',
       })
       expect(result.success).toBe(true)
@@ -365,7 +388,7 @@ describe('TypedObjectSchema', () => {
 
     it('rejects with non-matching $type', () => {
       const result = complexSchema.safeParse({
-        $type: 'app.bsky.feed.post#main',
+        $type: 'app.bsky.feed.post',
         displayName: 'John Doe',
       })
       expect(result.success).toBe(false)
@@ -374,18 +397,20 @@ describe('TypedObjectSchema', () => {
 
   describe('with different $type formats', () => {
     it('validates with main type', () => {
-      const mainSchema = new TypedObjectSchema(
-        'app.bsky.feed.post#main',
-        new ObjectSchema({ text: new StringSchema({}) }),
+      const mainSchema = typedObject(
+        'app.bsky.feed.post',
+        'main',
+        object({ text: string() }),
       )
       const result = mainSchema.safeParse({ text: 'Hello' })
       expect(result.success).toBe(true)
     })
 
     it('validates with custom fragment', () => {
-      const fragmentSchema = new TypedObjectSchema(
-        'app.bsky.feed.post#reply',
-        new ObjectSchema({ text: new StringSchema({}) }),
+      const fragmentSchema = typedObject(
+        'app.bsky.feed.post',
+        'reply',
+        object({ text: string() }),
       )
       const result = fragmentSchema.safeParse({
         $type: 'app.bsky.feed.post#reply',
@@ -395,9 +420,10 @@ describe('TypedObjectSchema', () => {
     })
 
     it('distinguishes between different fragments', () => {
-      const replySchema = new TypedObjectSchema(
-        'app.bsky.feed.post#reply',
-        new ObjectSchema({ text: new StringSchema({}) }),
+      const replySchema = typedObject(
+        'app.bsky.feed.post',
+        'reply',
+        object({ text: string() }),
       )
       const result = replySchema.safeParse({
         $type: 'app.bsky.feed.post#quote',
@@ -407,9 +433,10 @@ describe('TypedObjectSchema', () => {
     })
 
     it('validates with long NSID', () => {
-      const longSchema = new TypedObjectSchema(
-        'com.example.app.feature.action.detail#variant',
-        new ObjectSchema({ value: new StringSchema({}) }),
+      const longSchema = typedObject(
+        'com.example.app.feature.action.detail',
+        'variant',
+        object({ value: string() }),
       )
       const result = longSchema.safeParse({
         $type: 'com.example.app.feature.action.detail#variant',
@@ -421,10 +448,7 @@ describe('TypedObjectSchema', () => {
 
   describe('edge cases', () => {
     it('validates object with only extra properties', () => {
-      const minimalSchema = new TypedObjectSchema(
-        'app.bsky.test#main',
-        new ObjectSchema({}),
-      )
+      const minimalSchema = typedObject('app.bsky.test', 'main', object({}))
       const result = minimalSchema.safeParse({
         extra1: 'value1',
         extra2: 'value2',
@@ -433,21 +457,15 @@ describe('TypedObjectSchema', () => {
     })
 
     it('validates empty object with no required properties', () => {
-      const minimalSchema = new TypedObjectSchema(
-        'app.bsky.test#main',
-        new ObjectSchema({}),
-      )
+      const minimalSchema = typedObject('app.bsky.test', 'main', object({}))
       const result = minimalSchema.safeParse({})
       expect(result.success).toBe(true)
     })
 
     it('validates with $type as only property', () => {
-      const minimalSchema = new TypedObjectSchema(
-        'app.bsky.test#main',
-        new ObjectSchema({}),
-      )
+      const minimalSchema = typedObject('app.bsky.test', 'main', object({}))
       const result = minimalSchema.safeParse({
-        $type: 'app.bsky.test#main',
+        $type: 'app.bsky.test',
       })
       expect(result.success).toBe(true)
     })
@@ -494,15 +512,14 @@ describe('TypedObjectSchema', () => {
   })
 
   describe('integration with all property types', () => {
-    const fullSchema = new TypedObjectSchema(
-      'app.bsky.test#full',
-      new ObjectSchema({
-        required: new StringSchema({}),
-        optional: new OptionalSchema(new StringSchema({})),
-        nullable: new NullableSchema(new StringSchema({})),
-        optionalNullable: new OptionalSchema(
-          new NullableSchema(new StringSchema({})),
-        ),
+    const fullSchema = typedObject(
+      'app.bsky.test',
+      'full',
+      object({
+        required: string(),
+        optional: optional(string()),
+        nullable: nullable(string()),
+        optionalNullable: optional(nullable(string())),
       }),
     )
 
@@ -576,9 +593,9 @@ describe('TypedObjectSchema', () => {
   })
 
   describe('comparison with plain ObjectSchema', () => {
-    const plainSchema = new ObjectSchema({
-      text: new StringSchema({}),
-      likes: new OptionalSchema(new IntegerSchema({})),
+    const plainSchema = object({
+      text: string(),
+      likes: optional(integer()),
     })
 
     it('typed schema accepts same input as plain schema', () => {
@@ -605,7 +622,7 @@ describe('TypedObjectSchema', () => {
     })
 
     it('typed schema accepts matching $type', () => {
-      const input = { $type: 'app.bsky.feed.post#main', text: 'Hello' }
+      const input = { $type: 'app.bsky.feed.post', text: 'Hello' }
       const typedResult = schema.safeParse(input)
       expect(typedResult.success).toBe(true)
     })

package/src/schema/typed-object.ts

@@ -1,61 +1,60 @@
 import { isPlainObject } from '@atproto/lex-data'
 import {
   $Type,
+  $TypeOf,
   $Typed,
   $TypedMaybe,
-  Infer,
+  $type,
+  $typed,
+  InferInput,
+  InferOutput,
+  NsidString,
   Schema,
-  ValidationResult,
+  Unknown$TypedObject,
+  ValidationContext,
   Validator,
-  ValidatorContext,
 } from '../core.js'
-import { TypedObject } from './typed-union.js'
-
-export type TypedObjectSchemaOutput<
-  T extends $Type,
-  S extends Validator<{ [k: string]: unknown }>,
-> = $TypedMaybe<Infer<S>, T>
 
 export class TypedObjectSchema<
-  const T extends $Type = any,
-  const S extends Validator<{ [k: string]: unknown }> = any,
-> extends Schema<TypedObjectSchemaOutput<T, S>> {
+  const TType extends $Type = $Type,
+  const TShape extends Validator<{ [k: string]: unknown }> = any,
+> extends Schema<
+  $TypedMaybe<InferInput<TShape>, TType>,
+  $TypedMaybe<InferOutput<TShape>, TType>
+> {
   constructor(
-    readonly $type: T,
-    readonly schema: S,
+    readonly $type: TType,
+    readonly schema: TShape,
   ) {
     super()
   }
 
   isTypeOf<X extends Record<string, unknown>>(
     value: X,
-  ): value is Exclude<
-    X extends { $type?: T } ? X : $TypedMaybe<X, T>,
-    TypedObject
-  > {
+  ): value is X extends { $type?: TType }
+    ? X
+    : $TypedMaybe<Exclude<X, Unknown$TypedObject>, TType> {
     return value.$type === undefined || value.$type === this.$type
   }
 
-  build<X extends Omit<Infer<S>, '$type'>>(
-    input: X,
-  ): $Typed<Omit<X, '$type'>, T> {
-    return input.$type === this.$type
-      ? (input as $Typed<X, T>)
-      : { ...input, $type: this.$type }
+  build(
+    input: Omit<InferInput<this>, '$type'>,
+  ): $Typed<InferOutput<this>, TType> {
+    return this.parse($typed(input, this.$type)) as $Typed<
+      InferOutput<this>,
+      TType
+    >
   }
 
   $isTypeOf<X extends Record<string, unknown>>(value: X) {
     return this.isTypeOf(value)
   }
 
-  $build<X extends Omit<Infer<S>, '$type'>>(input: X) {
-    return this.build<X>(input)
+  $build(input: Omit<InferInput<this>, '$type'>) {
+    return this.build(input)
   }
 
-  validateInContext(
-    input: unknown,
-    ctx: ValidatorContext,
-  ): ValidationResult<TypedObjectSchemaOutput<T, S>> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     if (!isPlainObject(input)) {
       return ctx.issueInvalidType(input, 'object')
     }
@@ -68,8 +67,44 @@ export class TypedObjectSchema<
       return ctx.issueInvalidPropertyValue(input, '$type', [this.$type])
     }
 
-    return ctx.validate(input, this.schema) as ValidationResult<
-      TypedObjectSchemaOutput<T, S>
-    >
+    return ctx.validate(input, this.schema)
   }
 }
+
+/**
+ * This function offers two overloads:
+ * - One that allows creating a {@link TypedObjectSchema}, and infer the output
+ *   type from the provided arguments, without requiring to specify any of the
+ *   generics. This is useful when you want to define a record without
+ *   explicitly defining its interface. This version does not support circular
+ *   references, as TypeScript cannot infer types in such cases.
+ * - One allows creating a {@link TypedObjectSchema} with an explicitly defined
+ *   interface. This will typically be used by codegen (`lex build`) to generate
+ *   schemas that work even if they contain circular references.
+ */
+export function typedObject<
+  const N extends NsidString,
+  const H extends string,
+  const S extends Validator<{ [k: string]: unknown }>,
+>(nsid: N, hash: H, validator: S): TypedObjectSchema<$Type<N, H>, S>
+export function typedObject<V extends { $type?: $Type }>(
+  nsid: V extends { $type?: infer T extends string }
+    ? T extends `${infer N}#${string}`
+      ? N
+      : T // (T is a "main" type, so already an NSID)
+    : never,
+  hash: V extends { $type?: infer T extends string }
+    ? T extends `${string}#${infer H}`
+      ? H
+      : 'main'
+    : never,
+  validator: Validator<Omit<V, '$type'>>,
+): TypedObjectSchema<$TypeOf<V>, Validator<V>>
+/*@__NO_SIDE_EFFECTS__*/
+export function typedObject<
+  const N extends NsidString,
+  const H extends string,
+  const S extends Validator<{ [k: string]: unknown }>,
+>(nsid: N, hash: H, validator: S) {
+  return new TypedObjectSchema<$Type<N, H>, S>($type(nsid, hash), validator)
+}