@atproto/lexicon 0.1.0 → 0.2.1

package/src/util.ts

@@ -7,8 +7,13 @@ import {
   ValidationResult,
   isDiscriminatedObject,
 } from './types'
+import { z } from 'zod'
 
 export function toLexUri(str: string, baseUri?: string): string {
+  if (str.split('#').length > 2) {
+    throw new Error('Uri can only have one hash segment')
+  }
+
   if (str.startsWith('lex:')) {
     return str
   }
@@ -40,7 +45,7 @@ export function validateOneOf(
         ),
       }
     }
-    if (!def.refs.includes(toLexUri(value.$type))) {
+    if (!refsContainType(def.refs, value.$type)) {
       if (def.closed) {
         return {
           success: false,
@@ -104,3 +109,58 @@ export function toConcreteTypes(
     return [def]
   }
 }
+
+export function requiredPropertiesRefinement<
+  ObjectType extends {
+    required?: string[]
+    properties?: Record<string, unknown>
+  },
+>(object: ObjectType, ctx: z.RefinementCtx) {
+  // Required fields check
+  if (object.required === undefined) {
+    return
+  }
+
+  if (!Array.isArray(object.required)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.invalid_type,
+      received: typeof object.required,
+      expected: 'array',
+    })
+    return
+  }
+
+  if (object.properties === undefined) {
+    if (object.required.length > 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Required fields defined but no properties defined`,
+      })
+    }
+    return
+  }
+
+  for (const field of object.required) {
+    if (object.properties[field] === undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Required field "${field}" not defined`,
+      })
+    }
+  }
+}
+
+// to avoid bugs like #0189 this needs to handle both
+// explicit and implicit #main
+const refsContainType = (refs: string[], type: string) => {
+  const lexUri = toLexUri(type)
+  if (refs.includes(lexUri)) {
+    return true
+  }
+
+  if (lexUri.endsWith('#main')) {
+    return refs.includes(lexUri.replace('#main', ''))
+  } else {
+    return refs.includes(lexUri + '#main')
+  }
+}

package/src/validators/complex.ts

