@atproto/lexicon 0.7.3 → 0.7.4

package/src/serialize.ts

@@ -1,102 +0,0 @@
-import { CID } from 'multiformats/cid'
-import {
-  IpldValue,
-  JsonValue,
-  check,
-  ipldToJson,
-  jsonToIpld,
-} from '@atproto/common-web'
-import { BlobRef, jsonBlobRef } from './blob-refs.js'
-
-/**
- * @note this is equivalent to `unknown` because of {@link IpldValue} being `unknown`.
- * @deprecated Use {@link Lex} from `@atproto/lex-data` instead.
- */
-export type LexValue = unknown
-
-/**
- * @deprecated Use {@link TypedLexMap} from `@atproto/lex-data` instead.
- */
-export type RepoRecord = Record<string, LexValue>
-
-// @NOTE avoiding use of check.is() here only because it makes
-// these implementations slow, and they often live in hot paths.
-
-/**
- * @deprecated Use `LexValue` from `@atproto/lex-data` instead (which doesn't need conversion to IPLD).
- */
-export const lexToIpld = (val: LexValue): IpldValue => {
-  // walk arrays
-  if (Array.isArray(val)) {
-    return val.map((item) => lexToIpld(item))
-  }
-  // objects
-  if (val && typeof val === 'object') {
-    // convert blobs, leaving the original encoding so that we don't change CIDs on re-encode
-    if (val instanceof BlobRef) {
-      return val.original
-    }
-    // retain cids & bytes
-    if (CID.asCID(val) || val instanceof Uint8Array) {
-      return val
-    }
-    // walk plain objects
-    const toReturn = {}
-    for (const key of Object.keys(val)) {
-      toReturn[key] = lexToIpld(val[key])
-    }
-    return toReturn
-  }
-  // pass through
-  return val
-}
-
-/**
- * @deprecated Use `LexValue` from `@atproto/lex-data` instead instead (which doesn't need conversion to IPLD).
- */
-export const ipldToLex = (val: IpldValue): LexValue => {
-  // map arrays
-  if (Array.isArray(val)) {
-    return val.map((item) => ipldToLex(item))
-  }
-  // objects
-  if (val && typeof val === 'object') {
-    // convert blobs, using hints to avoid expensive is() check
-    if (
-      (val['$type'] === 'blob' ||
-        (typeof val['cid'] === 'string' &&
-          typeof val['mimeType'] === 'string')) &&
-      check.is(val, jsonBlobRef)
-    ) {
-      return BlobRef.fromJsonRef(val)
-    }
-    // retain cids, bytes
-    if (CID.asCID(val) || val instanceof Uint8Array) {
-      return val
-    }
-    // map plain objects
-    const toReturn = {}
-    for (const key of Object.keys(val)) {
-      toReturn[key] = ipldToLex(val[key])
-    }
-    return toReturn
-  }
-  // pass through
-  return val
-}
-
-export const lexToJson = (val: LexValue): JsonValue => {
-  return ipldToJson(lexToIpld(val))
-}
-
-export const stringifyLex = (val: LexValue): string => {
-  return JSON.stringify(lexToJson(val))
-}
-
-export const jsonToLex = (val: JsonValue): LexValue => {
-  return ipldToLex(jsonToIpld(val))
-}
-
-export const jsonStringToLex = (val: string): LexValue => {
-  return jsonToLex(JSON.parse(val))
-}

package/src/types.ts

