@atproto/lexicon 0.0.4 → 0.2.0

package/tests/general.test.ts

@@ -1,4 +1,6 @@
-import { Lexicons } from '../src/index'
+import { CID } from 'multiformats/cid'
+import { lexiconDoc, Lexicons } from '../src/index'
+import { object } from '../src/validators/complex'
 import LexiconDocs from './_scaffolds/lexicons'
 
 describe('Lexicons collection', () => {
@@ -40,22 +42,28 @@ describe('General validation', () => {
           object: { boolean: true },
           array: ['one', 'two'],
           boolean: true,
-          number: 123.45,
           integer: 123,
           string: 'string',
         },
         array: ['one', 'two'],
         boolean: true,
-        number: 123.45,
         integer: 123,
         string: 'string',
         datetime: new Date().toISOString(),
+        atUri: 'at://did:web:example.com/com.example.test/self',
+        did: 'did:web:example.com',
+        cid: 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+        bytes: new Uint8Array([0, 1, 2, 3]),
+        cidLink: CID.parse(
+          'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+        ),
       })
       expect(res.success).toBe(true)
     }
     {
       const res = lex.validate('com.example.kitchenSink', {})
       expect(res.success).toBe(false)
+      if (res.success) throw new Error('Asserted')
       expect(res.error?.message).toBe('Record must have the property "object"')
     }
   })
@@ -65,7 +73,6 @@ describe('General validation', () => {
         object: { boolean: true },
         array: ['one', 'two'],
         boolean: true,
-        number: 123.45,
         integer: 123,
         string: 'string',
       })
@@ -74,32 +81,206 @@ describe('General validation', () => {
     {
       const res = lex.validate('com.example.kitchenSink#object', {})
       expect(res.success).toBe(false)
+      if (res.success) throw new Error('Asserted')
       expect(res.error?.message).toBe('Object must have the property "object"')
     }
   })