@@ -20,8 +20,6 @@ export function validate(
   switch (def.type) {
     case 'boolean':
       return Primitives.boolean(lexicons, path, def, value)
-    case 'float':
-      return Primitives.float(lexicons, path, def, value)
     case 'integer':
       return Primitives.integer(lexicons, path, def, value)
     case 'string':

package/src/validators/formats.ts

@@ -1,9 +1,13 @@
-import { ensureValidAtUri } from '@atproto/uri'
 import { isValidISODateString } from 'iso-datestring-validator'
 import { CID } from 'multiformats/cid'
 import { ValidationResult, ValidationError } from '../types'
-import { ensureValidDid, ensureValidHandle } from '@atproto/identifier'
-import { ensureValidNsid } from '@atproto/nsid'
+import {
+  ensureValidDid,
+  ensureValidHandle,
+  ensureValidNsid,
+  ensureValidAtUri,
+} from '@atproto/syntax'
+import { validateLanguage } from '@atproto/common-web'
 
 export function datetime(path: string, value: string): ValidationResult {
   try {
@@ -105,3 +109,16 @@ export function cid(path: string, value: string): ValidationResult {
   }
   return { success: true, value }
 }
+
+// The language format validates well-formed BCP 47 language tags: https://www.rfc-editor.org/info/bcp47
+export function language(path: string, value: string): ValidationResult {
+  if (validateLanguage(value)) {
+    return { success: true, value }
+  }
+  return {
+    success: false,
+    error: new ValidationError(
+      `${path} must be a well-formed BCP 47 language tag`,
+    ),
+  }
+}

package/src/validators/primitives.ts

@@ -5,7 +5,6 @@ import * as formats from './formats'
 import {
   LexUserType,
   LexBoolean,
-  LexFloat,
   LexInteger,
   LexString,
   ValidationResult,
@@ -22,8 +21,6 @@ export function validate(
   switch (def.type) {
     case 'boolean':
       return boolean(lexicons, path, def, value)
-    case 'float':
-      return float(lexicons, path, def, value)
     case 'integer':
       return integer(lexicons, path, def, value)
     case 'string':
@@ -80,13 +77,13 @@ export function boolean(
   return { success: true, value }
 }
 
-export function float(
+export function integer(
   lexicons: Lexicons,
   path: string,
   def: LexUserType,
   value: unknown,
 ): ValidationResult {
-  def = def as LexFloat
+  def = def as LexInteger
 
   // type
   const type = typeof value
@@ -96,12 +93,12 @@ export function float(
     }
     return {
       success: false,
-      error: new ValidationError(`${path} must be a number`),
+      error: new ValidationError(`${path} must be an integer`),
     }
-  } else if (type !== 'number') {
+  } else if (!Number.isInteger(value)) {
     return {
       success: false,
-      error: new ValidationError(`${path} must be a number`),
+      error: new ValidationError(`${path} must be an integer`),
     }
   }
 
@@ -154,33 +151,6 @@ export function float(
   return { success: true, value }
 }
 
-export function integer(
-  lexicons: Lexicons,
-  path: string,
-  def: LexUserType,
-  value: unknown,
-): ValidationResult {
-  def = def as LexInteger
-
-  // run number validation
-  const numRes = float(lexicons, path, def, value)
-  if (!numRes.success) {
-    return numRes
-  } else {
-    value = numRes.value
-  }
-
-  // whole numbers only
-  if (!Number.isInteger(value)) {
-    return {
-      success: false,
-      error: new ValidationError(`${path} must be an integer`),
-    }
-  }
-
-  return { success: true, value }
-}
-
 export function string(
   lexicons: Lexicons,
   path: string,
@@ -293,6 +263,8 @@ export function string(
         return formats.nsid(path, value)
       case 'cid':
         return formats.cid(path, value)
+      case 'language':
+        return formats.language(path, value)
     }
   }
 

package/tests/_scaffolds/lexicons.ts

@@ -13,7 +13,6 @@ export default [
             'object',
             'array',
             'boolean',
-            'float',
             'integer',
             'string',
             'bytes',
@@ -23,7 +22,6 @@ export default [
             object: { type: 'ref', ref: '#object' },
             array: { type: 'array', items: { type: 'string' } },
             boolean: { type: 'boolean' },
-            float: { type: 'float' },
             integer: { type: 'integer' },
             string: { type: 'string' },
             bytes: { type: 'bytes' },
@@ -33,12 +31,11 @@ export default [
       },
       object: {
         type: 'object',
-        required: ['object', 'array', 'boolean', 'float', 'integer', 'string'],
+        required: ['object', 'array', 'boolean', 'integer', 'string'],
         properties: {
           object: { type: 'ref', ref: '#subobject' },
           array: { type: 'array', items: { type: 'string' } },
           boolean: { type: 'boolean' },
-          float: { type: 'float' },
           integer: { type: 'integer' },
           string: { type: 'string' },
         },
@@ -61,10 +58,9 @@ export default [
         description: 'A query',
         parameters: {
           type: 'params',
-          required: ['boolean', 'float', 'integer'],
+          required: ['boolean', 'integer'],
           properties: {
             boolean: { type: 'boolean' },
-            float: { type: 'float' },
             integer: { type: 'integer' },
             string: { type: 'string' },
             array: { type: 'array', items: { type: 'string' } },
@@ -87,10 +83,9 @@ export default [
         description: 'A procedure',
         parameters: {
           type: 'params',
-          required: ['boolean', 'float', 'integer'],
+          required: ['boolean', 'integer'],
           properties: {
             boolean: { type: 'boolean' },
-            float: { type: 'float' },
             integer: { type: 'integer' },
             string: { type: 'string' },
             array: { type: 'array', items: { type: 'string' } },
@@ -119,7 +114,6 @@ export default [
             object: { type: 'ref', ref: 'com.example.kitchenSink#object' },
             array: { type: 'array', items: { type: 'string' } },
             boolean: { type: 'boolean' },
-            float: { type: 'float' },
             integer: { type: 'integer' },
             string: { type: 'string' },
           },
@@ -138,7 +132,6 @@ export default [
           required: ['boolean'],
           properties: {
             boolean: { type: 'boolean', default: false },
-            float: { type: 'float', default: 0 },
             integer: { type: 'integer', default: 0 },
             string: { type: 'string', default: '' },
             object: { type: 'ref', ref: '#object' },
@@ -149,7 +142,6 @@ export default [
         type: 'object',
         properties: {
           boolean: { type: 'boolean', default: true },
-          float: { type: 'float', default: 1.5 },
           integer: { type: 'integer', default: 1 },
           string: { type: 'string', default: 'x' },
         },
@@ -220,7 +212,7 @@ export default [
               type: 'array',
               minLength: 2,
               maxLength: 4,
-              items: { type: 'float' },
+              items: { type: 'integer' },
             },
           },
         },
@@ -245,61 +237,6 @@ export default [
       },
     },
   },
-  {
-    lexicon: 1,
-    id: 'com.example.floatRange',
-    defs: {
-      main: {
-        type: 'record',
-        record: {
-          type: 'object',
-          properties: {
-            float: {
-              type: 'float',
-              minimum: 2,
-              maximum: 4,
-            },
-          },
-        },
-      },
-    },
-  },
-  {
-    lexicon: 1,
-    id: 'com.example.floatEnum',
-    defs: {
-      main: {
-        type: 'record',
-        record: {
-          type: 'object',
-          properties: {
-            float: {
-              type: 'float',
-              enum: [1, 1.5, 2],
-            },
-          },
-        },
-      },
-    },
-  },
-  {
-    lexicon: 1,
-    id: 'com.example.floatConst',
-    defs: {
-      main: {
-        type: 'record',
-        record: {
-          type: 'object',
-          properties: {
-            float: {
-              type: 'float',
-              const: 0,
-            },
-          },
-        },
-      },
-    },
-  },
   {
     lexicon: 1,
     id: 'com.example.integerRange',
@@ -549,6 +486,21 @@ export default [
       },
     },
   },
+  {
+    lexicon: 1,
+    id: 'com.example.language',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            language: { type: 'string', format: 'language' },
+          },
+        },
+      },
+    },
+  },
   {
     lexicon: 1,
     id: 'com.example.byteLength',