@atproto/lexicon 0.1.0 → 0.2.0

package/dist/util.d.ts

@@ -1,6 +1,11 @@
 import { Lexicons } from './lexicons';
 import { LexUserType, LexRefVariant, ValidationResult } from './types';
+import { z } from 'zod';
 export declare function toLexUri(str: string, baseUri?: string): string;
 export declare function validateOneOf(lexicons: Lexicons, path: string, def: LexRefVariant | LexUserType, value: unknown, mustBeObj?: boolean): ValidationResult;
 export declare function assertValidOneOf(lexicons: Lexicons, path: string, def: LexRefVariant | LexUserType, value: unknown, mustBeObj?: boolean): unknown;
 export declare function toConcreteTypes(lexicons: Lexicons, def: LexRefVariant | LexUserType): LexUserType[];
+export declare function requiredPropertiesRefinement<ObjectType extends {
+    required?: string[];
+    properties?: Record<string, unknown>;
+}>(object: ObjectType, ctx: z.RefinementCtx): void;

package/dist/validators/formats.d.ts

@@ -7,3 +7,4 @@ export declare function handle(path: string, value: string): ValidationResult;
 export declare function atIdentifier(path: string, value: string): ValidationResult;
 export declare function nsid(path: string, value: string): ValidationResult;
 export declare function cid(path: string, value: string): ValidationResult;
+export declare function language(path: string, value: string): ValidationResult;

package/dist/validators/primitives.d.ts

@@ -2,7 +2,6 @@ import { Lexicons } from '../lexicons';
 import { LexUserType, ValidationResult } from '../types';
 export declare function validate(lexicons: Lexicons, path: string, def: LexUserType, value: unknown): ValidationResult;
 export declare function boolean(lexicons: Lexicons, path: string, def: LexUserType, value: unknown): ValidationResult;
-export declare function float(lexicons: Lexicons, path: string, def: LexUserType, value: unknown): ValidationResult;
 export declare function integer(lexicons: Lexicons, path: string, def: LexUserType, value: unknown): ValidationResult;
 export declare function string(lexicons: Lexicons, path: string, def: LexUserType, value: unknown): ValidationResult;
 export declare function bytes(lexicons: Lexicons, path: string, def: LexUserType, value: unknown): ValidationResult;

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@atproto/lexicon",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "main": "dist/index.js",
   "scripts": {
     "test": "jest",
-    "prettier": "prettier --check src/",
-    "prettier:fix": "prettier --write src/",
+    "prettier": "prettier --check src/ tests/",
+    "prettier:fix": "prettier --write src/ tests/",
     "lint": "eslint . --ext .ts,.tsx",
     "lint:fix": "yarn lint --fix",
     "verify": "run-p prettier lint",
@@ -18,6 +18,11 @@
     "postpublish": "npm run update-main-to-src"
   },
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bluesky-social/atproto.git",
+    "directory": "packages/lexicon"
+  },
   "dependencies": {
     "@atproto/common-web": "*",
     "@atproto/identifier": "*",
@@ -25,6 +30,6 @@
     "@atproto/uri": "*",
     "iso-datestring-validator": "^2.2.2",
     "multiformats": "^9.6.4",
-    "zod": "^3.14.2"
+    "zod": "^3.21.4"
   }
 }

package/src/types.ts

@@ -1,37 +1,31 @@
 import { z } from 'zod'
 import { NSID } from '@atproto/nsid'
+import { requiredPropertiesRefinement } from './util'
 
 // primitives
 // =
 
-export const lexBoolean = z.object({
-  type: z.literal('boolean'),
-  description: z.string().optional(),
-  default: z.boolean().optional(),
-  const: z.boolean().optional(),
-})
+export const lexBoolean = z
+  .object({
+    type: z.literal('boolean'),
+    description: z.string().optional(),
+    default: z.boolean().optional(),
+    const: z.boolean().optional(),
+  })
+  .strict()
 export type LexBoolean = z.infer<typeof lexBoolean>
 