+  it('fails when a required property is missing', () => {
+    const schema = {
+      lexicon: 1,
+      id: 'com.example.kitchenSink',
+      defs: {
+        test: {
+          type: 'object',
+          required: ['foo'],
+          properties: {},
+        },
+      },
+    }
+    expect(() => {
+      lexiconDoc.parse(schema)
+    }).toThrow('Required field \\"foo\\" not defined')
+  })
+  it('fails when unknown fields are present', () => {
+    const schema = {
+      lexicon: 1,
+      id: 'com.example.unknownFields',
+      defs: {
+        test: {
+          type: 'object',
+          foo: 3,
+        },
+      },
+    }
+
+    expect(() => {
+      lexiconDoc.parse(schema)
+    }).toThrow("Unrecognized key(s) in object: 'foo'")
+  })
+  it('fails lexicon parsing when uri is invalid', () => {
+    const schema = {
+      lexicon: 1,
+      id: 'com.example.invalidUri',
+      defs: {
+        main: {
+          type: 'object',
+          properties: {
+            test: { type: 'ref', ref: 'com.example.invalid#test#test' },
+          },
+        },
+      },
+    }
+
+    expect(() => {
+      new Lexicons([schema])
+    }).toThrow('Uri can only have one hash segment')
+  })
+  it('fails validation when ref uri has multiple hash segments', () => {
+    const schema = {
+      lexicon: 1,
+      id: 'com.example.invalidUri',
+      defs: {
+        main: {
+          type: 'object',
+          properties: {
+            test: { type: 'integer' },
+          },
+        },
+        object: {
+          type: 'object',
+          required: ['test'],
+          properties: {
+            test: {
+              type: 'union',
+              refs: ['com.example.invalidUri'],
+            },
+          },
+        },
+      },
+    }
+    const lexicons = new Lexicons([schema])
+    expect(() => {
+      lexicons.validate('com.example.invalidUri#object', {
+        test: {
+          $type: 'com.example.invalidUri#main#main',
+          test: 123,
+        },
+      })
+    }).toThrow('Uri can only have one hash segment')
+  })
+  it('union handles both implicit and explicit #main', () => {
+    const schemas = [
+      {
+        lexicon: 1,
+        id: 'com.example.implicitMain',
+        defs: {
+          main: {
+            type: 'object',
+            required: ['test'],
+            properties: {
+              test: { type: 'string' },
+            },
+          },
+        },
+      },
+      {
+        lexicon: 1,
+        id: 'com.example.testImplicitMain',
+        defs: {
+          main: {
+            type: 'object',
+            required: ['union'],
+            properties: {
+              union: {
+                type: 'union',
+                refs: ['com.example.implicitMain'],
+              },
+            },
+          },
+        },
+      },
+      {
+        lexicon: 1,
+        id: 'com.example.testExplicitMain',
+        defs: {
+          main: {
+            type: 'object',
+            required: ['union'],
+            properties: {
+              union: {
+                type: 'union',
+                refs: ['com.example.implicitMain#main'],
+              },
+            },
+          },
+        },
+      },
+    ]
+
+    const lexicon = new Lexicons(schemas)
+
+    let result = lexicon.validate('com.example.testImplicitMain', {
+      union: {
+        $type: 'com.example.implicitMain',
+        test: 123,
+      },
+    })
+    expect(result.success).toBeFalsy()
+    expect(result['error']?.message).toBe('Object/union/test must be a string')
+
+    result = lexicon.validate('com.example.testImplicitMain', {
+      union: {
+        $type: 'com.example.implicitMain#main',
+        test: 123,
+      },
+    })
+    expect(result.success).toBeFalsy()
+    expect(result['error']?.message).toBe('Object/union/test must be a string')
+
+    result = lexicon.validate('com.example.testExplicitMain', {
+      union: {
+        $type: 'com.example.implicitMain',
+        test: 123,
+      },
+    })
+    expect(result.success).toBeFalsy()
+    expect(result['error']?.message).toBe('Object/union/test must be a string')
+
+    result = lexicon.validate('com.example.testExplicitMain', {
+      union: {
+        $type: 'com.example.implicitMain#main',
+        test: 123,
+      },
+    })
+    expect(result.success).toBeFalsy()
+    expect(result['error']?.message).toBe('Object/union/test must be a string')
+  })
 })
 
 describe('Record validation', () => {
   const lex = new Lexicons(LexiconDocs)
 
-  it('Passes valid schemas', () => {
-    lex.assertValidRecord('com.example.kitchenSink', {
-      $type: 'com.example.kitchenSink',
-      object: {
-        object: { boolean: true },
-        array: ['one', 'two'],
-        boolean: true,
-        number: 123.45,
-        integer: 123,
-        string: 'string',
-      },
+  const passingSink = {
+    $type: 'com.example.kitchenSink',
+    object: {
+      object: { boolean: true },
       array: ['one', 'two'],
       boolean: true,
-      number: 123.45,
       integer: 123,
       string: 'string',
-      datetime: new Date().toISOString(),
-    })
+    },
+    array: ['one', 'two'],
+    boolean: true,
+    integer: 123,
+    string: 'string',
+    bytes: new Uint8Array([0, 1, 2, 3]),
+    cidLink: CID.parse(
+      'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+    ),
+  }
+
+  it('Passes valid schemas', () => {
+    lex.assertValidRecord('com.example.kitchenSink', passingSink)
   })
 
   it('Fails invalid input types', () => {
@@ -129,10 +310,22 @@ describe('Record validation', () => {
         $type: 'com.example.kitchenSink',
         array: ['one', 'two'],
         boolean: true,
-        number: 123.45,
         integer: 123,
         string: 'string',
         datetime: new Date().toISOString(),
+        atUri: 'at://did:web:example.com/com.example.test/self',
+        did: 'did:web:example.com',
+        cid: 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+        bytes: new Uint8Array([0, 1, 2, 3]),
+        cidLink: CID.parse(
+          'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+        ),
+      }),
+    ).toThrow('Record must have the property "object"')
+    expect(() =>
+      lex.assertValidRecord('com.example.kitchenSink', {
+        ...passingSink,
+        object: undefined,
       }),
     ).toThrow('Record must have the property "object"')
   })
@@ -140,130 +333,49 @@ describe('Record validation', () => {
   it('Fails incorrect types', () => {
     expect(() =>
       lex.assertValidRecord('com.example.kitchenSink', {
-        $type: 'com.example.kitchenSink',
+        ...passingSink,
         object: {
+          ...passingSink.object,
           object: { boolean: '1234' },
-          array: ['one', 'two'],
-          boolean: true,
-          number: 123.45,
-          integer: 123,
-          string: 'string',
         },
-        array: ['one', 'two'],
-        boolean: true,
-        number: 123.45,
-        integer: 123,
-        string: 'string',
-        datetime: new Date().toISOString(),
       }),
     ).toThrow('Record/object/object/boolean must be a boolean')
     expect(() =>
       lex.assertValidRecord('com.example.kitchenSink', {
-        $type: 'com.example.kitchenSink',
+        ...passingSink,
         object: true,
-        array: ['one', 'two'],
-        boolean: true,
-        number: 123.45,
-        integer: 123,
-        string: 'string',
-        datetime: new Date().toISOString(),
       }),
     ).toThrow('Record/object must be an object')
     expect(() =>
       lex.assertValidRecord('com.example.kitchenSink', {
-        $type: 'com.example.kitchenSink',
-        object: {
-          object: { boolean: true },
-          array: ['one', 'two'],
-          boolean: true,
-          number: 123.45,
-          integer: 123,
-          string: 'string',
-        },
+        ...passingSink,
         array: 1234,
-        boolean: true,
-        number: 123.45,
-        integer: 123,
-        string: 'string',
-        datetime: new Date().toISOString(),
       }),
     ).toThrow('Record/array must be an array')
     expect(() =>
       lex.assertValidRecord('com.example.kitchenSink', {
-        $type: 'com.example.kitchenSink',
-        object: {
-          object: { boolean: true },
-          array: ['one', 'two'],
-          boolean: true,
-          number: 123.45,
-          integer: 123,
-          string: 'string',
-        },
-        array: ['one', 'two'],
-        boolean: true,
-        number: 'string',
-        integer: 123,
-        string: 'string',
-        datetime: new Date().toISOString(),
-      }),
-    ).toThrow('Record/number must be a number')
-    expect(() =>
-      lex.assertValidRecord('com.example.kitchenSink', {
-        $type: 'com.example.kitchenSink',
-        object: {
-          object: { boolean: true },
-          array: ['one', 'two'],
-          boolean: true,
-          number: 123.45,
-          integer: 123,
-          string: 'string',
-        },
-        array: ['one', 'two'],
-        boolean: true,
-        number: 123.45,
+        ...passingSink,
         integer: true,
-        string: 'string',
-        datetime: new Date().toISOString(),
       }),
-    ).toThrow('Record/integer must be a number')
+    ).toThrow('Record/integer must be an integer')
     expect(() =>
       lex.assertValidRecord('com.example.kitchenSink', {
-        $type: 'com.example.kitchenSink',
-        object: {
-          object: { boolean: true },
-          array: ['one', 'two'],
-          boolean: true,
-          number: 123.45,
-          integer: 123,
-          string: 'string',
-        },
-        array: ['one', 'two'],
-        boolean: true,
-        number: 123.45,
-        integer: 123,
+        ...passingSink,
         string: {},
-        datetime: new Date().toISOString(),
       }),
     ).toThrow('Record/string must be a string')
     expect(() =>
       lex.assertValidRecord('com.example.kitchenSink', {
-        $type: 'com.example.kitchenSink',
-        object: {
-          object: { boolean: true },
-          array: ['one', 'two'],
-          boolean: true,
-          number: 123.45,
-          integer: 123,
-          string: 'string',
-        },
-        array: ['one', 'two'],
-        boolean: true,
-        number: 123.45,
-        integer: 123,
-        string: 'string',
-        datetime: 1234,
+        ...passingSink,
+        bytes: 1234,
       }),
-    ).toThrow('Record/datetime must be a string')
+    ).toThrow('Record/bytes must be a byte array')
+    expect(() =>
+      lex.assertValidRecord('com.example.kitchenSink', {
+        ...passingSink,
+        cidLink: 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+      }),
+    ).toThrow('Record/cidLink must be a CID')
   })
 
   it('Handles optional properties correctly', () => {
@@ -272,6 +384,25 @@ describe('Record validation', () => {
     })
   })
 
+  it('Handles default properties correctly', () => {
+    const result = lex.assertValidRecord('com.example.default', {
+      $type: 'com.example.default',
+      object: {},
+    })
+    expect(result).toEqual({
+      $type: 'com.example.default',
+      boolean: false,
+      integer: 0,
+      string: '',
+      object: {
+        boolean: true,
+        integer: 1,
+        string: 'x',
+      },
+    })
+    expect(result).not.toHaveProperty('datetime')
+  })
+
   it('Handles unions correctly', () => {
     lex.assertValidRecord('com.example.union', {
       $type: 'com.example.union',
@@ -280,7 +411,6 @@ describe('Record validation', () => {
         object: { boolean: true },
         array: ['one', 'two'],
         boolean: true,
-        number: 123.45,
         integer: 123,
         string: 'string',
       },
@@ -355,6 +485,21 @@ describe('Record validation', () => {
     ).toThrow('Record/array must not have more than 4 elements')
   })
 
+  it('Applies array item constraints', () => {
+    expect(() =>
+      lex.assertValidRecord('com.example.arrayLength', {
+        $type: 'com.example.arrayLength',
+        array: [1, '2', 3],
+      }),
+    ).toThrow('Record/array/1 must be an integer')
+    expect(() =>
+      lex.assertValidRecord('com.example.arrayLength', {
+        $type: 'com.example.arrayLength',
+        array: [1, undefined, 3],
+      }),
+    ).toThrow('Record/array/1 must be an integer')
+  })
+
   it('Applies boolean const constraint', () => {
     lex.assertValidRecord('com.example.boolConst', {
       $type: 'com.example.boolConst',
@@ -368,51 +513,6 @@ describe('Record validation', () => {
     ).toThrow('Record/boolean must be false')
   })
 
-  it('Applies number range constraint', () => {
-    lex.assertValidRecord('com.example.numberRange', {
-      $type: 'com.example.numberRange',
-      number: 2.5,
-    })
-    expect(() =>
-      lex.assertValidRecord('com.example.numberRange', {
-        $type: 'com.example.numberRange',
-        number: 1,
-      }),
-    ).toThrow('Record/number can not be less than 2')
-    expect(() =>
-      lex.assertValidRecord('com.example.numberRange', {
-        $type: 'com.example.numberRange',
-        number: 5,
-      }),
-    ).toThrow('Record/number can not be greater than 4')
-  })
-
-  it('Applies number enum constraint', () => {
-    lex.assertValidRecord('com.example.numberEnum', {
-      $type: 'com.example.numberEnum',
-      number: 1.5,
-    })
-    expect(() =>
-      lex.assertValidRecord('com.example.numberEnum', {
-        $type: 'com.example.numberEnum',
-        number: 0,
-      }),
-    ).toThrow('Record/number must be one of (1|1.5|2)')
-  })
-
-  it('Applies number const constraint', () => {
-    lex.assertValidRecord('com.example.numberConst', {
-      $type: 'com.example.numberConst',
-      number: 0,
-    })
-    expect(() =>
-      lex.assertValidRecord('com.example.numberConst', {
-        $type: 'com.example.numberConst',
-        number: 1,
-      }),
-    ).toThrow('Record/number must be 0')
-  })
-
   it('Applies integer range constraint', () => {
     lex.assertValidRecord('com.example.integerRange', {
       $type: 'com.example.integerRange',
@@ -484,6 +584,31 @@ describe('Record validation', () => {
         string: '12345',
       }),
     ).toThrow('Record/string must not be longer than 4 characters')
+    expect(() =>
+      lex.assertValidRecord('com.example.stringLength', {
+        $type: 'com.example.stringLength',
+        string: '👨‍👩‍👧‍👧',
+      }),
+    ).toThrow('Record/string must not be longer than 4 characters')
+  })
+
+  it('Applies grapheme string length constraint', () => {
+    lex.assertValidRecord('com.example.stringLengthGrapheme', {
+      $type: 'com.example.stringLengthGrapheme',
+      string: '12👨‍👩‍👧‍👧',
+    })
+    expect(() =>
+      lex.assertValidRecord('com.example.stringLengthGrapheme', {
+        $type: 'com.example.stringLengthGrapheme',
+        string: '👨‍👩‍👧‍👧',
+      }),
+    ).toThrow('Record/string must not be shorter than 2 graphemes')
+    expect(() =>
+      lex.assertValidRecord('com.example.stringLengthGrapheme', {
+        $type: 'com.example.stringLengthGrapheme',
+        string: '12345',
+      }),
+    ).toThrow('Record/string must not be longer than 4 graphemes')
   })
 
   it('Applies string enum constraint', () => {
@@ -537,36 +662,230 @@ describe('Record validation', () => {
       }),
     ).toThrow('Record/datetime must be an iso8601 formatted datetime')
   })
+
+  it('Applies uri formatting constraint', () => {
+    for (const uri of [
+      'https://example.com',
+      'https://example.com/with/path',
+      'https://example.com/with/path?and=query',
+      'at://bsky.social',
+      'did:example:test',
+    ]) {
+      lex.assertValidRecord('com.example.uri', {
+        $type: 'com.example.uri',
+        uri,
+      })
+    }
+    expect(() =>
+      lex.assertValidRecord('com.example.uri', {
+        $type: 'com.example.uri',
+        uri: 'not a uri',
+      }),
+    ).toThrow('Record/uri must be a uri')
+  })
+
+  it('Applies at-uri formatting constraint', () => {
+    lex.assertValidRecord('com.example.atUri', {
+      $type: 'com.example.atUri',
+      atUri: 'at://did:web:example.com/com.example.test/self',
+    })
+    expect(() =>
+      lex.assertValidRecord('com.example.atUri', {
+        $type: 'com.example.atUri',
+        atUri: 'http://not-atproto.com',
+      }),
+    ).toThrow('Record/atUri must be a valid at-uri')
+  })
+
+  it('Applies did formatting constraint', () => {
+    lex.assertValidRecord('com.example.did', {
+      $type: 'com.example.did',
+      did: 'did:web:example.com',
+    })
+    lex.assertValidRecord('com.example.did', {
+      $type: 'com.example.did',
+      did: 'did:plc:12345678abcdefghijklmnop',
+    })
+
+    expect(() =>
+      lex.assertValidRecord('com.example.did', {
+        $type: 'com.example.did',
+        did: 'bad did',
+      }),
+    ).toThrow('Record/did must be a valid did')
+    expect(() =>
+      lex.assertValidRecord('com.example.did', {
+        $type: 'com.example.did',
+        did: 'did:short',
+      }),
+    ).toThrow('Record/did must be a valid did')
+  })
+
+  it('Applies handle formatting constraint', () => {
+    lex.assertValidRecord('com.example.handle', {
+      $type: 'com.example.handle',
+      handle: 'test.bsky.social',
+    })
+    lex.assertValidRecord('com.example.handle', {
+      $type: 'com.example.handle',
+      handle: 'bsky.test',
+    })
+
+    expect(() =>
+      lex.assertValidRecord('com.example.handle', {
+        $type: 'com.example.handle',
+        handle: 'bad handle',
+      }),
+    ).toThrow('Record/handle must be a valid handle')
+    expect(() =>
+      lex.assertValidRecord('com.example.handle', {
+        $type: 'com.example.handle',
+        handle: '-bad-.test',
+      }),
+    ).toThrow('Record/handle must be a valid handle')
+  })
+
+  it('Applies at-identifier formatting constraint', () => {
+    lex.assertValidRecord('com.example.atIdentifier', {
+      $type: 'com.example.atIdentifier',
+      atIdentifier: 'bsky.test',
+    })
+    lex.assertValidRecord('com.example.atIdentifier', {
+      $type: 'com.example.atIdentifier',
+      atIdentifier: 'did:plc:12345678abcdefghijklmnop',
+    })
+
+    expect(() =>
+      lex.assertValidRecord('com.example.atIdentifier', {
+        $type: 'com.example.atIdentifier',
+        atIdentifier: 'bad id',
+      }),
+    ).toThrow('Record/atIdentifier must be a valid did or a handle')
+    expect(() =>
+      lex.assertValidRecord('com.example.atIdentifier', {
+        $type: 'com.example.atIdentifier',
+        atIdentifier: '-bad-.test',
+      }),
+    ).toThrow('Record/atIdentifier must be a valid did or a handle')
+  })
+
+  it('Applies nsid formatting constraint', () => {
+    lex.assertValidRecord('com.example.nsid', {
+      $type: 'com.example.nsid',
+      nsid: 'com.atproto.test',
+    })
+    lex.assertValidRecord('com.example.nsid', {
+      $type: 'com.example.nsid',
+      nsid: 'app.bsky.nested.test',
+    })
+
+    expect(() =>
+      lex.assertValidRecord('com.example.nsid', {
+        $type: 'com.example.nsid',
+        nsid: 'bad nsid',
+      }),
+    ).toThrow('Record/nsid must be a valid nsid')
+    expect(() =>
+      lex.assertValidRecord('com.example.nsid', {
+        $type: 'com.example.nsid',
+        nsid: 'com.bad-.foo',
+      }),
+    ).toThrow('Record/nsid must be a valid nsid')
+  })
+
+  it('Applies cid formatting constraint', () => {
+    lex.assertValidRecord('com.example.cid', {
+      $type: 'com.example.cid',
+      cid: 'bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a',
+    })
+    expect(() =>
+      lex.assertValidRecord('com.example.cid', {
+        $type: 'com.example.cid',
+        cid: 'abapsdofiuwrpoiasdfuaspdfoiu',
+      }),
+    ).toThrow('Record/cid must be a cid string')
+  })
+
+  it('Applies language formatting constraint', () => {
+    lex.assertValidRecord('com.example.language', {
+      $type: 'com.example.language',
+      language: 'en-US-boont',
+    })
+    expect(() =>
+      lex.assertValidRecord('com.example.language', {
+        $type: 'com.example.language',
+        language: 'not-a-language-',
+      }),
+    ).toThrow('Record/language must be a well-formed BCP 47 language tag')
+  })
+
+  it('Applies bytes length constraints', () => {
+    lex.assertValidRecord('com.example.byteLength', {
+      $type: 'com.example.byteLength',
+      bytes: new Uint8Array([1, 2, 3]),
+    })
+    expect(() =>
+      lex.assertValidRecord('com.example.byteLength', {
+        $type: 'com.example.byteLength',
+        bytes: new Uint8Array([1]),
+      }),
+    ).toThrow('Record/bytes must not be smaller than 2 bytes')
+    expect(() =>
+      lex.assertValidRecord('com.example.byteLength', {
+        $type: 'com.example.byteLength',
+        bytes: new Uint8Array([1, 2, 3, 4, 5]),
+      }),
+    ).toThrow('Record/bytes must not be larger than 4 bytes')
+  })
 })
 
 describe('XRPC parameter validation', () => {
   const lex = new Lexicons(LexiconDocs)
 
   it('Passes valid parameters', () => {
-    lex.assertValidXrpcParams('com.example.query', {
+    const queryResult = lex.assertValidXrpcParams('com.example.query', {
+      boolean: true,
+      integer: 123,
+      string: 'string',
+      array: ['x', 'y'],
+    })
+    expect(queryResult).toEqual({
+      boolean: true,
+      integer: 123,
+      string: 'string',
+      array: ['x', 'y'],
+      def: 0,
+    })
+    const paramResult = lex.assertValidXrpcParams('com.example.procedure', {
       boolean: true,
-      number: 123.45,
       integer: 123,
       string: 'string',
+      array: ['x', 'y'],
+      def: 1,
     })
-    lex.assertValidXrpcParams('com.example.procedure', {
+    expect(paramResult).toEqual({
       boolean: true,
-      number: 123.45,
       integer: 123,
       string: 'string',
+      array: ['x', 'y'],
+      def: 1,
     })
   })
 
   it('Handles required correctly', () => {
     lex.assertValidXrpcParams('com.example.query', {
       boolean: true,
-      number: 123.45,
       integer: 123,
     })
     expect(() =>
       lex.assertValidXrpcParams('com.example.query', {
         boolean: true,
-        number: 123.45,
+      }),
+    ).toThrow('Params must have the property "integer"')
+    expect(() =>
+      lex.assertValidXrpcParams('com.example.query', {
+        boolean: true,
+        integer: undefined,
       }),
     ).toThrow('Params must have the property "integer"')
   })
@@ -575,19 +894,19 @@ describe('XRPC parameter validation', () => {
     expect(() =>
       lex.assertValidXrpcParams('com.example.query', {
         boolean: 'string',
-        number: 123.45,
         integer: 123,
         string: 'string',
       }),
     ).toThrow('boolean must be a boolean')
     expect(() =>
-      lex.assertValidXrpcParams('com.example.procedure', {
+      lex.assertValidXrpcParams('com.example.query', {
         boolean: true,
-        number: true,
+        float: 123.45,
         integer: 123,
         string: 'string',
+        array: 'x',
       }),
-    ).toThrow('number must be a number')
+    ).toThrow('array must be an array')
   })
 })
 
@@ -599,7 +918,7 @@ describe('XRPC input validation', () => {
       object: { boolean: true },
       array: ['one', 'two'],
       boolean: true,
-      number: 123.45,
+      float: 123.45,
       integer: 123,
       string: 'string',
     })
@@ -612,7 +931,7 @@ describe('XRPC input validation', () => {
         object: { boolean: 'string' },
         array: ['one', 'two'],
         boolean: true,
-        number: 123.45,
+        float: 123.45,
         integer: 123,
         string: 'string',
       }),
@@ -631,7 +950,7 @@ describe('XRPC output validation', () => {
       object: { boolean: true },
       array: ['one', 'two'],
       boolean: true,
-      number: 123.45,
+      float: 123.45,
       integer: 123,
       string: 'string',
     })
@@ -639,7 +958,7 @@ describe('XRPC output validation', () => {
       object: { boolean: true },
       array: ['one', 'two'],
       boolean: true,
-      number: 123.45,
+      float: 123.45,
       integer: 123,
       string: 'string',
     })
@@ -652,7 +971,7 @@ describe('XRPC output validation', () => {
         object: { boolean: 'string' },
         array: ['one', 'two'],
         boolean: true,
-        number: 123.45,
+        float: 123.45,
         integer: 123,
         string: 'string',
       }),