@atproto/lex-document 0.0.2 → 0.0.4

package/src/lexicon-schema-builder.test.ts

@@ -1,4 +1,5 @@
-import { CID, l } from '@atproto/lex-schema'
+import { parseCid } from '@atproto/lex-data'
+import { l } from '@atproto/lex-schema'
 import { LexiconDocument, lexiconDocumentSchema } from './lexicon-document.js'
 import { LexiconIterableIndexer } from './lexicon-iterable-indexer.js'
 import { LexiconSchemaBuilder } from './lexicon-schema-builder.js'
@@ -59,20 +60,26 @@ describe('LexiconSchemaBuilder', () => {
             type: 'object',
             required: ['object', 'array', 'boolean', 'integer', 'string'],
             properties: {
-              object: { type: 'ref', ref: '#subobject' },
+              object: { type: 'ref', ref: '#subObject' },
               array: { type: 'array', items: { type: 'string' } },
               boolean: { type: 'boolean' },
               integer: { type: 'integer' },
               string: { type: 'string' },
+              refToEnumWithDefault: { type: 'ref', ref: '#enumWithDefault' },
             },
           },
-          subobject: {
+          subObject: {
             type: 'object',
             required: ['boolean'],
             properties: {
               boolean: { type: 'boolean' },
             },
           },
+          enumWithDefault: {
+            type: 'string',
+            default: 'option3',
+            enum: ['option1', 'option2', 'option3'],
+          },
         },
       }),
     ])
