@atproto/lexicon 0.0.4 → 0.1.0

package/src/validators/xrpc.ts

@@ -2,49 +2,49 @@ import { Lexicons } from '../lexicons'
 import { LexXrpcParameters, ValidationResult, ValidationError } from '../types'
 
 import * as PrimitiveValidators from './primitives'
+import { array } from './complex'
 
 export function params(
   lexicons: Lexicons,
   path: string,
   def: LexXrpcParameters,
-  value: unknown,
+  val: unknown,
 ): ValidationResult {
-  def = def as LexXrpcParameters
-
   // type
-  if (!value || typeof value !== 'object') {
-    // in this case, we just fall back to an object
-    value = {}
-  }
+  const value = val && typeof val === 'object' ? val : {}
+
+  const requiredProps = new Set(def.required ?? [])
 
-  // required
-  if (Array.isArray(def.required)) {
-    for (const key of def.required) {
-      if (!(key in (value as Record<string, unknown>))) {
+  // properties
+  let resultValue = value
+  if (typeof def.properties === 'object') {
+    for (const key in def.properties) {
+      const propDef = def.properties[key]
+      const validated =
+        propDef.type === 'array'
+          ? array(lexicons, key, propDef, value[key])
+          : PrimitiveValidators.validate(lexicons, key, propDef, value[key])
+      const propValue = validated.success ? validated.value : value[key]
+      const propIsUndefined = typeof propValue === 'undefined'
+      // Return error for bad validation, giving required rule precedence
+      if (propIsUndefined && requiredProps.has(key)) {
         return {
           success: false,
           error: new ValidationError(`${path} must have the property "${key}"`),
         }
+      } else if (!propIsUndefined && !validated.success) {
+        return validated
+      }
+      // Adjust value based on e.g. applied defaults, cloning shallowly if there was a changed value
+      if (propValue !== value[key]) {
+        if (resultValue === value) {
+          // Lazy shallow clone
+          resultValue = { ...value }
+        }
+        resultValue[key] = propValue
       }
     }
   }
 
-  // properties
-  for (const key in def.properties) {
-    if (typeof (value as Record<string, unknown>)[key] === 'undefined') {
-      continue // skip- if required, will have already failed
-    }
-    const paramDef = def.properties[key]
-    const res = PrimitiveValidators.validate(
-      lexicons,
-      key,
-      paramDef,
-      (value as Record<string, unknown>)[key],
-    )
-    if (!res.success) {
-      return res
-    }
-  }
-
-  return { success: true }
+  return { success: true, value: resultValue }
 }

package/tests/_scaffolds/lexicons.ts

@@ -13,30 +13,32 @@ export default [
             'object',
             'array',
             'boolean',
-            'number',
+            'float',
             'integer',
             'string',
-            'datetime',
+            'bytes',
+            'cidLink',
           ],
           properties: {
             object: { type: 'ref', ref: '#object' },
             array: { type: 'array', items: { type: 'string' } },
             boolean: { type: 'boolean' },
-            number: { type: 'number' },
+            float: { type: 'float' },
             integer: { type: 'integer' },
             string: { type: 'string' },
-            datetime: { type: 'datetime' },
+            bytes: { type: 'bytes' },
+            cidLink: { type: 'cid-link' },
           },
         },
       },
       object: {
         type: 'object',
-        required: ['object', 'array', 'boolean', 'number', 'integer', 'string'],
+        required: ['object', 'array', 'boolean', 'float', 'integer', 'string'],
         properties: {
           object: { type: 'ref', ref: '#subobject' },
           array: { type: 'array', items: { type: 'string' } },
           boolean: { type: 'boolean' },
-          number: { type: 'number' },
+          float: { type: 'float' },
           integer: { type: 'integer' },
           string: { type: 'string' },
         },
@@ -59,12 +61,14 @@ export default [
         description: 'A query',
         parameters: {
           type: 'params',
-          required: ['boolean', 'number', 'integer'],
+          required: ['boolean', 'float', 'integer'],
           properties: {
             boolean: { type: 'boolean' },
-            number: { type: 'number' },
+            float: { type: 'float' },
             integer: { type: 'integer' },
             string: { type: 'string' },
+            array: { type: 'array', items: { type: 'string' } },
+            def: { type: 'integer', default: 0 },
           },
         },
         output: {
@@ -83,12 +87,13 @@ export default [
         description: 'A procedure',
         parameters: {
           type: 'params',
-          required: ['boolean', 'number', 'integer'],
+          required: ['boolean', 'float', 'integer'],
           properties: {
             boolean: { type: 'boolean' },
-            number: { type: 'number' },
+            float: { type: 'float' },
             integer: { type: 'integer' },
             string: { type: 'string' },
+            array: { type: 'array', items: { type: 'string' } },
           },
         },
         input: {
@@ -114,7 +119,7 @@ export default [
             object: { type: 'ref', ref: 'com.example.kitchenSink#object' },
             array: { type: 'array', items: { type: 'string' } },
             boolean: { type: 'boolean' },
-            number: { type: 'number' },
+            float: { type: 'float' },
             integer: { type: 'integer' },
             string: { type: 'string' },
           },
@@ -122,6 +127,35 @@ export default [
       },
     },
   },
+  {
+    lexicon: 1,
+    id: 'com.example.default',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          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' },
+          },
+        },
+      },
+      object: {
+        type: 'object',
+        properties: {
+          boolean: { type: 'boolean', default: true },
+          float: { type: 'float', default: 1.5 },
+          integer: { type: 'integer', default: 1 },
+          string: { type: 'string', default: 'x' },
+        },
+      },
+    },
+  },
   {
     lexicon: 1,
     id: 'com.example.union',
@@ -186,7 +220,7 @@ export default [
               type: 'array',
               minLength: 2,
               maxLength: 4,
-              items: { type: 'number' },
+              items: { type: 'float' },
             },
           },
         },
