@atproto/lexicon 0.0.4 → 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): void;
+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/validation.d.ts

@@ -1,6 +1,7 @@
 import { Lexicons } from './lexicons';
-import { LexRecord, LexXrpcProcedure, LexXrpcQuery } from './types';
-export declare function assertValidRecord(lexicons: Lexicons, def: LexRecord, value: unknown): void;
-export declare function assertValidXrpcParams(lexicons: Lexicons, def: LexXrpcProcedure | LexXrpcQuery, value: unknown): void;
-export declare function assertValidXrpcInput(lexicons: Lexicons, def: LexXrpcProcedure, value: unknown): void;
-export declare function assertValidXrpcOutput(lexicons: Lexicons, def: LexXrpcProcedure | LexXrpcQuery, value: unknown): void;
+import { LexRecord, LexXrpcProcedure, LexXrpcQuery, LexXrpcSubscription } from './types';
+export declare function assertValidRecord(lexicons: Lexicons, def: LexRecord, value: unknown): unknown;
+export declare function assertValidXrpcParams(lexicons: Lexicons, def: LexXrpcProcedure | LexXrpcQuery | LexXrpcSubscription, value: unknown): unknown;
+export declare function assertValidXrpcInput(lexicons: Lexicons, def: LexXrpcProcedure, value: unknown): unknown;
+export declare function assertValidXrpcOutput(lexicons: Lexicons, def: LexXrpcProcedure | LexXrpcQuery, value: unknown): unknown;
+export declare function assertValidXrpcMessage(lexicons: Lexicons, def: LexXrpcSubscription, value: unknown): unknown;

package/dist/validators/blob.d.ts

@@ -1,6 +1,3 @@
 import { Lexicons } from '../lexicons';
 import { LexUserType, ValidationResult } from '../types';
 export declare function blob(lexicons: Lexicons, path: string, def: LexUserType, value: unknown): ValidationResult;
-export declare function image(lexicons: Lexicons, path: string, def: LexUserType, value: unknown): ValidationResult;
-export declare function video(lexicons: Lexicons, path: string, def: LexUserType, value: unknown): ValidationResult;
-export declare function audio(lexicons: Lexicons, path: string, def: LexUserType, value: unknown): ValidationResult;

package/dist/validators/complex.d.ts

@@ -1,5 +1,5 @@
 import { Lexicons } from '../lexicons';
-import { LexUserType, ValidationResult } from '../types';
+import { LexArray, LexUserType, ValidationResult } from '../types';
 export declare function validate(lexicons: Lexicons, path: string, def: LexUserType, value: unknown): ValidationResult;
-export declare function array(lexicons: Lexicons, path: string, def: LexUserType, value: unknown): ValidationResult;
+export declare function array(lexicons: Lexicons, path: string, def: LexArray, value: unknown): ValidationResult;
 export declare function object(lexicons: Lexicons, path: string, def: LexUserType, value: unknown): ValidationResult;

package/dist/validators/formats.d.ts

@@ -0,0 +1,10 @@
+import { ValidationResult } from '../types';
+export declare function datetime(path: string, value: string): ValidationResult;
+export declare function uri(path: string, value: string): ValidationResult;
+export declare function atUri(path: string, value: string): ValidationResult;
+export declare function did(path: string, value: string): ValidationResult;
+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,8 +2,8 @@ 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 number(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 datetime(lexicons: Lexicons, path: string, def: LexUserType, value: unknown): ValidationResult;
+export declare function bytes(lexicons: Lexicons, path: string, def: LexUserType, value: unknown): ValidationResult;
+export declare function cidLink(lexicons: Lexicons, path: string, def: LexUserType, value: unknown): ValidationResult;
 export declare function unknown(lexicons: Lexicons, path: string, def: LexUserType, value: unknown): ValidationResult;

package/dist/validators/xrpc.d.ts

@@ -1,3 +1,3 @@
 import { Lexicons } from '../lexicons';
 import { LexXrpcParameters, ValidationResult } from '../types';
-export declare function params(lexicons: Lexicons, path: string, def: LexXrpcParameters, value: unknown): ValidationResult;
+export declare function params(lexicons: Lexicons, path: string, def: LexXrpcParameters, val: unknown): ValidationResult;

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@atproto/lexicon",
-  "version": "0.0.4",
+  "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,9 +18,18 @@
     "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": "*",
     "@atproto/nsid": "*",
+    "@atproto/uri": "*",
     "iso-datestring-validator": "^2.2.2",
-    "zod": "^3.14.2"
+    "multiformats": "^9.6.4",
+    "zod": "^3.21.4"
   }
 }

package/src/blob-refs.ts

