@atproto/lex-schema 0.0.9 → 0.0.11

package/src/schema/record.test.ts

@@ -1,16 +1,17 @@
 import { describe, expect, it } from 'vitest'
-import { ObjectSchema } from './object.js'
-import { RecordSchema } from './record.js'
-import { StringSchema } from './string.js'
+import { Infer, Unknown$Type, Unknown$TypedObject } from '../core.js'
+import { object } from './object.js'
+import { record } from './record.js'
+import { string } from './string.js'
 
 describe('RecordSchema', () => {
   describe('basic validation', () => {
-    const schema = new RecordSchema(
+    const schema = record(
       'any',
       'app.bsky.feed.post',
-      new ObjectSchema({
-        $type: new StringSchema({}),
-        text: new StringSchema({}),
+      object({
+        $type: string(),
+        text: string(),
       }),
     )
 
@@ -63,14 +64,14 @@ describe('RecordSchema', () => {
   })
 
   describe('isTypeOf method', () => {
-    const schema = new RecordSchema(
+    const schema = record(
       'any',
       'app.bsky.feed.post',
-      new ObjectSchema({
-        $type: new StringSchema({}),
-        text: new StringSchema({}),
+      object({
+        text: string(),
       }),
     )
+    type Schema = Infer<typeof schema>
 
     it('returns true for matching $type', () => {
       const result = schema.isTypeOf({ $type: 'app.bsky.feed.post' })
@@ -96,15 +97,39 @@ describe('RecordSchema', () => {
       const result = schema.isTypeOf({ $type: null })
       expect(result).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('build method', () => {
-    const schema = new RecordSchema(
+    const schema = record(
       'any',
       'app.bsky.feed.post',
-      new ObjectSchema({
-        $type: new StringSchema({}),
-        text: new StringSchema({}),
+      object({
+        $type: string(),
+        text: string(),
       }),
     )
 
@@ -117,15 +142,18 @@ describe('RecordSchema', () => {
     it('preserves existing properties', () => {
       const result = schema.build({
         text: 'Hello world',
+        // @ts-expect-error
         extra: 'value',
       })
       expect(result.$type).toBe('app.bsky.feed.post')
       expect(result.text).toBe('Hello world')
+      // @ts-expect-error
       expect(result.extra).toBe('value')
     })
 
     it('overwrites existing $type', () => {
       const result = schema.build({
+        // @ts-expect-error
         $type: 'wrong.type',
         text: 'Hello world',
       })
@@ -134,12 +162,12 @@ describe('RecordSchema', () => {
   })
 
   describe('key type: any', () => {
-    const schema = new RecordSchema(
+    const schema = record(
       'any',
       'app.bsky.feed.post',
-      new ObjectSchema({
-        $type: new StringSchema({}),
-        text: new StringSchema({}),
+      object({
+        $type: string(),
+        text: string(),
       }),
     )
 
@@ -170,12 +198,12 @@ describe('RecordSchema', () => {
   })
 
   describe('key type: tid', () => {
-    const schema = new RecordSchema(
+    const schema = record(
       'tid',
       'app.bsky.feed.post',
-      new ObjectSchema({
-        $type: new StringSchema({}),
-        text: new StringSchema({}),
+      object({
+        $type: string(),
+        text: string(),
       }),
     )
 
@@ -206,12 +234,12 @@ describe('RecordSchema', () => {
   })
 
   describe('key type: nsid', () => {
-    const schema = new RecordSchema(
+    const schema = record(
       'nsid',
       'app.bsky.feed.post',
-      new ObjectSchema({
-        $type: new StringSchema({}),
-        text: new StringSchema({}),
+      object({
+        $type: string(),
+        text: string(),
       }),
     )
 
@@ -245,12 +273,12 @@ describe('RecordSchema', () => {
 
   describe('key type: literal', () => {
     describe('literal:self', () => {
-      const schema = new RecordSchema(
+      const schema = record(
         'literal:self',
         'app.bsky.feed.post',
-        new ObjectSchema({
-          $type: new StringSchema({}),
-          text: new StringSchema({}),
+        object({
+          $type: string(),
+          text: string(),
         }),
       )
 
@@ -276,12 +304,12 @@ describe('RecordSchema', () => {
     })
 
     describe('literal:customKey', () => {
-      const schema = new RecordSchema(
+      const schema = record(
         'literal:customKey',
         'app.bsky.feed.post',
-        new ObjectSchema({
-          $type: new StringSchema({}),
-          text: new StringSchema({}),
+        object({
+          $type: string(),
+          text: string(),
         }),
       )
 
@@ -303,12 +331,12 @@ describe('RecordSchema', () => {
   })
 
   describe('$type with hash fragment', () => {
-    const schema = new RecordSchema(
+    const schema = record(
       'any',
       'app.bsky.feed.post#main',
-      new ObjectSchema({
-        $type: new StringSchema({}),
-        text: new StringSchema({}),
+      object({
+        $type: string(),
+        text: string(),
       }),
     )
 
@@ -338,13 +366,13 @@ describe('RecordSchema', () => {
   })
 
   describe('complex nested schema', () => {
-    const schema = new RecordSchema(
+    const schema = record(
       'any',
       'app.bsky.feed.post',
-      new ObjectSchema({
-        $type: new StringSchema({}),
-        text: new StringSchema({ maxLength: 300 }),
-        createdAt: new StringSchema({ format: 'datetime' }),
+      object({
+        $type: string(),
+        text: string({ maxLength: 300 }),
+        createdAt: string({ format: 'datetime' }),
       }),
     )
 
@@ -377,12 +405,12 @@ describe('RecordSchema', () => {
   })
 
   describe('edge cases', () => {
-    const schema = new RecordSchema(
+    const schema = record(
       'any',
       'app.bsky.feed.post',
-      new ObjectSchema({
-        $type: new StringSchema({}),
-        text: new StringSchema({}),
+      object({
+        $type: string(),
+        text: string(),
       }),
     )
 
@@ -442,14 +470,14 @@ describe('RecordSchema', () => {
     })
 
     it('handles deeply nested structures', () => {
-      const complexSchema = new RecordSchema(
+      const complexSchema = record(
         'any',
         'app.bsky.complex',
-        new ObjectSchema({
-          $type: new StringSchema({}),
-          nested: new ObjectSchema({
-            deep: new ObjectSchema({
-              value: new StringSchema({}),
+        object({
+          $type: string(),
+          nested: object({
+            deep: object({
+              value: string(),
             }),
           }),
         }),
@@ -468,12 +496,12 @@ describe('RecordSchema', () => {
   })
 
   describe('$isTypeOf method', () => {
-    const schema = new RecordSchema(
+    const schema = record(
       'any',
       'app.bsky.feed.post',
-      new ObjectSchema({
-        $type: new StringSchema({}),
-        text: new StringSchema({}),
+      object({
+        $type: string(),
+        text: string(),
       }),
     )
 
@@ -489,12 +517,12 @@ describe('RecordSchema', () => {
   })
 
   describe('$build method', () => {
-    const schema = new RecordSchema(
+    const schema = record(
       'any',
       'app.bsky.feed.post',
-      new ObjectSchema({
-        $type: new StringSchema({}),
-        text: new StringSchema({}),
+      object({
+        $type: string(),
+        text: string(),
       }),
     )
 
@@ -506,13 +534,13 @@ describe('RecordSchema', () => {
   })
 
   describe('validation with missing required fields', () => {
-    const schema = new RecordSchema(
+    const schema = record(
       'any',
       'app.bsky.feed.post',
-      new ObjectSchema({
-        $type: new StringSchema({}),
-        text: new StringSchema({}),
-        author: new StringSchema({}),
+      object({
+        $type: string(),
+        text: string(),
+        author: string(),
       }),
     )
 
@@ -536,40 +564,32 @@ describe('RecordSchema', () => {
 
   describe('different record key types', () => {
     it('constructs with key type "any"', () => {
-      const schema = new RecordSchema(
-        'any',
-        'app.bsky.test',
-        new ObjectSchema({ $type: new StringSchema({}) }),
-      )
+      const schema = record('any', 'app.bsky.test', object({ $type: string() }))
       expect(schema.key).toBe('any')
       expect(schema.keySchema).toBeDefined()
     })
 
     it('constructs with key type "tid"', () => {
-      const schema = new RecordSchema(
-        'tid',
-        'app.bsky.test',
-        new ObjectSchema({ $type: new StringSchema({}) }),
-      )
+      const schema = record('tid', 'app.bsky.test', object({ $type: string() }))
       expect(schema.key).toBe('tid')
       expect(schema.keySchema).toBeDefined()
     })
 
     it('constructs with key type "nsid"', () => {
-      const schema = new RecordSchema(
+      const schema = record(
         'nsid',
         'app.bsky.test',
-        new ObjectSchema({ $type: new StringSchema({}) }),
+        object({ $type: string() }),
       )
       expect(schema.key).toBe('nsid')
       expect(schema.keySchema).toBeDefined()
     })
 
     it('constructs with literal key type', () => {
-      const schema = new RecordSchema(
+      const schema = record(
         'literal:custom',
         'app.bsky.test',
-        new ObjectSchema({ $type: new StringSchema({}) }),
+        object({ $type: string() }),
       )
       expect(schema.key).toBe('literal:custom')
       expect(schema.keySchema).toBeDefined()
@@ -577,12 +597,12 @@ describe('RecordSchema', () => {
   })
 
   describe('validation with undefined vs missing fields', () => {
-    const schema = new RecordSchema(
+    const schema = record(
       'any',
       'app.bsky.feed.post',
-      new ObjectSchema({
-        $type: new StringSchema({}),
-        text: new StringSchema({}),
+      object({
+        $type: string(),
+        text: string(),
       }),
     )
 
@@ -613,12 +633,12 @@ describe('RecordSchema', () => {
 
   describe('record with empty $type string', () => {
     it('rejects empty $type string', () => {
-      const schema = new RecordSchema(
+      const schema = record(
         'any',
         'app.bsky.feed.post',
-        new ObjectSchema({
-          $type: new StringSchema({}),
-          text: new StringSchema({}),
+        object({
+          $type: string(),
+          text: string(),
         }),
       )
 
@@ -632,12 +652,12 @@ describe('RecordSchema', () => {
 
   describe('special characters in $type', () => {
     it('validates $type with dots', () => {
-      const schema = new RecordSchema(
+      const schema = record(
         'any',
         'app.bsky.feed.post',
-        new ObjectSchema({
-          $type: new StringSchema({}),
-          text: new StringSchema({}),
+        object({
+          $type: string(),
+          text: string(),
         }),
       )
 
@@ -649,12 +669,12 @@ describe('RecordSchema', () => {
     })
 
     it('validates $type with hash and alphanumeric fragment', () => {
-      const schema = new RecordSchema(
+      const schema = record(
         'any',
         'app.bsky.feed.post#reply123',
-        new ObjectSchema({
-          $type: new StringSchema({}),
-          text: new StringSchema({}),
+        object({
+          $type: string(),
+          text: string(),
         }),
       )
 
@@ -667,12 +687,12 @@ describe('RecordSchema', () => {
   })
 
   describe('case sensitivity', () => {
-    const schema = new RecordSchema(
+    const schema = record(
       'any',
       'app.bsky.feed.post',
-      new ObjectSchema({
-        $type: new StringSchema({}),
-        text: new StringSchema({}),
+      object({
+        $type: string(),
+        text: string(),
       }),
     )
 

package/src/schema/record.ts

@@ -1,37 +1,36 @@
 import {
   $Typed,
-  Infer,
+  $typed,
+  InferInput,
+  InferOutput,
   LexiconRecordKey,
   NsidString,
   Schema,
   TidString,
-  ValidationResult,
+  Unknown$TypedObject,
+  ValidationContext,
   Validator,
-  ValidatorContext,
 } from '../core.js'
-import { LiteralSchema } from './literal.js'
-import { StringSchema } from './string.js'
-import { TypedObject } from './typed-union.js'
+import { literal } from './literal.js'
+import { string } from './string.js'
 
 export type InferRecordKey<R extends RecordSchema> =
-  R extends RecordSchema<infer K> ? RecordKeySchemaOutput<K> : never
-
-export type RecordSchemaOutput<
-  T extends NsidString,
-  S extends Validator<{ [k: string]: unknown }>,
-> = $Typed<Infer<S>, T>
+  R extends RecordSchema<infer TKey> ? RecordKeySchemaOutput<TKey> : never
 
 export class RecordSchema<
-  K extends LexiconRecordKey = any,
-  T extends NsidString = any,
-  S extends Validator<{ [k: string]: unknown }> = any,
-> extends Schema<RecordSchemaOutput<T, S>> {
-  keySchema: RecordKeySchema<K>
+  const TKey extends LexiconRecordKey = any,
+  const TType extends NsidString = any,
+  const TShape extends Validator<{ [k: string]: unknown }> = any,
+> extends Schema<
+  $Typed<InferInput<TShape>, TType>,
+  $Typed<InferOutput<TShape>, TType>
+> {
+  keySchema: RecordKeySchema<TKey>
 
   constructor(
-    readonly key: K,
-    readonly $type: T,
-    readonly schema: S,
+    readonly key: TKey,
+    readonly $type: TType,
+    readonly schema: TShape,
   ) {
     super()
     this.keySchema = recordKey(key)
@@ -39,41 +38,38 @@ export class RecordSchema<
 
   isTypeOf<X extends { $type?: unknown }>(
     value: X,
-  ): value is Exclude<X extends { $type: T } ? X : $Typed<X, T>, TypedObject> {
+  ): value is X extends { $type: TType }
+    ? X
+    : $Typed<Exclude<X, Unknown$TypedObject>, TType> {
     return 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))
   }
 
   $isTypeOf<X extends { $type?: unknown }>(value: X) {
     return this.isTypeOf<X>(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<RecordSchemaOutput<T, S>> {
+  validateInContext(input: unknown, ctx: ValidationContext) {
     const result = ctx.validate(input, this.schema)
 
     if (!result.success) {
       return result
     }
 
-    if (this.$type !== result.value.$type) {
+    if (result.value.$type !== this.$type) {
       return ctx.issueInvalidPropertyValue(result.value, '$type', [this.$type])
     }
 
-    return result as ValidationResult<RecordSchemaOutput<T, S>>
+    return result
   }
 }
 
@@ -92,10 +88,10 @@ export type RecordKeySchema<Key extends LexiconRecordKey> = Schema<
   RecordKeySchemaOutput<Key>
 >
 
-const keySchema = new StringSchema({ minLength: 1 })
-const tidSchema = new StringSchema({ format: 'tid' })
-const nsidSchema = new StringSchema({ format: 'nsid' })
-const selfLiteralSchema = new LiteralSchema('self')
+const keySchema = string({ minLength: 1 })
+const tidSchema = string({ format: 'tid' })
+const nsidSchema = string({ format: 'nsid' })
+const selfLiteralSchema = literal('self')
 
 function recordKey<Key extends LexiconRecordKey>(
   key: Key,
@@ -107,8 +103,46 @@ function recordKey<Key extends LexiconRecordKey>(
   if (key.startsWith('literal:')) {
     const value = key.slice(8) as RecordKeySchemaOutput<Key>
     if (value === 'self') return selfLiteralSchema as any
-    return new LiteralSchema(value)
+    return literal(value)
   }
 
   throw new Error(`Unsupported record key type: ${key}`)
 }
+
+/**
+ * Ensures that a `$type` used in a record is a valid NSID (i.e. no fragment).
+ */
+type AsNsid<T> = T extends `${string}#${string}` ? never : T
+
+/**
+ * This function offers two overloads:
+ * - One that allows creating a {@link RecordSchema}, 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 RecordSchema} 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 record<
+  const K extends LexiconRecordKey,
+  const T extends NsidString,
+  const S extends Validator<{ [k: string]: unknown }>,
+>(key: K, type: AsNsid<T>, validator: S): RecordSchema<K, T, S>
+export function record<
+  const K extends LexiconRecordKey,
+  const V extends { $type: NsidString },
+>(
+  key: K,
+  type: AsNsid<V['$type']>,
+  validator: Validator<Omit<V, '$type'>>,
+): RecordSchema<K, V['$type'], Validator<Omit<V, '$type'>>>
+/*@__NO_SIDE_EFFECTS__*/
+export function record<
+  const K extends LexiconRecordKey,
+  const T extends NsidString,
+  const S extends Validator<{ [k: string]: unknown }>,
+>(key: K, type: T, validator: S) {
+  return new RecordSchema<K, T, S>(key, type, validator)
+}