@atproto/lex-document 0.0.3 → 0.0.4

package/src/lexicon-document.ts

@@ -1,98 +1,75 @@
 import { l } from '@atproto/lex-schema'
 
+// Re-usable shortcuts (avoid creating too many schemas)
+
+const bool = l.boolean()
+const int = l.integer()
+const str = l.string()
+
+const boopOpt = l.optional(bool)
+const intOpt = l.optional(int)
+const strOpt = l.optional(str)
+
+const strArrOpt = l.optional(l.array(str))
+
 // https://atproto.com/specs/lexicon
 
 // "Concrete" Types
 
-export const lexiconBooleanSchema = l.object(
-  {
-    type: l.literal('boolean'),
-    description: l.string(),
-    default: l.boolean(),
-    const: l.boolean(),
-  },
-  {
-    required: ['type'],
-  },
-)
+export const lexiconBooleanSchema = l.object({
+  type: l.literal('boolean'),
+  default: boopOpt,
+  const: boopOpt,
+  description: strOpt,
+})
 export type LexiconBoolean = l.Infer<typeof lexiconBooleanSchema>
 
-export const lexiconIntegerSchema = l.object(
-  {
-    type: l.literal('integer'),
-    description: l.string(),
-    default: l.integer(),
-    minimum: l.integer(),
-    maximum: l.integer(),
-    enum: l.array(l.integer()),
-    const: l.integer(),
-  },
-  {
-    required: ['type'],
-  },
-)
+export const lexiconIntegerSchema = l.object({
+  type: l.literal('integer'),
+  default: intOpt,
+  minimum: intOpt,
+  maximum: intOpt,
+  enum: l.optional(l.array(l.integer())),
+  const: intOpt,
+  description: strOpt,
+})
 export type LexiconInteger = l.Infer<typeof lexiconIntegerSchema>
 
-export type LexiconStringFormat = l.StringFormat
-export const lexiconStringFormatSchema = l.enum<LexiconStringFormat>(
-  l.STRING_FORMATS,
-)
-
-export const lexiconStringSchema = l.object(
-  {
-    type: l.literal('string'),
-    format: lexiconStringFormatSchema,
-    description: l.string(),
-    default: l.string(),
-    minLength: l.integer(),
-    maxLength: l.integer(),
-    minGraphemes: l.integer(),
-    maxGraphemes: l.integer(),
-    enum: l.array(l.string()),
-    const: l.string(),
-    knownValues: l.array(l.string()),
-  },
-  {
-    required: ['type'],
-  },
-)
+export const lexiconStringSchema = l.object({
+  type: l.literal('string'),
+  format: l.optional(l.enum<l.StringFormat>(l.STRING_FORMATS)),
+  default: strOpt,
+  minLength: intOpt,
+  maxLength: intOpt,
+  minGraphemes: intOpt,
+  maxGraphemes: intOpt,
+  enum: strArrOpt,
+  const: strOpt,
+  knownValues: strArrOpt,
+  description: strOpt,
+})
 export type LexiconString = l.Infer<typeof lexiconStringSchema>
 
-export const lexiconBytesSchema = l.object(
-  {
-    type: l.literal('bytes'),
-    description: l.string(),
-    maxLength: l.integer(),
-    minLength: l.integer(),
-  },
-  {
-    required: ['type'],
-  },
-)
+export const lexiconBytesSchema = l.object({
+  type: l.literal('bytes'),
+  maxLength: intOpt,
+  minLength: intOpt,
+  description: strOpt,
+})
 export type LexiconBytes = l.Infer<typeof lexiconBytesSchema>
 
-export const lexiconCidLinkSchema = l.object(
-  {
-    type: l.literal('cid-link'),
-    description: l.string(),
-  },
-  {
-    required: ['type'],
-  },
-)
+export const lexiconCidLinkSchema = l.object({
+  type: l.literal('cid-link'),
+  description: strOpt,
+})
 export type LexiconCid = l.Infer<typeof lexiconCidLinkSchema>
 