@@ -0,0 +1,70 @@
+import { check, ipldToJson, schema } from '@atproto/common-web'
+import { CID } from 'multiformats/cid'
+import { z } from 'zod'
+
+export const typedJsonBlobRef = z
+  .object({
+    $type: z.literal('blob'),
+    ref: schema.cid,
+    mimeType: z.string(),
+    size: z.number(),
+  })
+  .strict()
+export type TypedJsonBlobRef = z.infer<typeof typedJsonBlobRef>
+
+export const untypedJsonBlobRef = z
+  .object({
+    cid: z.string(),
+    mimeType: z.string(),
+  })
+  .strict()
+export type UntypedJsonBlobRef = z.infer<typeof untypedJsonBlobRef>
+
+export const jsonBlobRef = z.union([typedJsonBlobRef, untypedJsonBlobRef])
+export type JsonBlobRef = z.infer<typeof jsonBlobRef>
+
+export class BlobRef {
+  public original: JsonBlobRef
+
+  constructor(
+    public ref: CID,
+    public mimeType: string,
+    public size: number,
+    original?: JsonBlobRef,
+  ) {
+    this.original = original ?? {
+      $type: 'blob',
+      ref,
+      mimeType,
+      size,
+    }
+  }
+
+  static asBlobRef(obj: unknown): BlobRef | null {
+    if (check.is(obj, jsonBlobRef)) {
+      return BlobRef.fromJsonRef(obj)
+    }
+    return null
+  }
+
+  static fromJsonRef(json: JsonBlobRef): BlobRef {
+    if (check.is(json, typedJsonBlobRef)) {
+      return new BlobRef(json.ref, json.mimeType, json.size)
+    } else {
+      return new BlobRef(CID.parse(json.cid), json.mimeType, -1, json)
+    }
+  }
+
+  ipld(): TypedJsonBlobRef {
+    return {
+      $type: 'blob',
+      ref: this.ref,
+      mimeType: this.mimeType,
+      size: this.size,
+    }
+  }
+
+  toJSON() {
+    return ipldToJson(this.ipld())
+  }
+}

package/src/index.ts

@@ -1,2 +1,4 @@
 export * from './types'
 export * from './lexicons'
+export * from './blob-refs'
+export * from './serialize'

package/src/lexicons.ts

@@ -13,12 +13,14 @@ import {
   ValidationError,
   isObj,
   hasProp,
+  LexXrpcSubscription,
 } from './types'
 import {
   assertValidRecord,
   assertValidXrpcParams,
   assertValidXrpcInput,
   assertValidXrpcOutput,
+  assertValidXrpcMessage,
 } from './validation'
 import { toLexUri } from './util'
 import * as ComplexValidators from './validators/complex'
@@ -158,7 +160,7 @@ export class Lexicons {
         `Invalid $type: must be ${lexUri}, got ${$type}`,
       )
     }
-    assertValidRecord(this, def as LexRecord, value)
+    return assertValidRecord(this, def as LexRecord, value)
   }
 
   /**
@@ -166,8 +168,16 @@ export class Lexicons {
    */
   assertValidXrpcParams(lexUri: string, value: unknown) {
     lexUri = toLexUri(lexUri)
-    const def = this.getDefOrThrow(lexUri, ['query', 'procedure'])
-    assertValidXrpcParams(this, def as LexXrpcProcedure | LexXrpcQuery, value)
+    const def = this.getDefOrThrow(lexUri, [
+      'query',
+      'procedure',
+      'subscription',
+    ])
+    return assertValidXrpcParams(
+      this,
+      def as LexXrpcProcedure | LexXrpcQuery | LexXrpcSubscription,
+      value,
+    )
   }
 
   /**
@@ -176,7 +186,7 @@ export class Lexicons {
   assertValidXrpcInput(lexUri: string, value: unknown) {
     lexUri = toLexUri(lexUri)
     const def = this.getDefOrThrow(lexUri, ['procedure'])
-    assertValidXrpcInput(this, def as LexXrpcProcedure, value)
+    return assertValidXrpcInput(this, def as LexXrpcProcedure, value)
   }
 
   /**
@@ -185,7 +195,28 @@ export class Lexicons {
   assertValidXrpcOutput(lexUri: string, value: unknown) {
     lexUri = toLexUri(lexUri)
     const def = this.getDefOrThrow(lexUri, ['query', 'procedure'])
-    assertValidXrpcOutput(this, def as LexXrpcProcedure | LexXrpcQuery, value)
+    return assertValidXrpcOutput(
+      this,
+      def as LexXrpcProcedure | LexXrpcQuery,
+      value,
+    )
+  }
+
+  /**
+   * Validate xrpc subscription message and throw on any error.
+   */
+  assertValidXrpcMessage<T = unknown>(lexUri: string, value: unknown): T {
+    lexUri = toLexUri(lexUri)
+    const def = this.getDefOrThrow(lexUri, ['subscription'])
+    return assertValidXrpcMessage(this, def as LexXrpcSubscription, value) as T
+  }
+
+  /**
+   * Resolve a lex uri given a ref
+   */
+  resolveLexUri(lexUri: string, ref: string) {
+    lexUri = toLexUri(lexUri)
+    return toLexUri(ref, lexUri)
   }
 }
 

package/src/serialize.ts

@@ -0,0 +1,93 @@
+import {
+  check,
+  IpldValue,
+  ipldToJson,
+  jsonToIpld,
+  JsonValue,
+} from '@atproto/common-web'
+import { CID } from 'multiformats/cid'
+import { BlobRef, jsonBlobRef } from './blob-refs'
+
+export type LexValue =
+  | IpldValue
+  | BlobRef
+  | Array<LexValue>
+  | { [key: string]: LexValue }
+
+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.
+
+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
+}
+
+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))
+}