@@ -90,6 +97,7 @@ describe('LexiconSchemaBuilder', () => {
         boolean: true,
         integer: 123,
         string: 'string',
+        refToEnumWithDefault: 'option3',
       },
       array: ['one', 'two'],
       boolean: true,
@@ -100,12 +108,12 @@ describe('LexiconSchemaBuilder', () => {
       did: 'did:web:example.com',
       cid: 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
       bytes: new Uint8Array([0, 1, 2, 3]),
-      cidLink: CID.parse(
+      cidLink: parseCid(
         'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
       ),
     }
 
-    expect(schema.validate(value)).toStrictEqual({ success: true, value })
+    expect(schema.safeParse(value)).toStrictEqual({ success: true, value })
   })
 
   it('Validates objects correctly', () => {
@@ -122,7 +130,89 @@ describe('LexiconSchemaBuilder', () => {
       string: 'string',
     }
 
-    expect(schema.validate(value)).toStrictEqual({ success: true, value })
+    expect(schema.safeParse(value)).toStrictEqual({
+      success: true,
+      value: {
+        object: { boolean: true },
+        array: ['one', 'two'],
+        boolean: true,
+        integer: 123,
+        string: 'string',
+        refToEnumWithDefault: 'option3',
+      },
+    })
+  })
+
+  it('rejects invalid enum values', () => {
+    const schema = getSchema(
+      'com.example.kitchenSink#object',
+      l.TypedObjectSchema,
+    )
+
+    const value = {
+      object: { boolean: true },
+      array: ['one', 'two'],
+      boolean: true,
+      integer: 123,
+      string: 'string',
+      refToEnumWithDefault: 'invalidOption',
+    }
+
+    expect(schema.safeParse(value)).toMatchObject({
+      success: false,
+      error: {
+        issues: [
+          {
+            code: 'invalid_value',
+            input: 'invalidOption',
+            values: ['option1', 'option2', 'option3'],
+          },
+        ],
+      },
+    })
+  })
+
+  it('does not apply defaults when allowTransform is false', () => {
+    const schema = getSchema(
+      'com.example.kitchenSink#object',
+      l.TypedObjectSchema,
+    )
+
+    const value = {
+      object: { boolean: true },
+      array: ['one', 'two'],
+      boolean: true,
+      integer: 123,
+      string: 'string',
+    }
+
+    expect(schema.safeParse(value, { allowTransform: false })).toStrictEqual({
+      success: true,
+      value: {
+        object: { boolean: true },
+        array: ['one', 'two'],
+        boolean: true,
+        integer: 123,
+        string: 'string',
+      },
+    })
+  })
+
+  it('allows missing optional record fields', () => {
+    const schema = getSchema(
+      'com.example.kitchenSink#object',
+      l.TypedObjectSchema,
+    )
+
+    expect(
+      schema.matches({
+        object: { boolean: true },
+        array: ['one', 'two'],
+        boolean: true,
+        integer: 123,
+        string: 'string',
+      }),
+    ).toBe(true)
   })
 
   it('Rejects missing required record fields', () => {
@@ -139,7 +229,7 @@ describe('LexiconSchemaBuilder', () => {
       string: 'string',
     }
 
-    expect(schema.validate(value)).toMatchObject({
+    expect(schema.safeParse(value)).toMatchObject({
       success: false,
       error: { issues: [{ code: 'required_key', key: 'array' }] },
     })

package/src/lexicon-schema-builder.ts

@@ -33,8 +33,8 @@ export class LexiconSchemaBuilder {
     const ctx = new LexiconSchemaBuilder(indexer)
     try {
       const result = await ctx.buildFullRef(fullRef)
-      if (!(result instanceof l.Validator)) {
-        throw new Error(`Ref ${fullRef} is not a validator schema type`)
+      if (!(result instanceof l.Schema)) {
+        throw new Error(`Ref ${fullRef} is not a schema type`)
       }
       return result
     } finally {
@@ -90,8 +90,8 @@ export class LexiconSchemaBuilder {
 
     this.#asyncTasks.add(
       this.buildFullRef(fullRef).then((v) => {
-        if (!(v instanceof l.Validator)) {
-          throw new Error(`Only refs to validator schema types are allowed`)
+        if (!(v instanceof l.Schema)) {
+          throw new Error(`Only refs to schema types are allowed`)
         }
         validator = v
       }),
@@ -167,11 +167,7 @@ export class LexiconSchemaBuilder {
       case 'token':
         return l.token(doc.id, hash)
       case 'record':
-        return l.record(
-          def.key ? l.asRecordKey(def.key) : 'any',
-          doc.id,
-          this.compileObject(doc, def.record),
-        )
+        return l.record(def.key, doc.id, this.compileObject(doc, def.record))
       case 'object':
         return l.typedObject(doc.id, hash, this.compileObject(doc, def))
       default:
@@ -183,13 +179,48 @@ export class LexiconSchemaBuilder {
     doc: LexiconDocument,
     def: LexiconArray | LexiconArrayItems,
   ): l.Validator<unknown> {
+    if (
+      'const' in def &&
+      'enum' in def &&
+      def.enum != null &&
+      def.const !== undefined &&
+      !(def.enum as readonly unknown[]).includes(def.const)
+    ) {
+      return l.never()
+    }
+
     switch (def.type) {
-      case 'string':
-        return l.string(def)
-      case 'integer':
-        return l.integer(def)
-      case 'boolean':
-        return l.boolean(def)
+      case 'string': {
+        const schema: l.StringSchema = l.string(def)
+        if (def.const != null) {
+          schema.assert(def.const)
+          return l.literal(def.const, def)
+        } else if (def.enum != null) {
+          for (const v of def.enum) schema.assert(v)
+          return l.enum(def.enum, def)
+        } else {
+          return schema
+        }
+      }
+      case 'integer': {
+        const schema: l.IntegerSchema = l.integer(def)
+        if (def.const != null) {
+          schema.assert(def.const)
+          return l.literal(def.const, def)
+        } else if (def.enum != null) {
+          for (const v of def.enum) schema.assert(v)
+          return l.enum(def.enum, def)
+        } else {
+          return schema
+        }
+      }
+      case 'boolean': {
+        if (def.const != null) {
+          return l.literal(def.const, def)
+        } else {
+          return l.boolean(def)
+        }
+      }
       case 'blob':
         return l.blob(def)
       case 'cid-link':
@@ -232,9 +263,23 @@ export class LexiconSchemaBuilder {
     const props: Record<string, l.Validator> = {}
     for (const [key, propDef] of Object.entries(def.properties)) {
       if (propDef === undefined) continue
-      props[key] = this.compileLeaf(doc, propDef)
+
+      const isNullable = def.nullable?.includes(key)
+      const isRequired = def.required?.includes(key)
+
+      let schema = this.compileLeaf(doc, propDef)
+
+      if (isNullable) {
+        schema = l.nullable(schema)
+      }
+
+      if (!isRequired) {
+        schema = l.optional(schema)
+      }
+
+      props[key] = schema
     }
-    return l.object(props, def)
+    return l.object(props)
   }
 
   protected compilePayload(
@@ -273,9 +318,18 @@ export class LexiconSchemaBuilder {
     const props: Record<string, l.Validator> = {}
     for (const [key, propDef] of Object.entries(def.properties)) {
       if (propDef === undefined) continue
-      props[key] = this.compileLeaf(doc, propDef)
+
+      const isRequired = def.required?.includes(key)
+
+      let schema = this.compileLeaf(doc, propDef)
+
+      if (!isRequired) {
+        schema = l.optional(schema)
+      }
+
+      props[key] = schema
     }
-    return l.params(props, def)
+    return l.params(props)
   }
 }
 

package/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": ["../../../tsconfig/isomorphic.json"],
+  "include": ["./src"],
+  "exclude": ["**/*.test.ts"],
+  "compilerOptions": {
+    "noImplicitAny": true,
+    "importHelpers": true,
+    "target": "ES2023",
+    "rootDir": "./src",
+    "outDir": "./dist"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "include": [],
+  "references": [
+    { "path": "./tsconfig.build.json" },
+    { "path": "./tsconfig.tests.json" }
+  ]
+}

package/tsconfig.tests.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../../tsconfig/tests.json",
+  "include": ["./tests", "./src/**.test.ts"],
+  "compilerOptions": {
+    "noImplicitAny": true,
+    "rootDir": "./",
+    "baseUrl": "./"
+  }
+}