@@ -1,483 +0,0 @@
-import { z } from 'zod'
-import { validateLanguage } from '@atproto/common-web'
-import { isValidNsid } from '@atproto/syntax'
-import { requiredPropertiesRefinement } from './util.js'
-
-export const languageSchema = z
-  .string()
-  .refine(validateLanguage, 'Invalid BCP47 language tag')
-
-export const lexLang = z.record(languageSchema, z.string().optional())
-
-export type LexLang = z.infer<typeof lexLang>
-
-// primitives
-// =
-
-export const lexBoolean = z.object({
-  type: z.literal('boolean'),
-  description: z.string().optional(),
-  default: z.boolean().optional(),
-  const: z.boolean().optional(),
-})
-export type LexBoolean = z.infer<typeof lexBoolean>
-
-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 type LexInteger = z.infer<typeof lexInteger>
-
-export const lexStringFormat = z.enum([
-  'datetime',
-  'uri',
-  'at-uri',
-  'did',
-  'handle',
-  'at-identifier',
-  'nsid',
-  'cid',
-  'language',
-  'tid',
-  'record-key',
-])
-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 type LexString = z.infer<typeof lexString>
-
-export const lexUnknown = z.object({
-  type: z.literal('unknown'),
-  description: z.string().optional(),
-})
-export type LexUnknown = z.infer<typeof lexUnknown>
-
-export const lexPrimitive = z.discriminatedUnion('type', [
-  lexBoolean,
-  lexInteger,
-  lexString,
-  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(),
-})
-export type LexBytes = z.infer<typeof lexBytes>
-
-export const lexCidLink = z.object({
-  type: z.literal('cid-link'),
-  description: z.string().optional(),
-})
-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 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 type LexRefUnion = z.infer<typeof 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 type LexBlob = z.infer<typeof lexBlob>
-
-// complex types
-// =
-
-export const lexArray = z.object({
-  type: z.literal('array'),
-  description: z.string().optional(),
-  items: z.discriminatedUnion('type', [
-    // lexPrimitive
-    lexBoolean,
-    lexInteger,
-    lexString,
-    lexUnknown,
-    // lexIpldType
-    lexBytes,
-    lexCidLink,
-    // lexRefVariant
-    lexRef,
-    lexRefUnion,
-    // other
-    lexBlob,
-  ]),
-  minLength: z.number().int().optional(),
-  maxLength: z.number().int().optional(),
-})
-export type LexArray = z.infer<typeof lexArray>
-
-export const lexPrimitiveArray = lexArray.merge(
-  z.object({
-    items: lexPrimitive,
-  }),
-)
-export type LexPrimitiveArray = z.infer<typeof lexPrimitiveArray>
-
-export const lexToken = z.object({
-  type: z.literal('token'),
-  description: z.string().optional(),
-})
-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.string(),
-      z.discriminatedUnion('type', [
-        lexArray,
-
-        // lexPrimitive
-        lexBoolean,
-        lexInteger,
-        lexString,
-        lexUnknown,
-        // lexIpldType
-        lexBytes,
-        lexCidLink,
-        // lexRefVariant
-        lexRef,
-        lexRefUnion,
-        // other
-        lexBlob,
-      ]),
-    ),
-  })
-  .superRefine(requiredPropertiesRefinement)
-export type LexObject = z.infer<typeof lexObject>
-
-// permissions
-// =
-
-const lexPermission = z.intersection(
-  z.object({
-    type: z.literal('permission'),
-    resource: z.string().nonempty(),
-  }),
-  z.record(
-    z.string(),
-    z
-      .union([
-        z.array(z.union([z.string(), z.number().int(), z.boolean()])),
-
-        z.boolean(),
-        z.number().int(),
-        z.string(),
-      ])
-      .optional(),
-  ),
-)
-
-export type LexPermission = z.infer<typeof lexPermission>
-
-export const lexPermissionSet = z.object({
-  type: z.literal('permission-set'),
-  description: z.string().optional(),
-  title: z.string().optional(),
-  'title:lang': lexLang.optional(),
-  detail: z.string().optional(),
-  'detail:lang': lexLang.optional(),
-  permissions: z.array(lexPermission),
-})
-
-export type LexPermissionSet = z.infer<typeof lexPermissionSet>
-
-// xrpc
-// =
-
-export const lexXrpcParameters = z
-  .object({
-    type: z.literal('params'),
-    description: z.string().optional(),
-    required: z.string().array().optional(),
-    properties: z.record(
-      z.string(),
-      z.discriminatedUnion('type', [
-        lexPrimitiveArray,
-
-        // lexPrimitive
-        lexBoolean,
-        lexInteger,
-        lexString,
-        lexUnknown,
-      ]),
-    ),
-  })
-  .superRefine(requiredPropertiesRefinement)
-export type LexXrpcParameters = z.infer<typeof lexXrpcParameters>
-
-export const lexXrpcBody = z.object({
-  description: z.string().optional(),
-  encoding: z.string(),
-  // @NOTE using discriminatedUnion with a refined schema requires zod >= 4
-  schema: z.union([lexRefVariant, lexObject]).optional(),
-})
-export type LexXrpcBody = z.infer<typeof lexXrpcBody>
-
-export const lexXrpcError = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-})
-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 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 type LexXrpcProcedure = z.infer<typeof lexXrpcProcedure>
-
-export const lexXrpcSubscription = z.object({
-  type: z.literal('subscription'),
-  description: z.string().optional(),
-  parameters: lexXrpcParameters.optional(),
-  message: z.object({
-    description: z.string().optional(),
-    schema: lexRefUnion,
-  }),
-  errors: lexXrpcError.array().optional(),
-})
-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 type LexRecord = z.infer<typeof lexRecord>
-
-// core
-// =
-
-// 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
-  | LexPermissionSet
-  | LexXrpcQuery
-  | LexXrpcProcedure
-  | LexXrpcSubscription
-  | LexBlob
-  | LexArray
-  | LexToken
-  | LexObject
-  | LexBoolean
-  | LexInteger
-  | LexString
-  | LexBytes
-  | LexCidLink
-  | LexUnknown
->(
-  (val) => {
-    if (!val || typeof val !== 'object') {
-      return
-    }
-
-    if (val['type'] === undefined) {
-      return
-    }
-
-    switch (val['type']) {
-      case 'record':
-        return lexRecord.parse(val)
-
-      case 'permission-set':
-        return lexPermissionSet.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,
-      }
-    }
-
-    if (val['type'] === undefined) {
-      return {
-        message: 'Must have a type',
-        fatal: true,
-      }
-    }
-
-    if (typeof val['type'] !== 'string') {
-      return {
-        message: 'Type property must be a string',
-        fatal: true,
-      }
-    }
-
-    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
-  .object({
-    lexicon: z.literal(1),
-    id: z.string().refine(isValidNsid, {
-      message: 'Must be a valid NSID',
-    }),
-    revision: z.number().optional(),
-    description: z.string().optional(),
-    defs: z.record(z.string(), lexUserType),
-  })
-  .refine(
-    (doc) => {
-      for (const [defId, def] of Object.entries(doc.defs)) {
-        if (
-          defId !== 'main' &&
-          (def.type === 'record' ||
-            def.type === 'permission-set' ||
-            def.type === 'procedure' ||
-            def.type === 'query' ||
-            def.type === 'subscription')
-        ) {
-          return false
-        }
-      }
-      return true
-    },
-    {
-      message: `Records, permission sets, procedures, queries, and subscriptions must be the main definition.`,
-    },
-  )
-export type LexiconDoc = z.infer<typeof lexiconDoc>
-
-// helpers
-// =
-
-export function isValidLexiconDoc(v: unknown): v is LexiconDoc {
-  return lexiconDoc.safeParse(v).success
-}
-
-export function isObj<V>(v: V): v is V & object {
-  return v != null && typeof v === 'object'
-}
-
-export type DiscriminatedObject = { $type: string }
-export function isDiscriminatedObject(v: unknown): v is DiscriminatedObject {
-  return isObj(v) && '$type' in v && typeof v.$type === 'string'
-}
-
-export function parseLexiconDoc(v: unknown): LexiconDoc {
-  lexiconDoc.parse(v)
-  return v as LexiconDoc
-}
-
-export type ValidationResult<V = unknown> =
-  | {
-      success: true
-      value: V
-    }
-  | {
-      success: false
-      error: ValidationError
-    }
-
-export class ValidationError extends Error {}
-export class InvalidLexiconError extends Error {}
-export class LexiconDefNotFoundError extends Error {}

package/src/util.ts

@@ -1,58 +0,0 @@
-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
-  }
-  if (str.startsWith('#')) {
-    if (!baseUri) {
-      throw new Error(`Unable to resolve uri without anchor: ${str}`)
-    }
-    return `${baseUri}${str}`
-  }
-  return `lex:${str}`
-}
-
-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`,
-      })
-    }
-  }
-}