-export const lexiconBlobSchema = l.object(
-  {
-    type: l.literal('blob'),
-    description: l.string(),
-    accept: l.array(l.string()),
-    maxSize: l.integer(),
-  },
-  {
-    required: ['type'],
-  },
-)
+export const lexiconBlobSchema = l.object({
+  type: l.literal('blob'),
+  accept: strArrOpt,
+  maxSize: intOpt,
+  description: strOpt,
+})
 export type LexiconBlob = l.Infer<typeof lexiconBlobSchema>
 
 const CONCRETE_TYPES = [
@@ -108,51 +85,31 @@ const CONCRETE_TYPES = [
 
 // Meta types
 
-export const lexiconUnknownSchema = l.object(
-  {
-    type: l.literal('unknown'),
-    description: l.string(),
-  },
-  {
-    required: ['type'],
-  },
-)
+export const lexiconUnknownSchema = l.object({
+  type: l.literal('unknown'),
+  description: strOpt,
+})
 export type LexiconUnknown = l.Infer<typeof lexiconUnknownSchema>
 
-export const lexiconTokenSchema = l.object(
-  {
-    type: l.literal('token'),
-    description: l.string(),
-  },
-  {
-    required: ['type'],
-  },
-)
+export const lexiconTokenSchema = l.object({
+  type: l.literal('token'),
+  description: strOpt,
+})
 export type LexiconToken = l.Infer<typeof lexiconTokenSchema>
 
-export const lexiconRefSchema = l.object(
-  {
-    type: l.literal('ref'),
-    description: l.string(),
-    ref: l.string(),
-  },
-  {
-    required: ['type', 'ref'],
-  },
-)
+export const lexiconRefSchema = l.object({
+  type: l.literal('ref'),
+  ref: str,
+  description: strOpt,
+})
 export type LexiconRef = l.Infer<typeof lexiconRefSchema>
 
-export const lexiconRefUnionSchema = l.object(
-  {
-    type: l.literal('union'),
-    description: l.string(),
-    refs: l.array(l.string()),
-    closed: l.boolean(),
-  },
-  {
-    required: ['type', 'refs'],
-  },
-)
+export const lexiconRefUnionSchema = l.object({
+  type: l.literal('union'),
+  refs: l.array(str),
+  closed: boopOpt,
+  description: strOpt,
+})
 export type LexiconRefUnion = l.Infer<typeof lexiconRefUnionSchema>
 
 // Complex Types
@@ -167,171 +124,149 @@ const ARRAY_ITEMS_SCHEMAS = [
 
 export type LexiconArrayItems = l.Infer<(typeof ARRAY_ITEMS_SCHEMAS)[number]>
 
-export const lexiconArraySchema = l.object(
-  {
-    type: l.literal('array'),
-    description: l.string(),
-    items: l.discriminatedUnion('type', ARRAY_ITEMS_SCHEMAS),
-    minLength: l.integer(),
-    maxLength: l.integer(),
-  },
-  {
-    required: ['type', 'items'],
-  },
-)
+export const lexiconArraySchema = l.object({
+  type: l.literal('array'),
+  items: l.discriminatedUnion('type', ARRAY_ITEMS_SCHEMAS),
+  minLength: intOpt,
+  maxLength: intOpt,
+  description: strOpt,
+})
 export type LexiconArray = l.Infer<typeof lexiconArraySchema>
 
-export const lexiconObjectSchema = l.object(
-  {
+const requirePropertiesRefinement: l.RefinementCheck<{
+  required?: string[]
+  properties: Record<string, unknown>
+}> = {
+  check: (v) => !v.required || v.required.every((k) => k in v.properties),
+  message: 'All required parameters must be defined in properties',
+  path: 'required',
+}
+
+export const lexiconObjectSchema = l.refine(
+  l.object({
     type: l.literal('object'),
-    description: l.string(),
-    required: l.array(l.string()),
-    nullable: l.array(l.string()),
     properties: l.dict(
-      l.string(),
+      str,
       l.discriminatedUnion('type', [
         ...ARRAY_ITEMS_SCHEMAS,
         lexiconArraySchema,
       ]),
     ),
-  },
-  {
-    required: ['type', 'properties'],
-  },
+    required: strArrOpt,
+    nullable: strArrOpt,
+    description: strOpt,
+  }),
+  requirePropertiesRefinement,
 )
 export type LexiconObject = l.Infer<typeof lexiconObjectSchema>
 
 // Records
 
-export const lexiconRecordSchema = l.object(
-  {
-    type: l.literal('record'),
-    description: l.string(),
-    key: l.string(),
-    record: lexiconObjectSchema,
-  },
-  { required: ['type', 'record'] },
+export const lexiconRecordKeySchema = l.custom(
+  l.isLexiconRecordKey,
+  'Invalid record key definition (must be "any", "nsid", "tid", or "literal:<string>")',
 )
+
+export type LexiconRecordKey = l.LexiconRecordKey
+
+export const lexiconRecordSchema = l.object({
+  type: l.literal('record'),
+  record: lexiconObjectSchema,
+  description: strOpt,
+  key: lexiconRecordKeySchema,
+})
 export type LexiconRecord = l.Infer<typeof lexiconRecordSchema>
 
 // XRPC Methods
 
-export const lexiconParameters = l.object(
-  {
+export const lexiconParameters = l.refine(
+  l.object({
     type: l.literal('params'),
-    description: l.string(),
-    required: l.array(l.string()),
     properties: l.dict(
-      l.string(),
+      str,
       l.discriminatedUnion('type', [
         lexiconBooleanSchema,
         lexiconIntegerSchema,
         lexiconStringSchema,
-        l.object(
-          {
-            type: l.literal('array'),
-            description: l.string(),
-            items: l.discriminatedUnion('type', [
-              lexiconBooleanSchema,
-              lexiconIntegerSchema,
-              lexiconStringSchema,
-            ]),
-            minLength: l.integer(),
-            maxLength: l.integer(),
-          },
-          {
-            required: ['type', 'items'],
-          },
-        ),
+        l.object({
+          type: l.literal('array'),
+          items: l.discriminatedUnion('type', [
+            lexiconBooleanSchema,
+            lexiconIntegerSchema,
+            lexiconStringSchema,
+          ]),
+          minLength: intOpt,
+          maxLength: intOpt,
+          description: strOpt,
+        }),
       ]),
     ),
-  },
-  {
-    required: ['type', 'properties'],
-  },
+    required: strArrOpt,
+    description: strOpt,
+  }),
+  requirePropertiesRefinement,
 )
 export type LexiconParameters = l.Infer<typeof lexiconParameters>
 
-export const lexiconPayload = l.object(
-  {
-    description: l.string(),
-    encoding: l.string(),
-    schema: l.discriminatedUnion('type', [
+export const lexiconPayload = l.object({
+  encoding: str,
+  schema: l.optional(
+    l.discriminatedUnion('type', [
       lexiconRefSchema,
       lexiconRefUnionSchema,
       lexiconObjectSchema,
     ]),
-  },
-  {
-    required: ['encoding'],
-  },
-)
+  ),
+  description: strOpt,
+})
 export type LexiconPayload = l.Infer<typeof lexiconPayload>
 
 export const lexiconSubscriptionMessage = l.object({
-  description: l.string(),
-  schema: l.discriminatedUnion('type', [
-    lexiconRefSchema,
-    lexiconRefUnionSchema,
-    lexiconObjectSchema,
-  ]),
+  description: strOpt,
+  schema: l.optional(
+    l.discriminatedUnion('type', [
+      lexiconRefSchema,
+      lexiconRefUnionSchema,
+      lexiconObjectSchema,
+    ]),
+  ),
 })
 export type LexiconSubscriptionMessage = l.Infer<
   typeof lexiconSubscriptionMessage
 >
 
-export const lexiconError = l.object(
-  {
-    name: l.string({ minLength: 1 }),
-    description: l.string(),
-  },
-  {
-    required: ['name'],
-  },
-)
+export const lexiconError = l.object({
+  name: l.string({ minLength: 1 }),
+  description: strOpt,
+})
 export type LexiconError = l.Infer<typeof lexiconError>
 
-export const lexiconQuerySchema = l.object(
-  {
-    type: l.literal('query'),
-    description: l.string(),
-    parameters: lexiconParameters,
-    output: lexiconPayload,
-    errors: l.array(lexiconError),
-  },
-  {
-    required: ['type'],
-  },
-)
+export const lexiconQuerySchema = l.object({
+  type: l.literal('query'),
+  parameters: l.optional(lexiconParameters),
+  output: l.optional(lexiconPayload),
+  errors: l.optional(l.array(lexiconError)),
+  description: strOpt,
+})
 export type LexiconQuery = l.Infer<typeof lexiconQuerySchema>
 
-export const lexiconProcedureSchema = l.object(
-  {
-    type: l.literal('procedure'),
-    description: l.string(),
-    parameters: lexiconParameters,
-    input: lexiconPayload,
-    output: lexiconPayload,
-    errors: l.array(lexiconError),
-  },
-  {
-    required: ['type'],
-  },
-)
+export const lexiconProcedureSchema = l.object({
+  type: l.literal('procedure'),
+  parameters: l.optional(lexiconParameters),
+  input: l.optional(lexiconPayload),
+  output: l.optional(lexiconPayload),
+  errors: l.optional(l.array(lexiconError)),
+  description: strOpt,
+})
 export type LexiconProcedure = l.Infer<typeof lexiconProcedureSchema>
 
-export const lexiconSubscriptionSchema = l.object(
-  {
-    type: l.literal('subscription'),
-    description: l.string(),
-    parameters: lexiconParameters,
-    message: lexiconSubscriptionMessage,
-    errors: l.array(lexiconError),
-  },
-  {
-    required: ['type'],
-  },
-)
+export const lexiconSubscriptionSchema = l.object({
+  type: l.literal('subscription'),
+  description: strOpt,
+  parameters: l.optional(lexiconParameters),
+  message: l.optional(lexiconSubscriptionMessage),
+  errors: l.optional(l.array(lexiconError)),
+})
 
 export type LexiconSubscription = l.Infer<typeof lexiconSubscriptionSchema>
 
@@ -341,37 +276,29 @@ const lexiconLanguageSchema = l.string({ format: 'language' })
 
 export type LexiconLanguage = l.Infer<typeof lexiconLanguageSchema>
 
-const lexiconLanguageDict = l.dict(lexiconLanguageSchema, l.string())
+const lexiconLanguageDict = l.dict(lexiconLanguageSchema, str)
 
 export type LexiconLanguageDict = l.Infer<typeof lexiconLanguageDict>
 
-const lexiconPermissionSchema = l.object(
-  {
+const lexiconPermissionSchema = l.intersection(
+  l.object({
     type: l.literal('permission'),
     resource: l.string({ minLength: 1 }),
-  },
-  {
-    required: ['type', 'resource'],
-    unknownProperties: l.paramsSchema,
-  },
+  }),
+  l.paramsSchema,
 )
 
 export type LexiconPermission = l.Infer<typeof lexiconPermissionSchema>
 
-const lexiconPermissionSetSchema = l.object(
-  {
-    type: l.literal('permission-set'),
-    description: l.string(),
-    title: l.string(),
-    'title:lang': lexiconLanguageDict,
-    detail: l.string(),
-    'detail:lang': lexiconLanguageDict,
-    permissions: l.array(lexiconPermissionSchema),
-  },
-  {
-    required: ['type', 'permissions'],
-  },
-)
+const lexiconPermissionSetSchema = l.object({
+  type: l.literal('permission-set'),
+  permissions: l.array(lexiconPermissionSchema),
+  title: strOpt,
+  'title:lang': l.optional(lexiconLanguageDict),
+  detail: strOpt,
+  'detail:lang': l.optional(lexiconLanguageDict),
+  description: strOpt,
+})
 
 export type LexiconPermissionSet = l.Infer<typeof lexiconPermissionSetSchema>
 
@@ -404,24 +331,19 @@ export type MainLexiconDefinition = l.Infer<
 export const lexiconIdentifierSchema = l.string({ format: 'nsid' })
 export type LexiconIdentifier = l.Infer<typeof lexiconIdentifierSchema>
 
-export const lexiconDocumentSchema = l.object(
-  {
-    lexicon: l.literal(1),
-    id: lexiconIdentifierSchema,
-    revision: l.integer(),
-    description: l.string(),
-    defs: l.object(
-      { main: l.discriminatedUnion('type', MAIN_LEXICON_SCHEMAS) },
-      {
-        unknownProperties: l.dict(
-          l.string({ minLength: 1 }),
-          l.discriminatedUnion('type', NAMED_LEXICON_SCHEMAS),
-        ),
-      },
+export const lexiconDocumentSchema = l.object({
+  lexicon: l.literal(1),
+  id: lexiconIdentifierSchema,
+  revision: intOpt,
+  description: strOpt,
+  defs: l.intersection(
+    l.object({
+      main: l.optional(l.discriminatedUnion('type', MAIN_LEXICON_SCHEMAS)),
+    }),
+    l.dict(
+      l.string({ minLength: 1 }),
+      l.discriminatedUnion('type', NAMED_LEXICON_SCHEMAS),
     ),
-  },
-  {
-    required: ['lexicon', 'id', 'defs'],
-  },
-)
+  ),
+})
 export type LexiconDocument = l.Infer<typeof lexiconDocumentSchema>