@@ -213,15 +247,15 @@ export default [
   },
   {
     lexicon: 1,
-    id: 'com.example.numberRange',
+    id: 'com.example.floatRange',
     defs: {
       main: {
         type: 'record',
         record: {
           type: 'object',
           properties: {
-            number: {
-              type: 'number',
+            float: {
+              type: 'float',
               minimum: 2,
               maximum: 4,
             },
@@ -232,15 +266,15 @@ export default [
   },
   {
     lexicon: 1,
-    id: 'com.example.numberEnum',
+    id: 'com.example.floatEnum',
     defs: {
       main: {
         type: 'record',
         record: {
           type: 'object',
           properties: {
-            number: {
-              type: 'number',
+            float: {
+              type: 'float',
               enum: [1, 1.5, 2],
             },
           },
@@ -250,15 +284,15 @@ export default [
   },
   {
     lexicon: 1,
-    id: 'com.example.numberConst',
+    id: 'com.example.floatConst',
     defs: {
       main: {
         type: 'record',
         record: {
           type: 'object',
           properties: {
-            number: {
-              type: 'number',
+            float: {
+              type: 'float',
               const: 0,
             },
           },
@@ -340,6 +374,25 @@ export default [
       },
     },
   },
+  {
+    lexicon: 1,
+    id: 'com.example.stringLengthGrapheme',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            string: {
+              type: 'string',
+              minGraphemes: 2,
+              maxGraphemes: 4,
+            },
+          },
+        },
+      },
+    },
+  },
   {
     lexicon: 1,
     id: 'com.example.stringEnum',
@@ -385,8 +438,130 @@ export default [
         record: {
           type: 'object',
           properties: {
-            datetime: {
-              type: 'datetime',
+            datetime: { type: 'string', format: 'datetime' },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.uri',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            uri: { type: 'string', format: 'uri' },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.atUri',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            atUri: { type: 'string', format: 'at-uri' },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.did',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            did: { type: 'string', format: 'did' },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.handle',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            handle: { type: 'string', format: 'handle' },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.atIdentifier',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            atIdentifier: { type: 'string', format: 'at-identifier' },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.nsid',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            nsid: { type: 'string', format: 'nsid' },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.cid',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            cid: { type: 'string', format: 'cid' },
+          },
+        },
+      },
+    },
+  },
+  {
+    lexicon: 1,
+    id: 'com.example.byteLength',
+    defs: {
+      main: {
+        type: 'record',
+        record: {
+          type: 'object',
+          properties: {
+            bytes: {
+              type: 'bytes',
+              minLength: 2,
+              maxLength: 4,
             },
           },
         },