-export const lexFloat = z.object({
-  type: z.literal('float'),
-  description: z.string().optional(),
-  default: z.number().optional(),
-  minimum: z.number().optional(),
-  maximum: z.number().optional(),
-  enum: z.number().array().optional(),
-  const: z.number().optional(),
-})
-export type LexFloat = z.infer<typeof lexFloat>
-
-export const lexInteger = z.object({
-  type: z.literal('integer'),
-  description: z.string().optional(),
-  default: z.number().int().optional(),
-  minimum: z.number().int().optional(),
-  maximum: z.number().int().optional(),
-  enum: z.number().int().array().optional(),
-  const: z.number().int().optional(),
-})
+export const lexInteger = z
+  .object({
+    type: z.literal('integer'),
+    description: z.string().optional(),
+    default: z.number().int().optional(),
+    minimum: z.number().int().optional(),
+    maximum: z.number().int().optional(),
+    enum: z.number().int().array().optional(),
+    const: z.number().int().optional(),
+  })
+  .strict()
 export type LexInteger = z.infer<typeof lexInteger>
 
 export const lexStringFormat = z.enum([
@@ -43,33 +37,37 @@ export const lexStringFormat = z.enum([
   'at-identifier',
   'nsid',
   'cid',
+  'language',
 ])
 export type LexStringFormat = z.infer<typeof lexStringFormat>
 
-export const lexString = z.object({
-  type: z.literal('string'),
-  format: lexStringFormat.optional(),
-  description: z.string().optional(),
-  default: z.string().optional(),
-  minLength: z.number().int().optional(),
-  maxLength: z.number().int().optional(),
-  minGraphemes: z.number().int().optional(),
-  maxGraphemes: z.number().int().optional(),
-  enum: z.string().array().optional(),
-  const: z.string().optional(),
-  knownValues: z.string().array().optional(),
-})
+export const lexString = z
+  .object({
+    type: z.literal('string'),
+    format: lexStringFormat.optional(),
+    description: z.string().optional(),
+    default: z.string().optional(),
+    minLength: z.number().int().optional(),
+    maxLength: z.number().int().optional(),
+    minGraphemes: z.number().int().optional(),
+    maxGraphemes: z.number().int().optional(),
+    enum: z.string().array().optional(),
+    const: z.string().optional(),
+    knownValues: z.string().array().optional(),
+  })
+  .strict()
 export type LexString = z.infer<typeof lexString>
 
-export const lexUnknown = z.object({
-  type: z.literal('unknown'),
-  description: z.string().optional(),
-})
+export const lexUnknown = z
+  .object({
+    type: z.literal('unknown'),
+    description: z.string().optional(),
+  })
+  .strict()
 export type LexUnknown = z.infer<typeof lexUnknown>
 
-export const lexPrimitive = z.union([
+export const lexPrimitive = z.discriminatedUnion('type', [
   lexBoolean,
-  lexFloat,
   lexInteger,
   lexString,
   lexUnknown,
@@ -79,189 +77,288 @@ export type LexPrimitive = z.infer<typeof lexPrimitive>
 // ipld types
 // =
 
-export const lexBytes = z.object({
-  type: z.literal('bytes'),
-  description: z.string().optional(),
-  maxLength: z.number().optional(),
-  minLength: z.number().optional(),
-})
+export const lexBytes = z
+  .object({
+    type: z.literal('bytes'),
+    description: z.string().optional(),
+    maxLength: z.number().optional(),
+    minLength: z.number().optional(),
+  })
+  .strict()
 export type LexBytes = z.infer<typeof lexBytes>
 
-export const lexCidLink = z.object({
-  type: z.literal('cid-link'),
-  description: z.string().optional(),
-})
+export const lexCidLink = z
+  .object({
+    type: z.literal('cid-link'),
+    description: z.string().optional(),
+  })
+  .strict()
 export type LexCidLink = z.infer<typeof lexCidLink>
 
-export const lexIpldType = z.union([lexBytes, lexCidLink])
+export const lexIpldType = z.discriminatedUnion('type', [lexBytes, lexCidLink])
 export type LexIpldType = z.infer<typeof lexIpldType>
 
 // references
 // =
 
-export const lexRef = z.object({
-  type: z.literal('ref'),
-  description: z.string().optional(),
-  ref: z.string(),
-})
+export const lexRef = z
+  .object({
+    type: z.literal('ref'),
+    description: z.string().optional(),
+    ref: z.string(),
+  })
+  .strict()
 export type LexRef = z.infer<typeof lexRef>
 
-export const lexRefUnion = z.object({
-  type: z.literal('union'),
-  description: z.string().optional(),
-  refs: z.string().array(),
-  closed: z.boolean().optional(),
-})
+export const lexRefUnion = z
+  .object({
+    type: z.literal('union'),
+    description: z.string().optional(),
+    refs: z.string().array(),
+    closed: z.boolean().optional(),
+  })
+  .strict()
 export type LexRefUnion = z.infer<typeof lexRefUnion>
 
-export const lexRefVariant = z.union([lexRef, lexRefUnion])
+export const lexRefVariant = z.discriminatedUnion('type', [lexRef, lexRefUnion])
 export type LexRefVariant = z.infer<typeof lexRefVariant>
 
 // blobs
 // =
 
-export const lexBlob = z.object({
-  type: z.literal('blob'),
-  description: z.string().optional(),
-  accept: z.string().array().optional(),
-  maxSize: z.number().optional(),
-})
+export const lexBlob = z
+  .object({
+    type: z.literal('blob'),
+    description: z.string().optional(),
+    accept: z.string().array().optional(),
+    maxSize: z.number().optional(),
+  })
+  .strict()
 export type LexBlob = z.infer<typeof lexBlob>
 
 // complex types
 // =
 
-export const lexArray = z.object({
-  type: z.literal('array'),
-  description: z.string().optional(),
-  items: z.union([lexPrimitive, lexIpldType, lexBlob, lexRefVariant]),
-  minLength: z.number().int().optional(),
-  maxLength: z.number().int().optional(),
-})
+export const lexArray = z
+  .object({
+    type: z.literal('array'),
+    description: z.string().optional(),
+    items: z.union([lexPrimitive, lexIpldType, lexBlob, lexRefVariant]),
+    minLength: z.number().int().optional(),
+    maxLength: z.number().int().optional(),
+  })
+  .strict()
 export type LexArray = z.infer<typeof lexArray>
 
 export const lexPrimitiveArray = lexArray.merge(
-  z.object({
-    items: lexPrimitive,
-  }),
+  z
+    .object({
+      items: lexPrimitive,
+    })
+    .strict(),
 )
 export type LexPrimitiveArray = z.infer<typeof lexPrimitiveArray>
 
-export const lexToken = z.object({
-  type: z.literal('token'),
-  description: z.string().optional(),
-})
+export const lexToken = z
+  .object({
+    type: z.literal('token'),
+    description: z.string().optional(),
+  })
+  .strict()
 export type LexToken = z.infer<typeof lexToken>
 
-export const lexObject = z.object({
-  type: z.literal('object'),
-  description: z.string().optional(),
-  required: z.string().array().optional(),
-  nullable: z.string().array().optional(),
-  properties: z
-    .record(
-      z.union([lexRefVariant, lexIpldType, lexArray, lexBlob, lexPrimitive]),
-    )
-    .optional(),
-})
+export const lexObject = z
+  .object({
+    type: z.literal('object'),
+    description: z.string().optional(),
+    required: z.string().array().optional(),
+    nullable: z.string().array().optional(),
+    properties: z
+      .record(
+        z.union([lexRefVariant, lexIpldType, lexArray, lexBlob, lexPrimitive]),
+      )
+      .optional(),
+  })
+  .strict()
+  .superRefine(requiredPropertiesRefinement)
 export type LexObject = z.infer<typeof lexObject>
 
 // xrpc
 // =
 
-export const lexXrpcParameters = z.object({
-  type: z.literal('params'),
-  description: z.string().optional(),
-  required: z.string().array().optional(),
-  properties: z.record(z.union([lexPrimitive, lexPrimitiveArray])),
-})
+export const lexXrpcParameters = z
+  .object({
+    type: z.literal('params'),
+    description: z.string().optional(),
+    required: z.string().array().optional(),
+    properties: z.record(z.union([lexPrimitive, lexPrimitiveArray])),
+  })
+  .strict()
+  .superRefine(requiredPropertiesRefinement)
 export type LexXrpcParameters = z.infer<typeof lexXrpcParameters>
 
-export const lexXrpcBody = z.object({
-  description: z.string().optional(),
-  encoding: z.string(),
-  schema: z.union([lexRefVariant, lexObject]).optional(),
-})
+export const lexXrpcBody = z
+  .object({
+    description: z.string().optional(),
+    encoding: z.string(),
+    schema: z.union([lexRefVariant, lexObject]).optional(),
+  })
+  .strict()
 export type LexXrpcBody = z.infer<typeof lexXrpcBody>
 
-export const lexXrpcSubscriptionMessage = z.object({
-  description: z.string().optional(),
-  schema: z.union([lexRefVariant, lexObject]).optional(),
-})
+export const lexXrpcSubscriptionMessage = z
+  .object({
+    description: z.string().optional(),
+    schema: z.union([lexRefVariant, lexObject]).optional(),
+  })
+  .strict()
 export type LexXrpcSubscriptionMessage = z.infer<
   typeof lexXrpcSubscriptionMessage
 >
 
-export const lexXrpcError = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-})
+export const lexXrpcError = z
+  .object({
+    name: z.string(),
+    description: z.string().optional(),
+  })
+  .strict()
 export type LexXrpcError = z.infer<typeof lexXrpcError>
 
-export const lexXrpcQuery = z.object({
-  type: z.literal('query'),
-  description: z.string().optional(),
-  parameters: lexXrpcParameters.optional(),
-  output: lexXrpcBody.optional(),
-  errors: lexXrpcError.array().optional(),
-})
+export const lexXrpcQuery = z
+  .object({
+    type: z.literal('query'),
+    description: z.string().optional(),
+    parameters: lexXrpcParameters.optional(),
+    output: lexXrpcBody.optional(),
+    errors: lexXrpcError.array().optional(),
+  })
+  .strict()
 export type LexXrpcQuery = z.infer<typeof lexXrpcQuery>
 
-export const lexXrpcProcedure = z.object({
-  type: z.literal('procedure'),
-  description: z.string().optional(),
-  parameters: lexXrpcParameters.optional(),
-  input: lexXrpcBody.optional(),
-  output: lexXrpcBody.optional(),
-  errors: lexXrpcError.array().optional(),
-})
+export const lexXrpcProcedure = z
+  .object({
+    type: z.literal('procedure'),
+    description: z.string().optional(),
+    parameters: lexXrpcParameters.optional(),
+    input: lexXrpcBody.optional(),
+    output: lexXrpcBody.optional(),
+    errors: lexXrpcError.array().optional(),
+  })
+  .strict()
 export type LexXrpcProcedure = z.infer<typeof lexXrpcProcedure>
 
-export const lexXrpcSubscription = z.object({
-  type: z.literal('subscription'),
-  description: z.string().optional(),
-  parameters: lexXrpcParameters.optional(),
-  message: lexXrpcSubscriptionMessage.optional(),
-  infos: lexXrpcError.array().optional(),
-  errors: lexXrpcError.array().optional(),
-})
+export const lexXrpcSubscription = z
+  .object({
+    type: z.literal('subscription'),
+    description: z.string().optional(),
+    parameters: lexXrpcParameters.optional(),
+    message: lexXrpcSubscriptionMessage.optional(),
+    errors: lexXrpcError.array().optional(),
+  })
+  .strict()
 export type LexXrpcSubscription = z.infer<typeof lexXrpcSubscription>
 
 // database
 // =
 
-export const lexRecord = z.object({
-  type: z.literal('record'),
-  description: z.string().optional(),
-  key: z.string().optional(),
-  record: lexObject,
-})
+export const lexRecord = z
+  .object({
+    type: z.literal('record'),
+    description: z.string().optional(),
+    key: z.string().optional(),
+    record: lexObject,
+  })
+  .strict()
 export type LexRecord = z.infer<typeof lexRecord>
 
 // core
 // =
 
-export const lexUserType = z.union([
-  lexRecord,
+// We need to use `z.custom` here because
+// lexXrpcProperty and lexObject are refined
+// `z.union` would work, but it's too slow
+// see #915 for details
+export const lexUserType = z.custom<
+  | LexRecord
+  | LexXrpcQuery
+  | LexXrpcProcedure
+  | LexXrpcSubscription
+  | LexBlob
+  | LexArray
+  | LexToken
+  | LexObject
+  | LexBoolean
+  | LexInteger
+  | LexString
+  | LexBytes
+  | LexCidLink
+  | LexUnknown
+>(
+  (val) => {
+    if (!val || typeof val !== 'object') {
+      return
+    }
 
-  lexXrpcQuery,
-  lexXrpcProcedure,
-  lexXrpcSubscription,
+    if (val['type'] === undefined) {
+      return
+    }
 
-  lexBlob,
+    switch (val['type']) {
+      case 'record':
+        return lexRecord.parse(val)
+
+      case 'query':
+        return lexXrpcQuery.parse(val)
+      case 'procedure':
+        return lexXrpcProcedure.parse(val)
+      case 'subscription':
+        return lexXrpcSubscription.parse(val)
+
+      case 'blob':
+        return lexBlob.parse(val)
+
+      case 'array':
+        return lexArray.parse(val)
+      case 'token':
+        return lexToken.parse(val)
+      case 'object':
+        return lexObject.parse(val)
+
+      case 'boolean':
+        return lexBoolean.parse(val)
+      case 'integer':
+        return lexInteger.parse(val)
+      case 'string':
+        return lexString.parse(val)
+      case 'bytes':
+        return lexBytes.parse(val)
+      case 'cid-link':
+        return lexCidLink.parse(val)
+      case 'unknown':
+        return lexUnknown.parse(val)
+    }
+  },
+  (val) => {
+    if (!val || typeof val !== 'object') {
+      return {
+        message: 'Must be an object',
+        fatal: true,
+      }
+    }
 
-  lexArray,
-  lexToken,
-  lexObject,
+    if (val['type'] === undefined) {
+      return {
+        message: 'Must have a type',
+        fatal: true,
+      }
+    }
 
-  lexBoolean,
-  lexFloat,
-  lexInteger,
-  lexString,
-  lexBytes,
-  lexCidLink,
-  lexUnknown,
-])
+    return {
+      message: `Invalid type: ${val['type']} must be one of: record, query, procedure, subscription, blob, array, token, object, boolean, integer, string, bytes, cid-link, unknown`,
+      fatal: true,
+    }
+  },
+)
 export type LexUserType = z.infer<typeof lexUserType>
 
 export const lexiconDoc = z
@@ -274,7 +371,8 @@ export const lexiconDoc = z
     description: z.string().optional(),
     defs: z.record(lexUserType),
   })
-  .superRefine((doc: LexiconDoc, ctx) => {
+  .strict()
+  .superRefine((doc, ctx) => {
     for (const defId in doc.defs) {
       const def = doc.defs[defId]
       if (

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')
+  }
+}