@atproto/lexicon 0.0.4 → 0.2.0

package/src/types.ts

@@ -1,245 +1,364 @@
 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 lexNumber = z.object({
-  type: z.literal('number'),
-  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 LexNumber = z.infer<typeof lexNumber>
-
-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 lexString = z.object({
-  type: z.literal('string'),
-  description: z.string().optional(),
-  default: z.string().optional(),
-  minLength: z.number().int().optional(),
-  maxLength: z.number().int().optional(),
-  enum: z.string().array().optional(),
-  const: z.string().optional(),
-  knownValues: z.string().array().optional(),
-})
-export type LexString = z.infer<typeof lexString>
+export const lexStringFormat = z.enum([
+  'datetime',
+  'uri',
+  'at-uri',
+  'did',
+  'handle',
+  'at-identifier',
+  'nsid',
+  'cid',
+  'language',
+])
+export type LexStringFormat = z.infer<typeof lexStringFormat>
 
-export const lexDatetime = z.object({
-  type: z.literal('datetime'),
-  description: z.string().optional(),
-})
-export type LexDatetime = z.infer<typeof lexDatetime>
+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,
-  lexNumber,
   lexInteger,
   lexString,
-  lexDatetime,
   lexUnknown,
 ])
 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(),
+  })
+  .strict()
+export type LexBytes = z.infer<typeof lexBytes>
+
+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.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>
 
-export const lexImage = z.object({
-  type: z.literal('image'),
-  description: z.string().optional(),
-  accept: z.string().array().optional(),
-  maxSize: z.number().optional(),
-  maxWidth: z.number().int().optional(),
-  maxHeight: z.number().int().optional(),
-})
-export type LexImage = z.infer<typeof lexImage>
-
-export const lexVideo = z.object({
-  type: z.literal('video'),
-  description: z.string().optional(),
-  accept: z.string().array().optional(),
-  maxSize: z.number().optional(),
-  maxWidth: z.number().int().optional(),
-  maxHeight: z.number().int().optional(),
-  maxLength: z.number().int().optional(),
-})
-export type LexVideo = z.infer<typeof lexVideo>
-
-export const lexAudio = z.object({
-  type: z.literal('audio'),
-  description: z.string().optional(),
-  accept: z.string().array().optional(),
-  maxSize: z.number().optional(),
-  maxLength: z.number().int().optional(),
-})
-export type LexAudio = z.infer<typeof lexAudio>
-
-export const lexBlobVariant = z.union([lexBlob, lexImage, lexVideo, lexAudio])
-export type LexBlobVariant = z.infer<typeof lexBlobVariant>
-
 // complex types
 // =
 
-export const lexArray = z.object({
-  type: z.literal('array'),
-  description: z.string().optional(),
-  items: z.union([lexPrimitive, lexBlobVariant, 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 lexToken = z.object({
-  type: z.literal('token'),
-  description: z.string().optional(),
-})
+export const lexPrimitiveArray = lexArray.merge(
+  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(),
+  })
+  .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(),
-  properties: z
-    .record(z.union([lexRefVariant, lexArray, lexBlobVariant, 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(lexPrimitive),
-})
+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 lexXrpcError = z.object({
-  name: z.string(),
-  description: z.string().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(),
+  })
+  .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(),
+    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,
+    if (val['type'] === undefined) {
+      return
+    }
 
-  lexBlob,
-  lexImage,
-  lexVideo,
-  lexAudio,
+    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,
-  lexNumber,
-  lexInteger,
-  lexString,
-  lexDatetime,
-  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
@@ -252,18 +371,20 @@ 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 (
         defId !== 'main' &&
         (def.type === 'record' ||
           def.type === 'procedure' ||
-          def.type === 'query')
+          def.type === 'query' ||
+          def.type === 'subscription')
       ) {
         ctx.addIssue({
           code: z.ZodIssueCode.custom,
-          message: `Records, procedures, and queries must be the main definition.`,
+          message: `Records, procedures, queries, and subscriptions must be the main definition.`,
         })
       }
     }
@@ -308,10 +429,15 @@ export class LexiconDocMalformedError extends Error {
   }
 }
 
-export interface ValidationResult {
-  success: boolean
-  error?: ValidationError
-}
+export type ValidationResult =
+  | {
+      success: true
+      value: unknown
+    }
+  | {
+      success: false
+      error: ValidationError
+    }
 
 export class ValidationError extends Error {}
 export class InvalidLexiconError extends Error {}

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,
@@ -49,7 +54,7 @@ export function validateOneOf(
           ),
         }
       }
-      return { success: true }
+      return { success: true, value }
     } else {
       concreteDefs = toConcreteTypes(lexicons, {
         type: 'ref',
@@ -88,9 +93,8 @@ export function assertValidOneOf(
   mustBeObj = false,
 ) {
   const res = validateOneOf(lexicons, path, def, value, mustBeObj)
-  if (!res.success) {
-    throw res.error
-  }
+  if (!res.success) throw res.error
+  return res.value
 }
 
 export function toConcreteTypes(
@@ -105,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')
+  }
+}