+101 -12

common/dates.ts

reviewed

··· 1 1 + // Time constants 1 2 export const SECOND = 1000; 2 3 export const MINUTE = SECOND * 60; 3 4 export const HOUR = MINUTE * 60; 4 5 export const DAY = HOUR * 24; 5 6 7 7 + // Characters that need escaping in regex 8 8 + const SEPARATORS_TO_ESCAPE = new Set([ 9 9 + "\\", 10 10 + "^", 11 11 + "$", 12 12 + ".", 13 13 + "|", 14 14 + "?", 15 15 + "*", 16 16 + "+", 17 17 + "(", 18 18 + ")", 19 19 + "[", 20 20 + "]", 21 21 + "{", 22 22 + "}", 23 23 + ]); 24 24 + 25 25 + // Helper Functions 26 26 + 27 27 + function getStringSeparator(dateString: string): string { 28 28 + const separator = /\D/.exec(dateString); 29 29 + return separator ? separator[0] : ""; 30 30 + } 31 31 + 32 32 + function getTimeStringSeparator(timeString: string): string { 33 33 + const matches = timeString.match(/([^Z+\-\d])(?=\d+\1)/); 34 34 + return Array.isArray(matches) ? matches[0] : ""; 35 35 + } 36 36 + 37 37 + // Validation Functions 38 38 + 39 39 + export function isValidDate(date: string, s = "-"): boolean { 40 40 + if (SEPARATORS_TO_ESCAPE.has(s)) { 41 41 + s = `\\${s}`; 42 42 + } 43 43 + 44 44 + const validator = new RegExp( 45 45 + `^(?!0{4}${s}0{2}${s}0{2})((?=[0-9]{4}${s}(((0[^2])|1[0-2])|02(?=${s}(([0-1][0-9])|2[0-8])))${s}[0-9]{2})|(?=((([13579][26])|([2468][048])|(0[48]))0{2})|([0-9]{2}((((0|[2468])[48])|[2468][048])|([13579][26])))${s}02${s}29))([0-9]{4})${s}(?!((0[469])|11)${s}31)((0[1,3-9]|1[0-2])|(02(?!${s}3)))${s}(0[1-9]|[1-2][0-9]|3[0-1])$`, 46 46 + ); 47 47 + return validator.test(date); 48 48 + } 49 49 + 50 50 + function isValidTime( 51 51 + timeWithOffset: string, 52 52 + s = ":", 53 53 + isTimezoneCheckOn = false, 54 54 + ): boolean { 55 55 + const validator = new RegExp( 56 56 + `^([0-1]|2(?=([0-3])|4${s}00))[0-9]${s}[0-5][0-9](${s}([0-5]|6(?=0))[0-9])?(\.[0-9]{1,9})?$`, 57 57 + ); 58 58 + 59 59 + if (!isTimezoneCheckOn || !/[Z+\-]/.test(timeWithOffset)) { 60 60 + return validator.test(timeWithOffset); 61 61 + } 62 62 + 63 63 + // Case we got time in Zulu tz 64 64 + if (/Z$/.test(timeWithOffset)) { 65 65 + return validator.test(timeWithOffset.replace("Z", "")); 66 66 + } 67 67 + 68 68 + const isPositiveTimezoneOffset = timeWithOffset.includes("+"); 69 69 + const [time, offset] = timeWithOffset.split(/[+-]/); 70 70 + 71 71 + return validator.test(time) && 72 72 + isValidZoneOffset( 73 73 + offset, 74 74 + isPositiveTimezoneOffset, 75 75 + getStringSeparator(offset), 76 76 + ); 77 77 + } 78 78 + 79 79 + function isValidZoneOffset( 80 80 + offset: string, 81 81 + isPositiveOffset: boolean, 82 82 + s = ":", 83 83 + ): boolean { 84 84 + const validator = new RegExp( 85 85 + isPositiveOffset 86 86 + ? `^(0(?!(2${s}4)|0${s}3)|1(?=([0-1]|2(?=${s}[04])|[34](?=${s}0))))([03469](?=${s}[03])|[17](?=${s}0)|2(?=${s}[04])|5(?=${s}[034])|8(?=${s}[04]))${s}([03](?=0)|4(?=5))[05]$` 87 87 + : `^(0(?=[^0])|1(?=[0-2]))([39](?=${s}[03])|[0-24-8](?=${s}00))${s}[03]0$`, 88 88 + ); 89 89 + return validator.test(offset); 90 90 + } 91 91 + 92 92 + export function isValidISODateString(dateString: string): boolean { 93 93 + const [date, timeWithOffset] = dateString.split("T"); 94 94 + const dateSeparator = getStringSeparator(date); 95 95 + const isDateValid = isValidDate(date, dateSeparator); 96 96 + 97 97 + if (!timeWithOffset) { 98 98 + return false; 99 99 + } 100 100 + 101 101 + const timeStringSeparator = getTimeStringSeparator(timeWithOffset); 102 102 + return isDateValid && isValidTime(timeWithOffset, timeStringSeparator, true); 103 103 + } 104 104 + 105 105 + // Utility Functions 106 106 + 6 107 export const lessThanAgoMs = (time: Date, range: number): boolean => { 7 108 return Date.now() < time.getTime() + range; 8 109 }; ··· 13 114 currentDate.setHours(currentDate.getHours() + hours); 14 115 return currentDate; 15 116 }; 16 16 - 17 17 - function isValidISODateString(dateString: string): boolean { 18 18 - // Basic format check: YYYY-MM-DDTHH:mm:ss.sssZ or YYYY-MM-DDTHH:mm:ssZ 19 19 - const isoRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/; 20 20 - if (!isoRegex.test(dateString)) { 21 21 - return false; 22 22 - } 23 23 - 24 24 - // Check if the date is valid and matches the original string when parsed and converted back 25 25 - const date = new Date(dateString); 26 26 - return !isNaN(date.getTime()) && date.toISOString() === dateString; 27 27 - } 28 117 29 118 export function toSimplifiedISOSafe(dateStr: string): string { 30 119 const date = new Date(dateStr);

+1 -1

deno.json

reviewed

··· 1 1 { 2 2 - "workspace": ["xrpc-server", "lex-cli", "common", "syntax", "xrpc"] 2 2 + "workspace": ["common", "syntax", "lexicon", "xrpc", "xrpc-server", "lex-cli"] 3 3 }

+12 -48

deno.lock

reviewed

··· 43 43 "jsr:@zod/zod@^4.1.11": "4.1.11", 44 44 "jsr:@zod/zod@^4.1.5": "4.1.5", 45 45 "npm:@atproto/crypto@~0.4.4": "0.4.4", 46 46 - "npm:@atproto/lexicon@~0.4.11": "0.4.14", 47 47 - "npm:@atproto/lexicon@~0.4.14": "0.4.14", 48 48 - "npm:@atproto/lexicon@~0.5.1": "0.5.1", 49 46 "npm:@ipld/dag-cbor@^9.2.5": "9.2.5", 50 47 "npm:@types/node@*": "24.2.0", 51 48 "npm:cbor-x@*": "1.6.0", ··· 59 56 "npm:rate-limiter-flexible@^2.4.1": "2.4.2", 60 57 "npm:uint8arrays@3.0.0": "3.0.0", 61 58 "npm:uint8arrays@^5.1.0": "5.1.0", 62 62 - "npm:ws@^8.12.0": "8.18.3" 59 59 + "npm:ws@^8.12.0": "8.18.3", 60 60 + "npm:zod@^4.1.11": "4.1.11" 63 61 }, 64 62 "jsr": { 65 63 "@cliffy/ansi@1.0.0-rc.8": { ··· 198 196 } 199 197 }, 200 198 "npm": { 201 201 - "@atproto/common-web@0.4.3": { 202 202 - "integrity": "sha512-nRDINmSe4VycJzPo6fP/hEltBcULFxt9Kw7fQk6405FyAWZiTluYHlXOnU7GkQfeUK44OENG1qFTBcmCJ7e8pg==", 203 203 - "dependencies": [ 204 204 - "graphemer", 205 205 - "multiformats@9.9.0", 206 206 - "uint8arrays@3.0.0", 207 207 - "zod" 208 208 - ] 209 209 - }, 210 199 "@atproto/crypto@0.4.4": { 211 200 "integrity": "sha512-Yq9+crJ7WQl7sxStVpHgie5Z51R05etaK9DLWYG/7bR5T4bhdcIgF6IfklLShtZwLYdVVj+K15s0BqW9a8PSDA==", 212 201 "dependencies": [ ··· 215 204 "uint8arrays@3.0.0" 216 205 ] 217 206 }, 218 218 - "@atproto/lexicon@0.4.14": { 219 219 - "integrity": "sha512-jiKpmH1QER3Gvc7JVY5brwrfo+etFoe57tKPQX/SmPwjvUsFnJAow5xLIryuBaJgFAhnTZViXKs41t//pahGHQ==", 220 220 - "dependencies": [ 221 221 - "@atproto/common-web", 222 222 - "@atproto/syntax", 223 223 - "iso-datestring-validator", 224 224 - "multiformats@9.9.0", 225 225 - "zod" 226 226 - ] 227 227 - }, 228 228 - "@atproto/lexicon@0.5.1": { 229 229 - "integrity": "sha512-y8AEtYmfgVl4fqFxqXAeGvhesiGkxiy3CWoJIfsFDDdTlZUC8DFnZrYhcqkIop3OlCkkljvpSJi1hbeC1tbi8A==", 230 230 - "dependencies": [ 231 231 - "@atproto/common-web", 232 232 - "@atproto/syntax", 233 233 - "iso-datestring-validator", 234 234 - "multiformats@9.9.0", 235 235 - "zod" 236 236 - ] 237 237 - }, 238 238 - "@atproto/syntax@0.4.1": { 239 239 - "integrity": "sha512-CJdImtLAiFO+0z3BWTtxwk6aY5w4t8orHTMVJgkf++QRJWTxPbIFko/0hrkADB7n2EruDxDSeAgfUGehpH6ngw==" 240 240 - }, 241 207 "@cbor-extract/cbor-extract-darwin-arm64@2.2.0": { 242 208 "integrity": "sha512-P7swiOAdF7aSi0H+tHtHtr6zrpF3aAq/W9FXx5HektRvLTM2O89xCyXF3pk7pLc7QpaY7AoaE8UowVf9QBdh3w==", 243 209 "os": ["darwin"], ··· 364 330 "get-port@7.1.0": { 365 331 "integrity": "sha512-QB9NKEeDg3xxVwCCwJQ9+xycaz6pBB6iQ76wiWMl1927n0Kir6alPiP+yuiICLLU4jpMe08dXfpebuQppFA2zw==" 366 332 }, 367 367 - "graphemer@1.4.0": { 368 368 - "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==" 369 369 - }, 370 333 "hash.js@1.1.7": { 371 334 "integrity": "sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==", 372 335 "dependencies": [ ··· 394 357 }, 395 358 "inherits@2.0.4": { 396 359 "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==" 397 397 - }, 398 398 - "iso-datestring-validator@2.2.2": { 399 399 - "integrity": "sha512-yLEMkBbLZTlVQqOnQ4FiMujR6T4DEcCb1xizmvXS+OxuhwcbtynoosRzdMA69zZCShCNAbi+gJ71FxZBBXx1SA==" 400 360 }, 401 361 "key-encoder@2.0.3": { 402 362 "integrity": "sha512-fgBtpAGIr/Fy5/+ZLQZIPPhsZEcbSlYu/Wu96tNDFNSjSACw5lEIOFeaVdQ/iwrb8oxjlWi6wmWdH76hV6GZjg==", ··· 466 426 "ws@8.18.3": { 467 427 "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==" 468 428 }, 469 469 - "zod@3.25.76": { 470 470 - "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==" 429 429 + "zod@4.1.11": { 430 430 + "integrity": "sha512-WPsqwxITS2tzx1bzhIKsEs19ABD5vmCVa4xBo2tq/SrV4RNZtfws1EnCWQXM6yh8bD08a1idvkB5MZSBiZsjwg==" 471 431 } 472 432 }, 473 433 "remote": { ··· 508 468 "jsr:@std/path@^1.1.2", 509 469 "jsr:@ts-morph/ts-morph@26", 510 470 "jsr:@zod/zod@^4.1.5", 511 511 - "npm:@atproto/lexicon@~0.4.14", 512 471 "npm:prettier@^3.6.2" 513 472 ] 514 473 }, 474 474 + "lexicon": { 475 475 + "dependencies": [ 476 476 + "jsr:@std/assert@^1.0.14", 477 477 + "npm:multiformats@^13.4.1", 478 478 + "npm:zod@^4.1.11" 479 479 + ] 480 480 + }, 515 481 "syntax": { 516 482 "dependencies": [ 517 483 "jsr:@std/assert@^1.0.14" ··· 519 485 }, 520 486 "xrpc": { 521 487 "dependencies": [ 522 522 - "jsr:@zod/zod@^4.1.11", 523 523 - "npm:@atproto/lexicon@~0.5.1" 488 488 + "jsr:@zod/zod@^4.1.11" 524 489 ] 525 490 }, 526 491 "xrpc-server": { ··· 531 496 "jsr:@std/encoding@^1.0.10", 532 497 "jsr:@zod/zod@^4.0.17", 533 498 "npm:@atproto/crypto@~0.4.4", 534 534 - "npm:@atproto/lexicon@~0.4.11", 535 499 "npm:get-port@^7.1.0", 536 500 "npm:http-errors@2", 537 501 "npm:key-encoder@^2.0.3",

+1 -1

lex-cli/codegen/client.ts

reviewed

··· 4 4 type SourceFile, 5 5 VariableDeclarationKind, 6 6 } from "ts-morph"; 7 7 - import { type LexiconDoc, Lexicons, type LexRecord } from "@atproto/lexicon"; 7 7 + import { type LexiconDoc, Lexicons, type LexRecord } from "@atp/lexicon"; 8 8 import { NSID } from "@atp/syntax"; 9 9 import type { GeneratedAPI } from "../types.ts"; 10 10 import { gen, lexiconsTs, utilTs } from "./common.ts";

+4 -4

lex-cli/codegen/common.ts

reviewed

··· 3 3 type SourceFile, 4 4 VariableDeclarationKind, 5 5 } from "ts-morph"; 6 6 - import type { LexiconDoc } from "@atproto/lexicon"; 6 6 + import type { LexiconDoc } from "@atp/lexicon"; 7 7 import type { GeneratedFile } from "../types.ts"; 8 8 import type { CodeGenOptions } from "./util.ts"; 9 9 import { format, type Options as PrettierOptions } from "prettier"; ··· 21 21 ) => 22 22 gen(project, "/util.ts", (file) => { 23 23 file.replaceWithText(` 24 24 - import { type ValidationResult } from '@atproto/lexicon' 24 24 + import { type ValidationResult } from '@atp/lexicon' 25 25 26 26 export type OmitKey<T, K extends keyof T> = { 27 27 [K2 in keyof T as K2 extends K ? never : K2]: T[K2] ··· 152 152 .join(""); 153 153 }; 154 154 155 155 - //= import { type LexiconDoc, Lexicons } from '@atproto/lexicon' 155 155 + //= import { type LexiconDoc, Lexicons } from '@atp/lexicon' 156 156 file 157 157 .addImportDeclaration({ 158 158 - moduleSpecifier: "@atproto/lexicon", 158 158 + moduleSpecifier: "@atp/lexicon", 159 159 }) 160 160 .addNamedImports([ 161 161 { name: "LexiconDoc", isTypeOnly: true },

+4 -5

lex-cli/codegen/lex-gen.ts

reviewed

··· 10 10 LexObject, 11 11 LexPrimitive, 12 12 LexToken, 13 13 - } from "@atproto/lexicon"; 13 13 + } from "@atp/lexicon"; 14 14 import { 15 15 type CodeGenOptions, 16 16 toCamelCase, 17 17 toScreamingSnakeCase, 18 18 toTitleCase, 19 19 } from "./util.ts"; 20 20 - import type { LexiconDoc } from "@atproto/lexicon"; 21 21 - import type { LexUserType } from "@atproto/lexicon"; 20 20 + import type { LexiconDoc, LexUserType } from "@atp/lexicon"; 22 21 23 22 interface Commentable { 24 23 addJsDoc: ({ description }: { description: string }) => JSDoc; ··· 191 190 def.type === "object" 192 191 ); 193 192 194 194 - //= import {BlobRef} from '@atproto/lexicon' 193 193 + //= import {BlobRef} from '@atp/lexicon' 195 194 if (needsBlobRef) { 196 195 file 197 196 .addImportDeclaration({ 198 198 - moduleSpecifier: "@atproto/lexicon", 197 197 + moduleSpecifier: "@atp/lexicon", 199 198 }) 200 199 .addNamedImports([{ name: "BlobRef" }]); 201 200 }

+1 -1

lex-cli/codegen/server.ts

reviewed

··· 4 4 type SourceFile, 5 5 VariableDeclarationKind, 6 6 } from "ts-morph"; 7 7 - import { type LexiconDoc, Lexicons } from "@atproto/lexicon"; 7 7 + import { type LexiconDoc, Lexicons } from "@atp/lexicon"; 8 8 import { NSID } from "@atp/syntax"; 9 9 import type { GeneratedAPI } from "../types.ts"; 10 10 import { gen, lexiconsTs, utilTs } from "./common.ts";

+1 -1

lex-cli/codegen/util.ts

reviewed

··· 1 1 - import type { LexiconDoc, LexUserType } from "@atproto/lexicon"; 1 1 + import type { LexiconDoc, LexUserType } from "@atp/lexicon"; 2 2 import { NSID } from "@atp/syntax"; 3 3 4 4 export interface CodeGenOptions {

-1

lex-cli/deno.json

reviewed

··· 8 8 "@cliffy/command": "jsr:@cliffy/command@^1.0.0-rc.8", 9 9 "@std/fs": "jsr:@std/fs@^1.0.19", 10 10 "@std/path": "jsr:@std/path@^1.1.2", 11 11 - "@atproto/lexicon": "npm:@atproto/lexicon@^0.4.14", 12 11 "prettier": "npm:prettier@^3.6.2", 13 12 "ts-morph": "jsr:@ts-morph/ts-morph@^26.0.0", 14 13 "zod": "jsr:@zod/zod@^4.1.5"

+1 -1

lex-cli/mdgen/index.ts

reviewed

··· 1 1 import { readFileSync } from "@std/fs/unstable-read-file"; 2 2 import { writeFileSync } from "@std/fs/unstable-write-file"; 3 3 - import type { LexiconDoc } from "@atproto/lexicon"; 3 3 + import type { LexiconDoc } from "@atp/lexicon"; 4 4 5 5 const INSERT_START = [ 6 6 "<!-- START lex generated content. Please keep comment here to allow auto update -->",

+1 -1

lex-cli/util.ts

reviewed

··· 8 8 import { readDirSync } from "@std/fs/unstable-read-dir"; 9 9 import { colors } from "@cliffy/ansi/colors"; 10 10 import { ZodError } from "zod"; 11 11 - import { type LexiconDoc, parseLexiconDoc } from "@atproto/lexicon"; 11 11 + import { type LexiconDoc, parseLexiconDoc } from "@atp/lexicon"; 12 12 import type { FileDiff, GeneratedAPI } from "./types.ts"; 13 13 14 14 type RecursiveZodError = {

+71

lexicon/blob-refs.ts

reviewed

··· 1 1 + import { CID } from "multiformats/cid"; 2 2 + import { z } from "zod"; 3 3 + import { check, ipldToJson, schema } from "@atp/common"; 4 4 + 5 5 + export const typedJsonBlobRef = z.strictObject({ 6 6 + $type: z.literal("blob"), 7 7 + ref: schema.cid, 8 8 + mimeType: z.string(), 9 9 + size: z.number(), 10 10 + }); 11 11 + export type TypedJsonBlobRef = z.infer<typeof typedJsonBlobRef>; 12 12 + 13 13 + export const untypedJsonBlobRef = z.strictObject({ 14 14 + cid: z.string(), 15 15 + mimeType: z.string(), 16 16 + }); 17 17 + export type UntypedJsonBlobRef = z.infer<typeof untypedJsonBlobRef>; 18 18 + 19 19 + export const jsonBlobRef = z.union([typedJsonBlobRef, untypedJsonBlobRef]); 20 20 + export type JsonBlobRef = z.infer<typeof jsonBlobRef>; 21 21 + 22 22 + export class BlobRef { 23 23 + public original: JsonBlobRef; 24 24 + 25 25 + constructor( 26 26 + public ref: CID, 27 27 + public mimeType: string, 28 28 + public size: number, 29 29 + original?: JsonBlobRef, 30 30 + ) { 31 31 + this.original = original ?? { 32 32 + $type: "blob", 33 33 + ref, 34 34 + mimeType, 35 35 + size, 36 36 + }; 37 37 + } 38 38 + 39 39 + static asBlobRef(obj: unknown): BlobRef | null { 40 40 + if (check.is(obj, jsonBlobRef)) { 41 41 + return BlobRef.fromJsonRef(obj); 42 42 + } 43 43 + return null; 44 44 + } 45 45 + 46 46 + static fromJsonRef(json: JsonBlobRef): BlobRef { 47 47 + if (check.is(json, typedJsonBlobRef)) { 48 48 + return new BlobRef(json.ref as CID, json.mimeType, json.size, json); 49 49 + } else { 50 50 + return new BlobRef(CID.parse(json.cid), json.mimeType, -1); 51 51 + } 52 52 + } 53 53 + 54 54 + ipld(): TypedJsonBlobRef { 55 55 + return { 56 56 + $type: "blob", 57 57 + ref: this.ref, 58 58 + mimeType: this.mimeType, 59 59 + size: this.size, 60 60 + }; 61 61 + } 62 62 + 63 63 + toJSON() { 64 64 + return ipldToJson(this.ipld()) as { 65 65 + $type: "blob"; 66 66 + ref: { $link: string }; 67 67 + mimeType: string; 68 68 + size: number; 69 69 + }; 70 70 + } 71 71 + }

+11

lexicon/deno.json

reviewed

··· 1 1 + { 2 2 + "name": "@atp/lexicon", 3 3 + "version": "0.1.0-alpha.1", 4 4 + "exports": "./mod.ts", 5 5 + "license": "MIT", 6 6 + "imports": { 7 7 + "@std/assert": "jsr:@std/assert@^1.0.14", 8 8 + "multiformats": "npm:multiformats@^13.4.1", 9 9 + "zod": "npm:zod@^4.1.11" 10 10 + } 11 11 + }

+255

lexicon/lexicons.ts

reviewed

··· 1 1 + import { 2 2 + InvalidLexiconError, 3 3 + isObj, 4 4 + LexiconDefNotFoundError, 5 5 + type LexiconDoc, 6 6 + type LexRecord, 7 7 + type LexUserType, 8 8 + ValidationError, 9 9 + type ValidationResult, 10 10 + } from "./types.ts"; 11 11 + import { toLexUri } from "./util.ts"; 12 12 + import { 13 13 + assertValidRecord, 14 14 + assertValidXrpcInput, 15 15 + assertValidXrpcMessage, 16 16 + assertValidXrpcOutput, 17 17 + assertValidXrpcParams, 18 18 + } from "./validation/index.ts"; 19 19 + import { object as validateObject } from "./validation/complex.ts"; 20 20 + 21 21 + /** 22 22 + * A collection of compiled lexicons. 23 23 + */ 24 24 + export class Lexicons implements Iterable<LexiconDoc> { 25 25 + docs: Map<string, LexiconDoc> = new Map(); 26 26 + defs: Map<string, LexUserType> = new Map(); 27 27 + 28 28 + constructor(docs?: Iterable<LexiconDoc>) { 29 29 + if (docs) { 30 30 + for (const doc of docs) { 31 31 + this.add(doc); 32 32 + } 33 33 + } 34 34 + } 35 35 + 36 36 + /** 37 37 + * @example clone a lexicon: 38 38 + * ```ts 39 39 + * const clone = new Lexicons(originalLexicon) 40 40 + * ``` 41 41 + * 42 42 + * @example get docs array: 43 43 + * ```ts 44 44 + * const docs = Array.from(lexicons) 45 45 + * ``` 46 46 + */ 47 47 + [Symbol.iterator](): Iterator<LexiconDoc> { 48 48 + return this.docs.values(); 49 49 + } 50 50 + 51 51 + /** 52 52 + * Add a lexicon doc. 53 53 + */ 54 54 + add(doc: LexiconDoc): void { 55 55 + const uri = toLexUri(doc.id); 56 56 + if (this.docs.has(uri)) { 57 57 + throw new Error(`${uri} has already been registered`); 58 58 + } 59 59 + 60 60 + // WARNING 61 61 + // mutates the object 62 62 + // -prf 63 63 + resolveRefUris(doc, uri); 64 64 + 65 65 + this.docs.set(uri, doc); 66 66 + for (const [defUri, def] of iterDefs(doc)) { 67 67 + this.defs.set(defUri, def); 68 68 + } 69 69 + } 70 70 + 71 71 + /** 72 72 + * Remove a lexicon doc. 73 73 + */ 74 74 + remove(uri: string) { 75 75 + uri = toLexUri(uri); 76 76 + const doc = this.docs.get(uri); 77 77 + if (!doc) { 78 78 + throw new Error(`Unable to remove "${uri}": does not exist`); 79 79 + } 80 80 + for (const [defUri, _def] of iterDefs(doc)) { 81 81 + this.defs.delete(defUri); 82 82 + } 83 83 + this.docs.delete(uri); 84 84 + } 85 85 + 86 86 + /** 87 87 + * Get a lexicon doc. 88 88 + */ 89 89 + get(uri: string): LexiconDoc | undefined { 90 90 + uri = toLexUri(uri); 91 91 + return this.docs.get(uri); 92 92 + } 93 93 + 94 94 + /** 95 95 + * Get a definition. 96 96 + */ 97 97 + getDef(uri: string): LexUserType | undefined { 98 98 + uri = toLexUri(uri); 99 99 + return this.defs.get(uri); 100 100 + } 101 101 + 102 102 + /** 103 103 + * Get a def, throw if not found. Throws on not found. 104 104 + */ 105 105 + getDefOrThrow<T extends LexUserType["type"] = LexUserType["type"]>( 106 106 + uri: string, 107 107 + types?: readonly T[], 108 108 + ): Extract<LexUserType, { type: T }>; 109 109 + getDefOrThrow( 110 110 + uri: string, 111 111 + types?: readonly LexUserType["type"][], 112 112 + ): LexUserType { 113 113 + const def = this.getDef(uri); 114 114 + if (!def) { 115 115 + throw new LexiconDefNotFoundError(`Lexicon not found: ${uri}`); 116 116 + } 117 117 + if (types && !types.includes(def.type)) { 118 118 + throw new InvalidLexiconError( 119 119 + `Not a ${types.join(" or ")} lexicon: ${uri}`, 120 120 + ); 121 121 + } 122 122 + return def; 123 123 + } 124 124 + 125 125 + /** 126 126 + * Validate a record or object. 127 127 + */ 128 128 + validate(lexUri: string, value: unknown): ValidationResult { 129 129 + if (!isObj(value)) { 130 130 + throw new ValidationError(`Value must be an object`); 131 131 + } 132 132 + 133 133 + const lexUriNormalized = toLexUri(lexUri); 134 134 + const def = this.getDefOrThrow(lexUriNormalized, ["record", "object"]); 135 135 + 136 136 + if (def.type === "record") { 137 137 + return validateObject(this, "Record", def.record, value); 138 138 + } else if (def.type === "object") { 139 139 + return validateObject(this, "Object", def, value); 140 140 + } else { 141 141 + // shouldn't happen 142 142 + throw new InvalidLexiconError("Definition must be a record or object"); 143 143 + } 144 144 + } 145 145 + 146 146 + /** 147 147 + * Validate a record and throw on any error. 148 148 + */ 149 149 + assertValidRecord(lexUri: string, value: unknown) { 150 150 + if (!isObj(value)) { 151 151 + throw new ValidationError(`Record must be an object`); 152 152 + } 153 153 + if (!("$type" in value)) { 154 154 + throw new ValidationError(`Record/$type must be a string`); 155 155 + } 156 156 + const { $type } = value; 157 157 + if (typeof $type !== "string") { 158 158 + throw new ValidationError(`Record/$type must be a string`); 159 159 + } 160 160 + 161 161 + const lexUriNormalized = toLexUri(lexUri); 162 162 + if (toLexUri($type) !== lexUriNormalized) { 163 163 + throw new ValidationError( 164 164 + `Invalid $type: must be ${lexUriNormalized}, got ${$type}`, 165 165 + ); 166 166 + } 167 167 + 168 168 + const def = this.getDefOrThrow(lexUriNormalized, ["record"]); 169 169 + return assertValidRecord(this, def as LexRecord, value); 170 170 + } 171 171 + 172 172 + /** 173 173 + * Validate xrpc query params and throw on any error. 174 174 + */ 175 175 + assertValidXrpcParams(lexUri: string, value: unknown) { 176 176 + lexUri = toLexUri(lexUri); 177 177 + const def = this.getDefOrThrow(lexUri, [ 178 178 + "query", 179 179 + "procedure", 180 180 + "subscription", 181 181 + ]); 182 182 + return assertValidXrpcParams(this, def, value); 183 183 + } 184 184 + 185 185 + /** 186 186 + * Validate xrpc input body and throw on any error. 187 187 + */ 188 188 + assertValidXrpcInput(lexUri: string, value: unknown) { 189 189 + lexUri = toLexUri(lexUri); 190 190 + const def = this.getDefOrThrow(lexUri, ["procedure"]); 191 191 + return assertValidXrpcInput(this, def, value); 192 192 + } 193 193 + 194 194 + /** 195 195 + * Validate xrpc output body and throw on any error. 196 196 + */ 197 197 + assertValidXrpcOutput(lexUri: string, value: unknown) { 198 198 + lexUri = toLexUri(lexUri); 199 199 + const def = this.getDefOrThrow(lexUri, ["query", "procedure"]); 200 200 + return assertValidXrpcOutput(this, def, value); 201 201 + } 202 202 + 203 203 + /** 204 204 + * Validate xrpc subscription message and throw on any error. 205 205 + */ 206 206 + assertValidXrpcMessage<T = unknown>(lexUri: string, value: unknown): T { 207 207 + lexUri = toLexUri(lexUri); 208 208 + const def = this.getDefOrThrow(lexUri, ["subscription"]); 209 209 + return assertValidXrpcMessage(this, def, value) as T; 210 210 + } 211 211 + 212 212 + /** 213 213 + * Resolve a lex uri given a ref 214 214 + */ 215 215 + resolveLexUri(lexUri: string, ref: string) { 216 216 + lexUri = toLexUri(lexUri); 217 217 + return toLexUri(ref, lexUri); 218 218 + } 219 219 + } 220 220 + 221 221 + function* iterDefs(doc: LexiconDoc): Generator<[string, LexUserType]> { 222 222 + for (const defId in doc.defs) { 223 223 + yield [`lex:${doc.id}#${defId}`, doc.defs[defId]]; 224 224 + if (defId === "main") { 225 225 + yield [`lex:${doc.id}`, doc.defs[defId]]; 226 226 + } 227 227 + } 228 228 + } 229 229 + 230 230 + // WARNING 231 231 + // this method mutates objects 232 232 + // -prf 233 233 + function resolveRefUris(obj: Record<string, unknown>, baseUri: string): object { 234 234 + for (const k in obj) { 235 235 + if (obj.type === "ref") { 236 236 + obj.ref = toLexUri(obj.ref as string, baseUri); 237 237 + } else if (obj.type === "union") { 238 238 + const refs = obj.refs as string[]; 239 239 + obj.refs = refs.map((ref: string) => toLexUri(ref, baseUri)); 240 240 + } else if (Array.isArray(obj[k])) { 241 241 + const arrayValue = obj[k] as unknown[]; 242 242 + obj[k] = arrayValue.map((item: unknown) => { 243 243 + if (typeof item === "string") { 244 244 + return item.startsWith("#") ? toLexUri(item, baseUri) : item; 245 245 + } else if (item && typeof item === "object") { 246 246 + return resolveRefUris(item as Record<string, unknown>, baseUri); 247 247 + } 248 248 + return item; 249 249 + }); 250 250 + } else if (obj[k] && typeof obj[k] === "object") { 251 251 + obj[k] = resolveRefUris(obj[k] as Record<string, unknown>, baseUri); 252 252 + } 253 253 + } 254 254 + return obj; 255 255 + }

+4

lexicon/mod.ts

reviewed

··· 1 1 + export * from "./types.ts"; 2 2 + export * from "./lexicons.ts"; 3 3 + export * from "./blob-refs.ts"; 4 4 + export * from "./serialize.ts";

+94

lexicon/serialize.ts

reviewed

··· 1 1 + import { CID } from "multiformats/cid"; 2 2 + import { 3 3 + check, 4 4 + ipldToJson, 5 5 + type IpldValue, 6 6 + jsonToIpld, 7 7 + type JsonValue, 8 8 + } from "@atp/common"; 9 9 + import { BlobRef, jsonBlobRef } from "./blob-refs.ts"; 10 10 + 11 11 + export type LexValue = 12 12 + | IpldValue 13 13 + | BlobRef 14 14 + | Array<LexValue> 15 15 + | { [key: string]: LexValue }; 16 16 + 17 17 + export type RepoRecord = Record<string, LexValue>; 18 18 + 19 19 + // @NOTE avoiding use of check.is() here only because it makes 20 20 + // these implementations slow, and they often live in hot paths. 21 21 + 22 22 + export const lexToIpld = (val: LexValue): IpldValue => { 23 23 + // walk arrays 24 24 + if (Array.isArray(val)) { 25 25 + return val.map((item) => lexToIpld(item)); 26 26 + } 27 27 + // objects 28 28 + if (val && typeof val === "object") { 29 29 + // convert blobs, leaving the original encoding so that we don't change CIDs on re-encode 30 30 + if (val instanceof BlobRef) { 31 31 + return val.original; 32 32 + } 33 33 + // retain cids & bytes 34 34 + if (CID.asCID(val) || val instanceof Uint8Array) { 35 35 + return val; 36 36 + } 37 37 + // walk plain objects 38 38 + const toReturn: Record<string, IpldValue> = {}; 39 39 + for (const key of Object.keys(val)) { 40 40 + toReturn[key] = lexToIpld((val as Record<string, LexValue>)[key]); 41 41 + } 42 42 + return toReturn; 43 43 + } 44 44 + // pass through 45 45 + return val; 46 46 + }; 47 47 + 48 48 + export const ipldToLex = (val: IpldValue): LexValue => { 49 49 + // map arrays 50 50 + if (Array.isArray(val)) { 51 51 + return val.map((item) => ipldToLex(item)); 52 52 + } 53 53 + // objects 54 54 + if (val && typeof val === "object") { 55 55 + // convert blobs, using hints to avoid expensive is() check 56 56 + const obj = val as Record<string, unknown>; 57 57 + if ( 58 58 + (obj["$type"] === "blob" || 59 59 + (typeof obj["cid"] === "string" && 60 60 + typeof obj["mimeType"] === "string")) && 61 61 + check.is(val, jsonBlobRef) 62 62 + ) { 63 63 + return BlobRef.fromJsonRef(val); 64 64 + } 65 65 + // retain cids, bytes 66 66 + if (CID.asCID(val) || val instanceof Uint8Array) { 67 67 + return val; 68 68 + } 69 69 + // map plain objects 70 70 + const toReturn: Record<string, LexValue> = {}; 71 71 + for (const key of Object.keys(val)) { 72 72 + toReturn[key] = ipldToLex((val as Record<string, IpldValue>)[key]); 73 73 + } 74 74 + return toReturn; 75 75 + } 76 76 + // pass through 77 77 + return val; 78 78 + }; 79 79 + 80 80 + export const lexToJson = (val: LexValue): JsonValue => { 81 81 + return ipldToJson(lexToIpld(val)); 82 82 + }; 83 83 + 84 84 + export const stringifyLex = (val: LexValue): string => { 85 85 + return JSON.stringify(lexToJson(val)); 86 86 + }; 87 87 + 88 88 + export const jsonToLex = (val: JsonValue): LexValue => { 89 89 + return ipldToLex(jsonToIpld(val)); 90 90 + }; 91 91 + 92 92 + export const jsonStringToLex = (val: string): LexValue => { 93 93 + return jsonToLex(JSON.parse(val)); 94 94 + };

+34

lexicon/tests/general_test.ts

reviewed

··· 1 1 + import { assertThrows } from "@std/assert"; 2 2 + import { Lexicons } from "../mod.ts"; 3 3 + import LexiconDocs from "./scaffolds/lexicons.ts"; 4 4 + import { assertEquals } from "@std/assert/equals"; 5 5 + 6 6 + const lex = new Lexicons(LexiconDocs); 7 7 + 8 8 + Deno.test("Adds schemas", () => { 9 9 + assertThrows(() => lex.add(LexiconDocs[0])); 10 10 + }); 11 11 + 12 12 + Deno.test("Correctly references all definitions", () => { 13 13 + assertEquals(lex.getDef("com.example.kitchenSink"), LexiconDocs[0].defs.main); 14 14 + assertEquals( 15 15 + lex.getDef("lex:com.example.kitchenSink"), 16 16 + LexiconDocs[0].defs.main, 17 17 + ); 18 18 + assertEquals( 19 19 + lex.getDef("com.example.kitchenSink#main"), 20 20 + LexiconDocs[0].defs.main, 21 21 + ); 22 22 + assertEquals( 23 23 + lex.getDef("lex:com.example.kitchenSink#main"), 24 24 + LexiconDocs[0].defs.main, 25 25 + ); 26 26 + assertEquals( 27 27 + lex.getDef("com.example.kitchenSink#object"), 28 28 + LexiconDocs[0].defs.object, 29 29 + ); 30 30 + assertEquals( 31 31 + lex.getDef("lex:com.example.kitchenSink#object"), 32 32 + LexiconDocs[0].defs.object, 33 33 + ); 34 34 + });

+848

lexicon/tests/record_test.ts

reviewed

··· 1 1 + import { CID } from "multiformats/cid"; 2 2 + import { Lexicons } from "../mod.ts"; 3 3 + import LexiconDocs from "./scaffolds/lexicons.ts"; 4 4 + import { assert, assertEquals, assertThrows } from "@std/assert"; 5 5 + 6 6 + const lex = new Lexicons(LexiconDocs); 7 7 + 8 8 + const passingSink = { 9 9 + $type: "com.example.kitchenSink", 10 10 + object: { 11 11 + object: { boolean: true }, 12 12 + array: ["one", "two"], 13 13 + boolean: true, 14 14 + integer: 123, 15 15 + string: "string", 16 16 + }, 17 17 + array: ["one", "two"], 18 18 + boolean: true, 19 19 + integer: 123, 20 20 + string: "string", 21 21 + bytes: new Uint8Array([0, 1, 2, 3]), 22 22 + cidLink: CID.parse( 23 23 + "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a", 24 24 + ), 25 25 + }; 26 26 + 27 27 + Deno.test("Passes valid schemas", () => { 28 28 + lex.assertValidRecord("com.example.kitchenSink", passingSink); 29 29 + }); 30 30 + 31 31 + Deno.test("Fails invalid input types", () => { 32 32 + assertThrows(() => { 33 33 + lex.assertValidRecord("com.example.kitchenSink", undefined); 34 34 + }, "Record must be an object"); 35 35 + assertThrows(() => { 36 36 + lex.assertValidRecord("com.example.kitchenSink", 1234); 37 37 + }, "Record must be an object"); 38 38 + assertThrows(() => { 39 39 + lex.assertValidRecord("com.example.kitchenSink", "string"); 40 40 + }, "Record must be an object"); 41 41 + }); 42 42 + 43 43 + Deno.test("Fails incorrect $type", () => { 44 44 + assertThrows(() => { 45 45 + lex.assertValidRecord("com.example.kitchenSink", {}); 46 46 + }, "Record/$type must be a string"); 47 47 + assertThrows(() => { 48 48 + lex.assertValidRecord("com.example.kitchenSink", { $type: "foo" }); 49 49 + }, "Invalid $type: must be lex:com.example.kitchenSink, got foo"); 50 50 + }); 51 51 + 52 52 + Deno.test("Fails missing required", () => { 53 53 + assertThrows(() => { 54 54 + lex.assertValidRecord("com.example.kitchenSink", { 55 55 + $type: "com.example.kitchenSink", 56 56 + array: ["one", "two"], 57 57 + boolean: true, 58 58 + integer: 123, 59 59 + string: "string", 60 60 + datetime: new Date().toISOString(), 61 61 + atUri: "at://did:web:example.com/com.example.test/self", 62 62 + did: "did:web:example.com", 63 63 + cid: "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a", 64 64 + bytes: new Uint8Array([0, 1, 2, 3]), 65 65 + cidLink: CID.parse( 66 66 + "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a", 67 67 + ), 68 68 + }); 69 69 + }, "Record must have the property 'object'"); 70 70 + assertThrows(() => { 71 71 + lex.assertValidRecord("com.example.kitchenSink", { 72 72 + ...passingSink, 73 73 + object: undefined, 74 74 + }); 75 75 + }, "Record must have the property 'object'"); 76 76 + }); 77 77 + 78 78 + Deno.test("Fails incorrect types", () => { 79 79 + assertThrows(() => { 80 80 + lex.assertValidRecord("com.example.kitchenSink", { 81 81 + ...passingSink, 82 82 + object: { 83 83 + ...passingSink.object, 84 84 + object: { boolean: "1234" }, 85 85 + }, 86 86 + }); 87 87 + }, "Record/object/object/boolean must be a boolean"); 88 88 + assertThrows(() => { 89 89 + lex.assertValidRecord("com.example.kitchenSink", { 90 90 + ...passingSink, 91 91 + object: true, 92 92 + }); 93 93 + }, "Record/object must be an object"); 94 94 + assertThrows(() => { 95 95 + lex.assertValidRecord("com.example.kitchenSink", { 96 96 + ...passingSink, 97 97 + array: 1234, 98 98 + }); 99 99 + }, "Record/array must be an array"); 100 100 + assertThrows(() => { 101 101 + lex.assertValidRecord("com.example.kitchenSink", { 102 102 + ...passingSink, 103 103 + integer: true, 104 104 + }); 105 105 + }, "Record/integer must be an integer"); 106 106 + assertThrows(() => { 107 107 + lex.assertValidRecord("com.example.kitchenSink", { 108 108 + ...passingSink, 109 109 + string: {}, 110 110 + }); 111 111 + }, "Record/string must be a string"); 112 112 + assertThrows(() => { 113 113 + lex.assertValidRecord("com.example.kitchenSink", { 114 114 + ...passingSink, 115 115 + bytes: 1234, 116 116 + }); 117 117 + }, "Record/bytes must be a byte array"); 118 118 + assertThrows(() => { 119 119 + lex.assertValidRecord("com.example.kitchenSink", { 120 120 + ...passingSink, 121 121 + cidLink: "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a", 122 122 + }); 123 123 + }, "Record/cidLink must be a CID"); 124 124 + }); 125 125 + 126 126 + Deno.test("Handles optional properties correctly", () => { 127 127 + lex.assertValidRecord("com.example.optional", { 128 128 + $type: "com.example.optional", 129 129 + }); 130 130 + }); 131 131 + 132 132 + Deno.test("Handles default properties correctly", () => { 133 133 + const result = lex.assertValidRecord("com.example.default", { 134 134 + $type: "com.example.default", 135 135 + object: {}, 136 136 + }); 137 137 + assertEquals(result, { 138 138 + $type: "com.example.default", 139 139 + boolean: false, 140 140 + integer: 0, 141 141 + string: "", 142 142 + object: { 143 143 + boolean: true, 144 144 + integer: 1, 145 145 + string: "x", 146 146 + }, 147 147 + }); 148 148 + assert(!("datetime" in (result as Record<string, unknown>))); 149 149 + }); 150 150 + 151 151 + Deno.test("Handles unions correctly", () => { 152 152 + lex.assertValidRecord("com.example.union", { 153 153 + $type: "com.example.union", 154 154 + unionOpen: { 155 155 + $type: "com.example.kitchenSink#object", 156 156 + object: { boolean: true }, 157 157 + array: ["one", "two"], 158 158 + boolean: true, 159 159 + integer: 123, 160 160 + string: "string", 161 161 + }, 162 162 + unionClosed: { 163 163 + $type: "com.example.kitchenSink#subobject", 164 164 + boolean: true, 165 165 + }, 166 166 + }); 167 167 + lex.assertValidRecord("com.example.union", { 168 168 + $type: "com.example.union", 169 169 + unionOpen: { 170 170 + $type: "com.example.other", 171 171 + }, 172 172 + unionClosed: { 173 173 + $type: "com.example.kitchenSink#subobject", 174 174 + boolean: true, 175 175 + }, 176 176 + }); 177 177 + assertThrows(() => { 178 178 + lex.assertValidRecord("com.example.union", { 179 179 + $type: "com.example.union", 180 180 + unionOpen: {}, 181 181 + unionClosed: {}, 182 182 + }); 183 183 + }, 'Record/unionOpen must be an object which includes the "$type" property'); 184 184 + assertThrows( 185 185 + () => { 186 186 + lex.assertValidRecord("com.example.union", { 187 187 + $type: "com.example.union", 188 188 + unionOpen: { 189 189 + $type: "com.example.other", 190 190 + }, 191 191 + unionClosed: { 192 192 + $type: "com.example.other", 193 193 + boolean: true, 194 194 + }, 195 195 + }); 196 196 + }, 197 197 + "Record/unionClosed $type must be one of lex:com.example.kitchenSink#object, lex:com.example.kitchenSink#subobject", 198 198 + ); 199 199 + }); 200 200 + 201 201 + Deno.test("Handles unknowns correctly", () => { 202 202 + lex.assertValidRecord("com.example.unknown", { 203 203 + $type: "com.example.unknown", 204 204 + unknown: { foo: "bar" }, 205 205 + }); 206 206 + assertThrows(() => { 207 207 + lex.assertValidRecord("com.example.unknown", { 208 208 + $type: "com.example.unknown", 209 209 + }); 210 210 + }, 'Record must have the property "unknown"'); 211 211 + }); 212 212 + 213 213 + Deno.test("Applies array length constraints", () => { 214 214 + lex.assertValidRecord("com.example.arrayLength", { 215 215 + $type: "com.example.arrayLength", 216 216 + array: [1, 2, 3], 217 217 + }); 218 218 + assertThrows(() => { 219 219 + lex.assertValidRecord("com.example.arrayLength", { 220 220 + $type: "com.example.arrayLength", 221 221 + array: [1], 222 222 + }); 223 223 + }, "Record/array must not have fewer than 2 elements"); 224 224 + assertThrows(() => { 225 225 + lex.assertValidRecord("com.example.arrayLength", { 226 226 + $type: "com.example.arrayLength", 227 227 + array: [1, 2, 3, 4, 5], 228 228 + }); 229 229 + }, "Record/array must not have more than 4 elements"); 230 230 + }); 231 231 + 232 232 + Deno.test("Applies array item constraints", () => { 233 233 + assertThrows(() => { 234 234 + lex.assertValidRecord("com.example.arrayLength", { 235 235 + $type: "com.example.arrayLength", 236 236 + array: [1, "2", 3], 237 237 + }); 238 238 + }, "Record/array/1 must be an integer"); 239 239 + assertThrows(() => { 240 240 + lex.assertValidRecord("com.example.arrayLength", { 241 241 + $type: "com.example.arrayLength", 242 242 + array: [1, undefined, 3], 243 243 + }); 244 244 + }, "Record/array/1 must be an integer"); 245 245 + }); 246 246 + 247 247 + Deno.test("Applies boolean const constraint", () => { 248 248 + lex.assertValidRecord("com.example.boolConst", { 249 249 + $type: "com.example.boolConst", 250 250 + boolean: false, 251 251 + }); 252 252 + assertThrows(() => { 253 253 + lex.assertValidRecord("com.example.boolConst", { 254 254 + $type: "com.example.boolConst", 255 255 + boolean: true, 256 256 + }); 257 257 + }, "Record/boolean must be false"); 258 258 + }); 259 259 + 260 260 + Deno.test("Applies integer range constraint", () => { 261 261 + lex.assertValidRecord("com.example.integerRange", { 262 262 + $type: "com.example.integerRange", 263 263 + integer: 2, 264 264 + }); 265 265 + assertThrows(() => { 266 266 + lex.assertValidRecord("com.example.integerRange", { 267 267 + $type: "com.example.integerRange", 268 268 + integer: 1, 269 269 + }); 270 270 + }, "Record/integer can not be less than 2"); 271 271 + assertThrows(() => { 272 272 + lex.assertValidRecord("com.example.integerRange", { 273 273 + $type: "com.example.integerRange", 274 274 + integer: 5, 275 275 + }); 276 276 + }, "Record/integer can not be greater than 4"); 277 277 + }); 278 278 + 279 279 + Deno.test("Applies integer enum constraint", () => { 280 280 + lex.assertValidRecord("com.example.integerEnum", { 281 281 + $type: "com.example.integerEnum", 282 282 + integer: 2, 283 283 + }); 284 284 + assertThrows(() => { 285 285 + lex.assertValidRecord("com.example.integerEnum", { 286 286 + $type: "com.example.integerEnum", 287 287 + integer: 0, 288 288 + }); 289 289 + }, "Record/integer must be one of (1|2)"); 290 290 + }); 291 291 + 292 292 + Deno.test("Applies integer const constraint", () => { 293 293 + lex.assertValidRecord("com.example.integerConst", { 294 294 + $type: "com.example.integerConst", 295 295 + integer: 0, 296 296 + }); 297 297 + assertThrows(() => { 298 298 + lex.assertValidRecord("com.example.integerConst", { 299 299 + $type: "com.example.integerConst", 300 300 + integer: 1, 301 301 + }); 302 302 + }, "Record/integer must be 0"); 303 303 + }); 304 304 + 305 305 + Deno.test("Applies integer whole-number constraint", () => { 306 306 + assertThrows(() => { 307 307 + lex.assertValidRecord("com.example.integerRange", { 308 308 + $type: "com.example.integerRange", 309 309 + integer: 2.5, 310 310 + }); 311 311 + }, "Record/integer must be an integer"); 312 312 + }); 313 313 + 314 314 + Deno.test("Applies string length constraint", () => { 315 315 + // Shorter than two UTF8 characters 316 316 + assertThrows(() => { 317 317 + lex.assertValidRecord("com.example.stringLength", { 318 318 + $type: "com.example.stringLength", 319 319 + string: "", 320 320 + }); 321 321 + }, "Record/string must not be shorter than 2 characters"); 322 322 + assertThrows(() => { 323 323 + lex.assertValidRecord("com.example.stringLength", { 324 324 + $type: "com.example.stringLength", 325 325 + string: "a", 326 326 + }); 327 327 + }, "Record/string must not be shorter than 2 characters"); 328 328 + 329 329 + // Two to four UTF8 characters 330 330 + lex.assertValidRecord("com.example.stringLength", { 331 331 + $type: "com.example.stringLength", 332 332 + string: "ab", 333 333 + }); 334 334 + lex.assertValidRecord("com.example.stringLength", { 335 335 + $type: "com.example.stringLength", 336 336 + string: "\u0301", // Combining acute accent (2 bytes) 337 337 + }); 338 338 + lex.assertValidRecord("com.example.stringLength", { 339 339 + $type: "com.example.stringLength", 340 340 + string: "a\u0301", // 'a' + combining acute accent (1 + 2 bytes = 3 bytes) 341 341 + }); 342 342 + lex.assertValidRecord("com.example.stringLength", { 343 343 + $type: "com.example.stringLength", 344 344 + string: "aé", // 'a' (1 byte) + 'é' (2 bytes) = 3 bytes 345 345 + }); 346 346 + lex.assertValidRecord("com.example.stringLength", { 347 347 + $type: "com.example.stringLength", 348 348 + string: "abc", 349 349 + }); 350 350 + lex.assertValidRecord("com.example.stringLength", { 351 351 + $type: "com.example.stringLength", 352 352 + string: "一", // CJK character (3 bytes) 353 353 + }); 354 354 + lex.assertValidRecord("com.example.stringLength", { 355 355 + $type: "com.example.stringLength", 356 356 + string: "\uD83D", // Unpaired high surrogate (3 bytes) 357 357 + }); 358 358 + lex.assertValidRecord("com.example.stringLength", { 359 359 + $type: "com.example.stringLength", 360 360 + string: "abcd", 361 361 + }); 362 362 + lex.assertValidRecord("com.example.stringLength", { 363 363 + $type: "com.example.stringLength", 364 364 + string: "éé", // 'é' + 'é' (2 + 2 bytes = 4 bytes) 365 365 + }); 366 366 + lex.assertValidRecord("com.example.stringLength", { 367 367 + $type: "com.example.stringLength", 368 368 + string: "aaé", // 1 + 1 + 2 = 4 bytes 369 369 + }); 370 370 + lex.assertValidRecord("com.example.stringLength", { 371 371 + $type: "com.example.stringLength", 372 372 + string: "👋", // 4 bytes 373 373 + }); 374 374 + 375 375 + assertThrows(() => { 376 376 + lex.assertValidRecord("com.example.stringLength", { 377 377 + $type: "com.example.stringLength", 378 378 + string: "abcde", 379 379 + }); 380 380 + }, "Record/string must not be longer than 4 characters"); 381 381 + assertThrows(() => { 382 382 + lex.assertValidRecord("com.example.stringLength", { 383 383 + $type: "com.example.stringLength", 384 384 + string: "a\u0301\u0301", // 1 + (2 * 2) = 5 bytes 385 385 + }); 386 386 + }, "Record/string must not be longer than 4 characters"); 387 387 + assertThrows(() => { 388 388 + lex.assertValidRecord("com.example.stringLength", { 389 389 + $type: "com.example.stringLength", 390 390 + string: "\uD83D\uD83D", // Two unpaired high surrogates (3 * 2 = 6 bytes) 391 391 + }); 392 392 + }, "Record/string must not be longer than 4 characters"); 393 393 + assertThrows(() => { 394 394 + lex.assertValidRecord("com.example.stringLength", { 395 395 + $type: "com.example.stringLength", 396 396 + string: "ééé", // 2 + 2 + 2 bytes = 6 bytes 397 397 + }); 398 398 + }, "Record/string must not be longer than 4 characters"); 399 399 + assertThrows(() => { 400 400 + lex.assertValidRecord("com.example.stringLength", { 401 401 + $type: "com.example.stringLength", 402 402 + string: "👋a", // 4 + 1 bytes = 5 bytes 403 403 + }); 404 404 + }, "Record/string must not be longer than 4 characters"); 405 405 + assertThrows(() => { 406 406 + lex.assertValidRecord("com.example.stringLength", { 407 407 + $type: "com.example.stringLength", 408 408 + string: "👨👨", // 4 + 4 = 8 bytes 409 409 + }); 410 410 + }, "Record/string must not be longer than 4 characters"); 411 411 + assertThrows(() => { 412 412 + lex.assertValidRecord("com.example.stringLength", { 413 413 + $type: "com.example.stringLength", 414 414 + string: "👨‍👩‍👧‍👧", // 4 emojis × 4 bytes + 3 ZWJs × 3 bytes = 25 bytes 415 415 + }); 416 416 + }, "Record/string must not be longer than 4 characters"); 417 417 + }); 418 418 + 419 419 + Deno.test("Applies string length constraint (no minLength)", () => { 420 420 + // Shorter than two UTF8 characters 421 421 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 422 422 + $type: "com.example.stringLengthNoMinLength", 423 423 + string: "", 424 424 + }); 425 425 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 426 426 + $type: "com.example.stringLengthNoMinLength", 427 427 + string: "a", 428 428 + }); 429 429 + 430 430 + // Two to four UTF8 characters 431 431 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 432 432 + $type: "com.example.stringLengthNoMinLength", 433 433 + string: "ab", 434 434 + }); 435 435 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 436 436 + $type: "com.example.stringLengthNoMinLength", 437 437 + string: "\u0301", // Combining acute accent (2 bytes) 438 438 + }); 439 439 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 440 440 + $type: "com.example.stringLengthNoMinLength", 441 441 + string: "a\u0301", // 'a' + combining acute accent (1 + 2 bytes = 3 bytes) 442 442 + }); 443 443 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 444 444 + $type: "com.example.stringLengthNoMinLength", 445 445 + string: "aé", // 'a' (1 byte) + 'é' (2 bytes) = 3 bytes 446 446 + }); 447 447 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 448 448 + $type: "com.example.stringLengthNoMinLength", 449 449 + string: "abc", 450 450 + }); 451 451 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 452 452 + $type: "com.example.stringLengthNoMinLength", 453 453 + string: "一", // CJK character (3 bytes) 454 454 + }); 455 455 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 456 456 + $type: "com.example.stringLengthNoMinLength", 457 457 + string: "\uD83D", // Unpaired high surrogate (3 bytes) 458 458 + }); 459 459 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 460 460 + $type: "com.example.stringLengthNoMinLength", 461 461 + string: "abcd", 462 462 + }); 463 463 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 464 464 + $type: "com.example.stringLengthNoMinLength", 465 465 + string: "éé", // 'é' + 'é' (2 + 2 bytes = 4 bytes) 466 466 + }); 467 467 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 468 468 + $type: "com.example.stringLengthNoMinLength", 469 469 + string: "aaé", // 1 + 1 + 2 = 4 bytes 470 470 + }); 471 471 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 472 472 + $type: "com.example.stringLengthNoMinLength", 473 473 + string: "👋", // 4 bytes 474 474 + }); 475 475 + 476 476 + assertThrows(() => { 477 477 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 478 478 + $type: "com.example.stringLengthNoMinLength", 479 479 + string: "abcde", 480 480 + }); 481 481 + }, "Record/string must not be longer than 4 characters"); 482 482 + assertThrows(() => { 483 483 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 484 484 + $type: "com.example.stringLengthNoMinLength", 485 485 + string: "a\u0301\u0301", // 1 + (2 * 2) = 5 bytes 486 486 + }); 487 487 + }, "Record/string must not be longer than 4 characters"); 488 488 + assertThrows(() => { 489 489 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 490 490 + $type: "com.example.stringLengthNoMinLength", 491 491 + string: "\uD83D\uD83D", // Two unpaired high surrogates (3 * 2 = 6 bytes) 492 492 + }); 493 493 + }, "Record/string must not be longer than 4 characters"); 494 494 + assertThrows(() => { 495 495 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 496 496 + $type: "com.example.stringLengthNoMinLength", 497 497 + string: "ééé", // 2 + 2 + 2 bytes = 6 bytes 498 498 + }); 499 499 + }, "Record/string must not be longer than 4 characters"); 500 500 + assertThrows(() => { 501 501 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 502 502 + $type: "com.example.stringLengthNoMinLength", 503 503 + string: "👋a", // 4 + 1 bytes = 5 bytes 504 504 + }); 505 505 + }, "Record/string must not be longer than 4 characters"); 506 506 + assertThrows(() => { 507 507 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 508 508 + $type: "com.example.stringLengthNoMinLength", 509 509 + string: "👨👨", // 4 + 4 = 8 bytes 510 510 + }); 511 511 + }, "Record/string must not be longer than 4 characters"); 512 512 + assertThrows(() => { 513 513 + lex.assertValidRecord("com.example.stringLengthNoMinLength", { 514 514 + $type: "com.example.stringLengthNoMinLength", 515 515 + string: "👨‍👩‍👧‍👧", // 4 emojis × 4 bytes + 3 ZWJs × 3 bytes = 25 bytes 516 516 + }); 517 517 + }, "Record/string must not be longer than 4 characters"); 518 518 + }); 519 519 + 520 520 + Deno.test("Applies grapheme string length constraint", () => { 521 521 + // Shorter than two graphemes 522 522 + assertThrows(() => { 523 523 + lex.assertValidRecord("com.example.stringLengthGrapheme", { 524 524 + $type: "com.example.stringLengthGrapheme", 525 525 + string: "", 526 526 + }); 527 527 + }, "Record/string must not be shorter than 2 graphemes"); 528 528 + assertThrows(() => { 529 529 + lex.assertValidRecord("com.example.stringLengthGrapheme", { 530 530 + $type: "com.example.stringLengthGrapheme", 531 531 + string: "\u0301\u0301\u0301", // Three combining acute accents 532 532 + }); 533 533 + }, "Record/string must not be shorter than 2 graphemes"); 534 534 + assertThrows(() => { 535 535 + lex.assertValidRecord("com.example.stringLengthGrapheme", { 536 536 + $type: "com.example.stringLengthGrapheme", 537 537 + string: "a", 538 538 + }); 539 539 + }, "Record/string must not be shorter than 2 graphemes"); 540 540 + assertThrows(() => { 541 541 + lex.assertValidRecord("com.example.stringLengthGrapheme", { 542 542 + $type: "com.example.stringLengthGrapheme", 543 543 + string: "a\u0301\u0301\u0301\u0301", // 'á́́́' ('a' with four combining acute accents) 544 544 + }); 545 545 + }, "Record/string must not be shorter than 2 graphemes"); 546 546 + assertThrows(() => { 547 547 + lex.assertValidRecord("com.example.stringLengthGrapheme", { 548 548 + $type: "com.example.stringLengthGrapheme", 549 549 + string: "5\uFE0F", // '5️' with emoji presentation 550 550 + }); 551 551 + }, "Record/string must not be shorter than 2 graphemes"); 552 552 + assertThrows(() => { 553 553 + lex.assertValidRecord("com.example.stringLengthGrapheme", { 554 554 + $type: "com.example.stringLengthGrapheme", 555 555 + string: "👨‍👩‍👧‍👧", 556 556 + }); 557 557 + }, "Record/string must not be shorter than 2 graphemes"); 558 558 + 559 559 + // Two to four graphemes 560 560 + lex.assertValidRecord("com.example.stringLengthGrapheme", { 561 561 + $type: "com.example.stringLengthGrapheme", 562 562 + string: "ab", 563 563 + }); 564 564 + lex.assertValidRecord("com.example.stringLengthGrapheme", { 565 565 + $type: "com.example.stringLengthGrapheme", 566 566 + string: "a\u0301b", // 'áb' with combining accent 567 567 + }); 568 568 + lex.assertValidRecord("com.example.stringLengthGrapheme", { 569 569 + $type: "com.example.stringLengthGrapheme", 570 570 + string: "a\u0301b\u0301", // 'áb́' 571 571 + }); 572 572 + lex.assertValidRecord("com.example.stringLengthGrapheme", { 573 573 + $type: "com.example.stringLengthGrapheme", 574 574 + string: "😀😀", 575 575 + }); 576 576 + lex.assertValidRecord("com.example.stringLengthGrapheme", { 577 577 + $type: "com.example.stringLengthGrapheme", 578 578 + string: "12👨‍👩‍👧‍👧", 579 579 + }); 580 580 + lex.assertValidRecord("com.example.stringLengthGrapheme", { 581 581 + $type: "com.example.stringLengthGrapheme", 582 582 + string: "abcd", 583 583 + }); 584 584 + lex.assertValidRecord("com.example.stringLengthGrapheme", { 585 585 + $type: "com.example.stringLengthGrapheme", 586 586 + string: "a\u0301b\u0301c\u0301d\u0301", // 'áb́ćd́' 587 587 + }); 588 588 + 589 589 + // Longer than four graphemes 590 590 + assertThrows(() => { 591 591 + lex.assertValidRecord("com.example.stringLengthGrapheme", { 592 592 + $type: "com.example.stringLengthGrapheme", 593 593 + string: "abcde", 594 594 + }); 595 595 + }, "Record/string must not be longer than 4 graphemes"); 596 596 + assertThrows(() => { 597 597 + lex.assertValidRecord("com.example.stringLengthGrapheme", { 598 598 + $type: "com.example.stringLengthGrapheme", 599 599 + string: "a\u0301b\u0301c\u0301d\u0301e\u0301", // 'áb́ćd́é' 600 600 + }); 601 601 + }, "Record/string must not be longer than 4 graphemes"); 602 602 + assertThrows(() => { 603 603 + lex.assertValidRecord("com.example.stringLengthGrapheme", { 604 604 + $type: "com.example.stringLengthGrapheme", 605 605 + string: "😀😀😀😀😀", 606 606 + }); 607 607 + }, "Record/string must not be longer than 4 graphemes"); 608 608 + assertThrows(() => { 609 609 + lex.assertValidRecord("com.example.stringLengthGrapheme", { 610 610 + $type: "com.example.stringLengthGrapheme", 611 611 + string: "ab😀de", 612 612 + }); 613 613 + }, "Record/string must not be longer than 4 graphemes"); 614 614 + }); 615 615 + 616 616 + Deno.test("Applies string enum constraint", () => { 617 617 + lex.assertValidRecord("com.example.stringEnum", { 618 618 + $type: "com.example.stringEnum", 619 619 + string: "a", 620 620 + }); 621 621 + assertThrows(() => { 622 622 + lex.assertValidRecord("com.example.stringEnum", { 623 623 + $type: "com.example.stringEnum", 624 624 + string: "c", 625 625 + }); 626 626 + }, "Record/string must be one of (a|b)"); 627 627 + }); 628 628 + 629 629 + Deno.test("Applies string const constraint", () => { 630 630 + lex.assertValidRecord("com.example.stringConst", { 631 631 + $type: "com.example.stringConst", 632 632 + string: "a", 633 633 + }); 634 634 + assertThrows(() => { 635 635 + lex.assertValidRecord("com.example.stringConst", { 636 636 + $type: "com.example.stringConst", 637 637 + string: "b", 638 638 + }); 639 639 + }, "Record/string must be a"); 640 640 + }); 641 641 + 642 642 + Deno.test("Applies datetime formatting constraint", () => { 643 643 + for ( 644 644 + const datetime of [ 645 645 + "2022-12-12T00:50:36.809Z", 646 646 + "2022-12-12T00:50:36Z", 647 647 + "2022-12-12T00:50:36.8Z", 648 648 + "2022-12-12T00:50:36.80Z", 649 649 + "2022-12-12T00:50:36+00:00", 650 650 + "2022-12-12T00:50:36.8+00:00", 651 651 + "2022-12-11T19:50:36-05:00", 652 652 + "2022-12-11T19:50:36.8-05:00", 653 653 + "2022-12-11T19:50:36.80-05:00", 654 654 + "2022-12-11T19:50:36.809-05:00", 655 655 + ] 656 656 + ) { 657 657 + lex.assertValidRecord("com.example.datetime", { 658 658 + $type: "com.example.datetime", 659 659 + datetime, 660 660 + }); 661 661 + } 662 662 + assertThrows( 663 663 + () => { 664 664 + lex.assertValidRecord("com.example.datetime", { 665 665 + $type: "com.example.datetime", 666 666 + datetime: "bad date", 667 667 + }); 668 668 + }, 669 669 + "Record/datetime must be an valid atproto datetime (both RFC-3339 and ISO-8601)", 670 670 + ); 671 671 + }); 672 672 + 673 673 + Deno.test("Applies uri formatting constraint", () => { 674 674 + for ( 675 675 + const uri of [ 676 676 + "https://example.com", 677 677 + "https://example.com/with/path", 678 678 + "https://example.com/with/path?and=query", 679 679 + "at://bsky.social", 680 680 + "did:example:test", 681 681 + ] 682 682 + ) { 683 683 + lex.assertValidRecord("com.example.uri", { 684 684 + $type: "com.example.uri", 685 685 + uri, 686 686 + }); 687 687 + } 688 688 + assertThrows(() => { 689 689 + lex.assertValidRecord("com.example.uri", { 690 690 + $type: "com.example.uri", 691 691 + uri: "not a uri", 692 692 + }); 693 693 + }, "Record/uri must be a uri"); 694 694 + }); 695 695 + 696 696 + Deno.test("Applies at-uri formatting constraint", () => { 697 697 + lex.assertValidRecord("com.example.atUri", { 698 698 + $type: "com.example.atUri", 699 699 + atUri: "at://did:web:example.com/com.example.test/self", 700 700 + }); 701 701 + assertThrows(() => { 702 702 + lex.assertValidRecord("com.example.atUri", { 703 703 + $type: "com.example.atUri", 704 704 + atUri: "http://not-atproto.com", 705 705 + }); 706 706 + }, "Record/atUri must be a valid at-uri"); 707 707 + }); 708 708 + 709 709 + Deno.test("Applies did formatting constraint", () => { 710 710 + lex.assertValidRecord("com.example.did", { 711 711 + $type: "com.example.did", 712 712 + did: "did:web:example.com", 713 713 + }); 714 714 + lex.assertValidRecord("com.example.did", { 715 715 + $type: "com.example.did", 716 716 + did: "did:plc:12345678abcdefghijklmnop", 717 717 + }); 718 718 + 719 719 + assertThrows(() => { 720 720 + lex.assertValidRecord("com.example.did", { 721 721 + $type: "com.example.did", 722 722 + did: "bad did", 723 723 + }); 724 724 + }, "Record/did must be a valid did"); 725 725 + assertThrows(() => { 726 726 + lex.assertValidRecord("com.example.did", { 727 727 + $type: "com.example.did", 728 728 + did: "did:short", 729 729 + }); 730 730 + }, "Record/did must be a valid did"); 731 731 + }); 732 732 + 733 733 + Deno.test("Applies handle formatting constraint", () => { 734 734 + lex.assertValidRecord("com.example.handle", { 735 735 + $type: "com.example.handle", 736 736 + handle: "test.bsky.social", 737 737 + }); 738 738 + lex.assertValidRecord("com.example.handle", { 739 739 + $type: "com.example.handle", 740 740 + handle: "bsky.test", 741 741 + }); 742 742 + 743 743 + assertThrows(() => { 744 744 + lex.assertValidRecord("com.example.handle", { 745 745 + $type: "com.example.handle", 746 746 + handle: "bad handle", 747 747 + }); 748 748 + }, "Record/handle must be a valid handle"); 749 749 + assertThrows(() => { 750 750 + lex.assertValidRecord("com.example.handle", { 751 751 + $type: "com.example.handle", 752 752 + handle: "-bad-.test", 753 753 + }); 754 754 + }, "Record/handle must be a valid handle"); 755 755 + }); 756 756 + 757 757 + Deno.test("Applies at-identifier formatting constraint", () => { 758 758 + lex.assertValidRecord("com.example.atIdentifier", { 759 759 + $type: "com.example.atIdentifier", 760 760 + atIdentifier: "bsky.test", 761 761 + }); 762 762 + lex.assertValidRecord("com.example.atIdentifier", { 763 763 + $type: "com.example.atIdentifier", 764 764 + atIdentifier: "did:plc:12345678abcdefghijklmnop", 765 765 + }); 766 766 + 767 767 + assertThrows(() => { 768 768 + lex.assertValidRecord("com.example.atIdentifier", { 769 769 + $type: "com.example.atIdentifier", 770 770 + atIdentifier: "bad id", 771 771 + }); 772 772 + }, "Record/atIdentifier must be a valid did or a handle"); 773 773 + assertThrows(() => { 774 774 + lex.assertValidRecord("com.example.atIdentifier", { 775 775 + $type: "com.example.atIdentifier", 776 776 + atIdentifier: "-bad-.test", 777 777 + }); 778 778 + }, "Record/atIdentifier must be a valid did or a handle"); 779 779 + }); 780 780 + 781 781 + Deno.test("Applies nsid formatting constraint", () => { 782 782 + lex.assertValidRecord("com.example.nsid", { 783 783 + $type: "com.example.nsid", 784 784 + nsid: "com.atproto.test", 785 785 + }); 786 786 + lex.assertValidRecord("com.example.nsid", { 787 787 + $type: "com.example.nsid", 788 788 + nsid: "app.bsky.nested.test", 789 789 + }); 790 790 + 791 791 + assertThrows(() => { 792 792 + lex.assertValidRecord("com.example.nsid", { 793 793 + $type: "com.example.nsid", 794 794 + nsid: "bad nsid", 795 795 + }); 796 796 + }, "Record/nsid must be a valid nsid"); 797 797 + assertThrows(() => { 798 798 + lex.assertValidRecord("com.example.nsid", { 799 799 + $type: "com.example.nsid", 800 800 + nsid: "com.bad-.foo", 801 801 + }); 802 802 + }, "Record/nsid must be a valid nsid"); 803 803 + }); 804 804 + 805 805 + Deno.test("Applies cid formatting constraint", () => { 806 806 + lex.assertValidRecord("com.example.cid", { 807 807 + $type: "com.example.cid", 808 808 + cid: "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a", 809 809 + }); 810 810 + assertThrows(() => { 811 811 + lex.assertValidRecord("com.example.cid", { 812 812 + $type: "com.example.cid", 813 813 + cid: "abapsdofiuwrpoiasdfuaspdfoiu", 814 814 + }); 815 815 + }, "Record/cid must be a cid string"); 816 816 + }); 817 817 + 818 818 + Deno.test("Applies language formatting constraint", () => { 819 819 + lex.assertValidRecord("com.example.language", { 820 820 + $type: "com.example.language", 821 821 + language: "en-US-boont", 822 822 + }); 823 823 + assertThrows(() => { 824 824 + lex.assertValidRecord("com.example.language", { 825 825 + $type: "com.example.language", 826 826 + language: "not-a-language-", 827 827 + }); 828 828 + }, "Record/language must be a well-formed BCP 47 language tag"); 829 829 + }); 830 830 + 831 831 + Deno.test("Applies bytes length constraints", () => { 832 832 + lex.assertValidRecord("com.example.byteLength", { 833 833 + $type: "com.example.byteLength", 834 834 + bytes: new Uint8Array([1, 2, 3]), 835 835 + }); 836 836 + assertThrows(() => 837 837 + lex.assertValidRecord("com.example.byteLength", { 838 838 + $type: "com.example.byteLength", 839 839 + bytes: new Uint8Array([1]), 840 840 + }) 841 841 + ); 842 842 + assertThrows(() => 843 843 + lex.assertValidRecord("com.example.byteLength", { 844 844 + $type: "com.example.byteLength", 845 845 + bytes: new Uint8Array([1, 2, 3, 4, 5]), 846 846 + }) 847 847 + ); 848 848 + });

+545

lexicon/tests/scaffolds/lexicons.ts

reviewed

··· 1 1 + import type { LexiconDoc } from "../../mod.ts"; 2 2 + 3 3 + const lexicons: LexiconDoc[] = [ 4 4 + { 5 5 + lexicon: 1, 6 6 + id: "com.example.kitchenSink", 7 7 + defs: { 8 8 + main: { 9 9 + type: "record", 10 10 + description: "A record", 11 11 + key: "tid", 12 12 + record: { 13 13 + type: "object", 14 14 + required: [ 15 15 + "object", 16 16 + "array", 17 17 + "boolean", 18 18 + "integer", 19 19 + "string", 20 20 + "bytes", 21 21 + "cidLink", 22 22 + ], 23 23 + properties: { 24 24 + object: { type: "ref", ref: "#object" }, 25 25 + array: { type: "array", items: { type: "string" } }, 26 26 + boolean: { type: "boolean" }, 27 27 + integer: { type: "integer" }, 28 28 + string: { type: "string" }, 29 29 + bytes: { type: "bytes" }, 30 30 + cidLink: { type: "cid-link" }, 31 31 + }, 32 32 + }, 33 33 + }, 34 34 + object: { 35 35 + type: "object", 36 36 + required: ["object", "array", "boolean", "integer", "string"], 37 37 + properties: { 38 38 + object: { type: "ref", ref: "#subobject" }, 39 39 + array: { type: "array", items: { type: "string" } }, 40 40 + boolean: { type: "boolean" }, 41 41 + integer: { type: "integer" }, 42 42 + string: { type: "string" }, 43 43 + }, 44 44 + }, 45 45 + subobject: { 46 46 + type: "object", 47 47 + required: ["boolean"], 48 48 + properties: { 49 49 + boolean: { type: "boolean" }, 50 50 + }, 51 51 + }, 52 52 + }, 53 53 + }, 54 54 + { 55 55 + lexicon: 1, 56 56 + id: "com.example.query", 57 57 + defs: { 58 58 + main: { 59 59 + type: "query", 60 60 + description: "A query", 61 61 + parameters: { 62 62 + type: "params", 63 63 + required: ["boolean", "integer"], 64 64 + properties: { 65 65 + boolean: { type: "boolean" }, 66 66 + integer: { type: "integer" }, 67 67 + string: { type: "string" }, 68 68 + array: { type: "array", items: { type: "string" } }, 69 69 + def: { type: "integer", default: 0 }, 70 70 + }, 71 71 + }, 72 72 + output: { 73 73 + encoding: "application/json", 74 74 + schema: { type: "ref", ref: "com.example.kitchenSink#object" }, 75 75 + }, 76 76 + }, 77 77 + }, 78 78 + }, 79 79 + { 80 80 + lexicon: 1, 81 81 + id: "com.example.procedure", 82 82 + defs: { 83 83 + main: { 84 84 + type: "procedure", 85 85 + description: "A procedure", 86 86 + parameters: { 87 87 + type: "params", 88 88 + required: ["boolean", "integer"], 89 89 + properties: { 90 90 + boolean: { type: "boolean" }, 91 91 + integer: { type: "integer" }, 92 92 + string: { type: "string" }, 93 93 + array: { type: "array", items: { type: "string" } }, 94 94 + }, 95 95 + }, 96 96 + input: { 97 97 + encoding: "application/json", 98 98 + schema: { type: "ref", ref: "com.example.kitchenSink#object" }, 99 99 + }, 100 100 + output: { 101 101 + encoding: "application/json", 102 102 + schema: { type: "ref", ref: "com.example.kitchenSink#object" }, 103 103 + }, 104 104 + }, 105 105 + }, 106 106 + }, 107 107 + { 108 108 + lexicon: 1, 109 109 + id: "com.example.optional", 110 110 + defs: { 111 111 + main: { 112 112 + type: "record", 113 113 + record: { 114 114 + type: "object", 115 115 + properties: { 116 116 + object: { type: "ref", ref: "com.example.kitchenSink#object" }, 117 117 + array: { type: "array", items: { type: "string" } }, 118 118 + boolean: { type: "boolean" }, 119 119 + integer: { type: "integer" }, 120 120 + string: { type: "string" }, 121 121 + }, 122 122 + }, 123 123 + }, 124 124 + }, 125 125 + }, 126 126 + { 127 127 + lexicon: 1, 128 128 + id: "com.example.default", 129 129 + defs: { 130 130 + main: { 131 131 + type: "record", 132 132 + record: { 133 133 + type: "object", 134 134 + required: ["boolean"], 135 135 + properties: { 136 136 + boolean: { type: "boolean", default: false }, 137 137 + integer: { type: "integer", default: 0 }, 138 138 + string: { type: "string", default: "" }, 139 139 + object: { type: "ref", ref: "#object" }, 140 140 + }, 141 141 + }, 142 142 + }, 143 143 + object: { 144 144 + type: "object", 145 145 + properties: { 146 146 + boolean: { type: "boolean", default: true }, 147 147 + integer: { type: "integer", default: 1 }, 148 148 + string: { type: "string", default: "x" }, 149 149 + }, 150 150 + }, 151 151 + }, 152 152 + }, 153 153 + { 154 154 + lexicon: 1, 155 155 + id: "com.example.union", 156 156 + defs: { 157 157 + main: { 158 158 + type: "record", 159 159 + description: "A record", 160 160 + key: "tid", 161 161 + record: { 162 162 + type: "object", 163 163 + required: ["unionOpen", "unionClosed"], 164 164 + properties: { 165 165 + unionOpen: { 166 166 + type: "union", 167 167 + refs: [ 168 168 + "com.example.kitchenSink#object", 169 169 + "com.example.kitchenSink#subobject", 170 170 + ], 171 171 + }, 172 172 + unionClosed: { 173 173 + type: "union", 174 174 + closed: true, 175 175 + refs: [ 176 176 + "com.example.kitchenSink#object", 177 177 + "com.example.kitchenSink#subobject", 178 178 + ], 179 179 + }, 180 180 + }, 181 181 + }, 182 182 + }, 183 183 + }, 184 184 + }, 185 185 + { 186 186 + lexicon: 1, 187 187 + id: "com.example.unknown", 188 188 + defs: { 189 189 + main: { 190 190 + type: "record", 191 191 + description: "A record", 192 192 + key: "tid", 193 193 + record: { 194 194 + type: "object", 195 195 + required: ["unknown"], 196 196 + properties: { 197 197 + unknown: { type: "unknown" }, 198 198 + optUnknown: { type: "unknown" }, 199 199 + }, 200 200 + }, 201 201 + }, 202 202 + }, 203 203 + }, 204 204 + { 205 205 + lexicon: 1, 206 206 + id: "com.example.arrayLength", 207 207 + defs: { 208 208 + main: { 209 209 + type: "record", 210 210 + record: { 211 211 + type: "object", 212 212 + properties: { 213 213 + array: { 214 214 + type: "array", 215 215 + minLength: 2, 216 216 + maxLength: 4, 217 217 + items: { type: "integer" }, 218 218 + }, 219 219 + }, 220 220 + }, 221 221 + }, 222 222 + }, 223 223 + }, 224 224 + { 225 225 + lexicon: 1, 226 226 + id: "com.example.boolConst", 227 227 + defs: { 228 228 + main: { 229 229 + type: "record", 230 230 + record: { 231 231 + type: "object", 232 232 + properties: { 233 233 + boolean: { 234 234 + type: "boolean", 235 235 + const: false, 236 236 + }, 237 237 + }, 238 238 + }, 239 239 + }, 240 240 + }, 241 241 + }, 242 242 + { 243 243 + lexicon: 1, 244 244 + id: "com.example.integerRange", 245 245 + defs: { 246 246 + main: { 247 247 + type: "record", 248 248 + record: { 249 249 + type: "object", 250 250 + properties: { 251 251 + integer: { 252 252 + type: "integer", 253 253 + minimum: 2, 254 254 + maximum: 4, 255 255 + }, 256 256 + }, 257 257 + }, 258 258 + }, 259 259 + }, 260 260 + }, 261 261 + { 262 262 + lexicon: 1, 263 263 + id: "com.example.integerEnum", 264 264 + defs: { 265 265 + main: { 266 266 + type: "record", 267 267 + record: { 268 268 + type: "object", 269 269 + properties: { 270 270 + integer: { 271 271 + type: "integer", 272 272 + enum: [1, 2], 273 273 + }, 274 274 + }, 275 275 + }, 276 276 + }, 277 277 + }, 278 278 + }, 279 279 + { 280 280 + lexicon: 1, 281 281 + id: "com.example.integerConst", 282 282 + defs: { 283 283 + main: { 284 284 + type: "record", 285 285 + record: { 286 286 + type: "object", 287 287 + properties: { 288 288 + integer: { 289 289 + type: "integer", 290 290 + const: 0, 291 291 + }, 292 292 + }, 293 293 + }, 294 294 + }, 295 295 + }, 296 296 + }, 297 297 + { 298 298 + lexicon: 1, 299 299 + id: "com.example.stringLength", 300 300 + defs: { 301 301 + main: { 302 302 + type: "record", 303 303 + record: { 304 304 + type: "object", 305 305 + properties: { 306 306 + string: { 307 307 + type: "string", 308 308 + minLength: 2, 309 309 + maxLength: 4, 310 310 + }, 311 311 + }, 312 312 + }, 313 313 + }, 314 314 + }, 315 315 + }, 316 316 + { 317 317 + lexicon: 1, 318 318 + id: "com.example.stringLengthNoMinLength", 319 319 + defs: { 320 320 + main: { 321 321 + type: "record", 322 322 + record: { 323 323 + type: "object", 324 324 + properties: { 325 325 + string: { 326 326 + type: "string", 327 327 + maxLength: 4, 328 328 + }, 329 329 + }, 330 330 + }, 331 331 + }, 332 332 + }, 333 333 + }, 334 334 + { 335 335 + lexicon: 1, 336 336 + id: "com.example.stringLengthGrapheme", 337 337 + defs: { 338 338 + main: { 339 339 + type: "record", 340 340 + record: { 341 341 + type: "object", 342 342 + properties: { 343 343 + string: { 344 344 + type: "string", 345 345 + minGraphemes: 2, 346 346 + maxGraphemes: 4, 347 347 + }, 348 348 + }, 349 349 + }, 350 350 + }, 351 351 + }, 352 352 + }, 353 353 + { 354 354 + lexicon: 1, 355 355 + id: "com.example.stringEnum", 356 356 + defs: { 357 357 + main: { 358 358 + type: "record", 359 359 + record: { 360 360 + type: "object", 361 361 + properties: { 362 362 + string: { 363 363 + type: "string", 364 364 + enum: ["a", "b"], 365 365 + }, 366 366 + }, 367 367 + }, 368 368 + }, 369 369 + }, 370 370 + }, 371 371 + { 372 372 + lexicon: 1, 373 373 + id: "com.example.stringConst", 374 374 + defs: { 375 375 + main: { 376 376 + type: "record", 377 377 + record: { 378 378 + type: "object", 379 379 + properties: { 380 380 + string: { 381 381 + type: "string", 382 382 + const: "a", 383 383 + }, 384 384 + }, 385 385 + }, 386 386 + }, 387 387 + }, 388 388 + }, 389 389 + { 390 390 + lexicon: 1, 391 391 + id: "com.example.datetime", 392 392 + defs: { 393 393 + main: { 394 394 + type: "record", 395 395 + record: { 396 396 + type: "object", 397 397 + properties: { 398 398 + datetime: { type: "string", format: "datetime" }, 399 399 + }, 400 400 + }, 401 401 + }, 402 402 + }, 403 403 + }, 404 404 + { 405 405 + lexicon: 1, 406 406 + id: "com.example.uri", 407 407 + defs: { 408 408 + main: { 409 409 + type: "record", 410 410 + record: { 411 411 + type: "object", 412 412 + properties: { 413 413 + uri: { type: "string", format: "uri" }, 414 414 + }, 415 415 + }, 416 416 + }, 417 417 + }, 418 418 + }, 419 419 + { 420 420 + lexicon: 1, 421 421 + id: "com.example.atUri", 422 422 + defs: { 423 423 + main: { 424 424 + type: "record", 425 425 + record: { 426 426 + type: "object", 427 427 + properties: { 428 428 + atUri: { type: "string", format: "at-uri" }, 429 429 + }, 430 430 + }, 431 431 + }, 432 432 + }, 433 433 + }, 434 434 + { 435 435 + lexicon: 1, 436 436 + id: "com.example.did", 437 437 + defs: { 438 438 + main: { 439 439 + type: "record", 440 440 + record: { 441 441 + type: "object", 442 442 + properties: { 443 443 + did: { type: "string", format: "did" }, 444 444 + }, 445 445 + }, 446 446 + }, 447 447 + }, 448 448 + }, 449 449 + { 450 450 + lexicon: 1, 451 451 + id: "com.example.handle", 452 452 + defs: { 453 453 + main: { 454 454 + type: "record", 455 455 + record: { 456 456 + type: "object", 457 457 + properties: { 458 458 + handle: { type: "string", format: "handle" }, 459 459 + }, 460 460 + }, 461 461 + }, 462 462 + }, 463 463 + }, 464 464 + { 465 465 + lexicon: 1, 466 466 + id: "com.example.atIdentifier", 467 467 + defs: { 468 468 + main: { 469 469 + type: "record", 470 470 + record: { 471 471 + type: "object", 472 472 + properties: { 473 473 + atIdentifier: { type: "string", format: "at-identifier" }, 474 474 + }, 475 475 + }, 476 476 + }, 477 477 + }, 478 478 + }, 479 479 + { 480 480 + lexicon: 1, 481 481 + id: "com.example.nsid", 482 482 + defs: { 483 483 + main: { 484 484 + type: "record", 485 485 + record: { 486 486 + type: "object", 487 487 + properties: { 488 488 + nsid: { type: "string", format: "nsid" }, 489 489 + }, 490 490 + }, 491 491 + }, 492 492 + }, 493 493 + }, 494 494 + { 495 495 + lexicon: 1, 496 496 + id: "com.example.cid", 497 497 + defs: { 498 498 + main: { 499 499 + type: "record", 500 500 + record: { 501 501 + type: "object", 502 502 + properties: { 503 503 + cid: { type: "string", format: "cid" }, 504 504 + }, 505 505 + }, 506 506 + }, 507 507 + }, 508 508 + }, 509 509 + { 510 510 + lexicon: 1, 511 511 + id: "com.example.language", 512 512 + defs: { 513 513 + main: { 514 514 + type: "record", 515 515 + record: { 516 516 + type: "object", 517 517 + properties: { 518 518 + language: { type: "string", format: "language" }, 519 519 + }, 520 520 + }, 521 521 + }, 522 522 + }, 523 523 + }, 524 524 + { 525 525 + lexicon: 1, 526 526 + id: "com.example.byteLength", 527 527 + defs: { 528 528 + main: { 529 529 + type: "record", 530 530 + record: { 531 531 + type: "object", 532 532 + properties: { 533 533 + bytes: { 534 534 + type: "bytes", 535 535 + minLength: 2, 536 536 + maxLength: 4, 537 537 + }, 538 538 + }, 539 539 + }, 540 540 + }, 541 541 + }, 542 542 + }, 543 543 + ]; 544 544 + 545 545 + export default lexicons;

+227

lexicon/tests/validation_test.ts

reviewed

··· 1 1 + import { CID } from "multiformats/cid"; 2 2 + import { type LexiconDoc, Lexicons, parseLexiconDoc } from "../mod.ts"; 3 3 + import LexiconDocs from "./scaffolds/lexicons.ts"; 4 4 + import { assert, assertEquals, assertFalse, assertThrows } from "@std/assert"; 5 5 + 6 6 + const lex = new Lexicons(LexiconDocs); 7 7 + 8 8 + Deno.test("Validates records correctly", () => { 9 9 + { 10 10 + const res = lex.validate("com.example.kitchenSink", { 11 11 + $type: "com.example.kitchenSink", 12 12 + object: { 13 13 + object: { boolean: true }, 14 14 + array: ["one", "two"], 15 15 + boolean: true, 16 16 + integer: 123, 17 17 + string: "string", 18 18 + }, 19 19 + array: ["one", "two"], 20 20 + boolean: true, 21 21 + integer: 123, 22 22 + string: "string", 23 23 + datetime: new Date().toISOString(), 24 24 + atUri: "at://did:web:example.com/com.example.test/self", 25 25 + did: "did:web:example.com", 26 26 + cid: "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a", 27 27 + bytes: new Uint8Array([0, 1, 2, 3]), 28 28 + cidLink: CID.parse( 29 29 + "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a", 30 30 + ), 31 31 + }); 32 32 + assert(res.success); 33 33 + } 34 34 + { 35 35 + const res = lex.validate("com.example.kitchenSink", {}); 36 36 + assertFalse(res.success); 37 37 + if (res.success) throw new Error("Asserted"); 38 38 + assertEquals(res.error?.message, 'Record must have the property "object"'); 39 39 + } 40 40 + }); 41 41 + Deno.test("Validates objects correctly", () => { 42 42 + { 43 43 + const res = lex.validate("com.example.kitchenSink#object", { 44 44 + object: { boolean: true }, 45 45 + array: ["one", "two"], 46 46 + boolean: true, 47 47 + integer: 123, 48 48 + string: "string", 49 49 + }); 50 50 + assert(res.success); 51 51 + } 52 52 + { 53 53 + const res = lex.validate("com.example.kitchenSink#object", {}); 54 54 + assertFalse(res.success); 55 55 + if (res.success) throw new Error("Asserted"); 56 56 + assertEquals(res.error?.message, 'Object must have the property "object"'); 57 57 + } 58 58 + }); 59 59 + Deno.test("fails when a required property is missing", () => { 60 60 + const schema = { 61 61 + lexicon: 1, 62 62 + id: "com.example.kitchenSink", 63 63 + defs: { 64 64 + test: { 65 65 + type: "object", 66 66 + required: ["foo"], 67 67 + properties: {}, 68 68 + }, 69 69 + }, 70 70 + }; 71 71 + assertThrows(() => { 72 72 + parseLexiconDoc(schema); 73 73 + }, 'Required field \\"foo\\" not defined'); 74 74 + }); 75 75 + Deno.test("allows unknown fields to be present", () => { 76 76 + const schema = { 77 77 + lexicon: 1, 78 78 + id: "com.example.unknownFields", 79 79 + defs: { 80 80 + test: { 81 81 + type: "object", 82 82 + properties: {}, 83 83 + foo: 3, 84 84 + }, 85 85 + }, 86 86 + }; 87 87 + 88 88 + assert(parseLexiconDoc(schema)); 89 89 + }); 90 90 + Deno.test("fails lexicon parsing when uri is invalid", () => { 91 91 + const schema: LexiconDoc = { 92 92 + lexicon: 1, 93 93 + id: "com.example.invalidUri", 94 94 + defs: { 95 95 + main: { 96 96 + type: "object", 97 97 + properties: { 98 98 + test: { type: "ref", ref: "com.example.invalid#test#test" }, 99 99 + }, 100 100 + }, 101 101 + }, 102 102 + }; 103 103 + 104 104 + assertThrows(() => { 105 105 + new Lexicons([schema]); 106 106 + }, "Uri can only have one hash segment"); 107 107 + }); 108 108 + Deno.test("fails validation when ref uri has multiple hash segments", () => { 109 109 + const schema: LexiconDoc = { 110 110 + lexicon: 1, 111 111 + id: "com.example.invalidUri", 112 112 + defs: { 113 113 + main: { 114 114 + type: "object", 115 115 + properties: { 116 116 + test: { type: "integer" }, 117 117 + }, 118 118 + }, 119 119 + object: { 120 120 + type: "object", 121 121 + required: ["test"], 122 122 + properties: { 123 123 + test: { 124 124 + type: "union", 125 125 + refs: ["com.example.invalidUri"], 126 126 + }, 127 127 + }, 128 128 + }, 129 129 + }, 130 130 + }; 131 131 + const lexicons = new Lexicons([schema]); 132 132 + assertThrows(() => { 133 133 + lexicons.validate("com.example.invalidUri#object", { 134 134 + test: { 135 135 + $type: "com.example.invalidUri#main#main", 136 136 + test: 123, 137 137 + }, 138 138 + }); 139 139 + }, "Uri can only have one hash segment"); 140 140 + }); 141 141 + Deno.test("union handles both implicit and explicit #main", () => { 142 142 + const schemas: LexiconDoc[] = [ 143 143 + { 144 144 + lexicon: 1, 145 145 + id: "com.example.implicitMain", 146 146 + defs: { 147 147 + main: { 148 148 + type: "object", 149 149 + required: ["test"], 150 150 + properties: { 151 151 + test: { type: "string" }, 152 152 + }, 153 153 + }, 154 154 + }, 155 155 + }, 156 156 + { 157 157 + lexicon: 1, 158 158 + id: "com.example.testImplicitMain", 159 159 + defs: { 160 160 + main: { 161 161 + type: "object", 162 162 + required: ["union"], 163 163 + properties: { 164 164 + union: { 165 165 + type: "union", 166 166 + refs: ["com.example.implicitMain"], 167 167 + }, 168 168 + }, 169 169 + }, 170 170 + }, 171 171 + }, 172 172 + { 173 173 + lexicon: 1, 174 174 + id: "com.example.testExplicitMain", 175 175 + defs: { 176 176 + main: { 177 177 + type: "object", 178 178 + required: ["union"], 179 179 + properties: { 180 180 + union: { 181 181 + type: "union", 182 182 + refs: ["com.example.implicitMain#main"], 183 183 + }, 184 184 + }, 185 185 + }, 186 186 + }, 187 187 + }, 188 188 + ]; 189 189 + 190 190 + const lexicon = new Lexicons(schemas); 191 191 + 192 192 + let result = lexicon.validate("com.example.testImplicitMain", { 193 193 + union: { 194 194 + $type: "com.example.implicitMain", 195 195 + test: 123, 196 196 + }, 197 197 + }); 198 198 + assertFalse(result.success); 199 199 + assertEquals(result["error"]?.message, "Object/union/test must be a string"); 200 200 + 201 201 + result = lexicon.validate("com.example.testImplicitMain", { 202 202 + union: { 203 203 + $type: "com.example.implicitMain#main", 204 204 + test: 123, 205 205 + }, 206 206 + }); 207 207 + assertFalse(result.success); 208 208 + assertEquals(result["error"]?.message, "Object/union/test must be a string"); 209 209 + 210 210 + result = lexicon.validate("com.example.testExplicitMain", { 211 211 + union: { 212 212 + $type: "com.example.implicitMain", 213 213 + test: 123, 214 214 + }, 215 215 + }); 216 216 + assertFalse(result.success); 217 217 + assertEquals(result["error"]?.message, "Object/union/test must be a string"); 218 218 + 219 219 + result = lexicon.validate("com.example.testExplicitMain", { 220 220 + union: { 221 221 + $type: "com.example.implicitMain#main", 222 222 + test: 123, 223 223 + }, 224 224 + }); 225 225 + assertFalse(result.success); 226 226 + assertEquals(result["error"]?.message, "Object/union/test must be a string"); 227 227 + });

+136

lexicon/tests/xrpc_test.ts

reviewed

··· 1 1 + import { Lexicons } from "../mod.ts"; 2 2 + import LexiconDocs from "./scaffolds/lexicons.ts"; 3 3 + import { assertEquals, assertThrows } from "@std/assert"; 4 4 + 5 5 + const lex = new Lexicons(LexiconDocs); 6 6 + 7 7 + Deno.test("Passes valid inputs", () => { 8 8 + lex.assertValidXrpcInput("com.example.procedure", { 9 9 + object: { boolean: true }, 10 10 + array: ["one", "two"], 11 11 + boolean: true, 12 12 + float: 123.45, 13 13 + integer: 123, 14 14 + string: "string", 15 15 + }); 16 16 + }); 17 17 + 18 18 + Deno.test("Validates the input", () => { 19 19 + // dont need to check this extensively since it's the same logic as tested in record validation 20 20 + assertThrows(() => { 21 21 + lex.assertValidXrpcInput("com.example.procedure", { 22 22 + object: { boolean: "string" }, 23 23 + array: ["one", "two"], 24 24 + boolean: true, 25 25 + float: 123.45, 26 26 + integer: 123, 27 27 + string: "string", 28 28 + }); 29 29 + }, "Input/object/boolean must be a boolean"); 30 30 + assertThrows(() => { 31 31 + lex.assertValidXrpcInput("com.example.procedure", {}); 32 32 + }, 'Input must have the property "object"'); 33 33 + }); 34 34 + 35 35 + Deno.test("Passes valid outputs", () => { 36 36 + lex.assertValidXrpcOutput("com.example.query", { 37 37 + object: { boolean: true }, 38 38 + array: ["one", "two"], 39 39 + boolean: true, 40 40 + float: 123.45, 41 41 + integer: 123, 42 42 + string: "string", 43 43 + }); 44 44 + lex.assertValidXrpcOutput("com.example.procedure", { 45 45 + object: { boolean: true }, 46 46 + array: ["one", "two"], 47 47 + boolean: true, 48 48 + float: 123.45, 49 49 + integer: 123, 50 50 + string: "string", 51 51 + }); 52 52 + }); 53 53 + 54 54 + Deno.test("Validates the output", () => { 55 55 + // dont need to check this extensively since it's the same logic as tested in record validation 56 56 + assertThrows(() => { 57 57 + lex.assertValidXrpcOutput("com.example.query", { 58 58 + object: { boolean: "string" }, 59 59 + array: ["one", "two"], 60 60 + boolean: true, 61 61 + float: 123.45, 62 62 + integer: 123, 63 63 + string: "string", 64 64 + }); 65 65 + }, "Output/object/boolean must be a boolean"); 66 66 + assertThrows(() => { 67 67 + lex.assertValidXrpcOutput("com.example.procedure", {}); 68 68 + }, 'Output must have the property "object"'); 69 69 + }); 70 70 + 71 71 + Deno.test("Passes valid parameters", () => { 72 72 + const queryResult = lex.assertValidXrpcParams("com.example.query", { 73 73 + boolean: true, 74 74 + integer: 123, 75 75 + string: "string", 76 76 + array: ["x", "y"], 77 77 + }); 78 78 + assertEquals(queryResult, { 79 79 + boolean: true, 80 80 + integer: 123, 81 81 + string: "string", 82 82 + array: ["x", "y"], 83 83 + def: 0, 84 84 + }); 85 85 + const paramResult = lex.assertValidXrpcParams("com.example.procedure", { 86 86 + boolean: true, 87 87 + integer: 123, 88 88 + string: "string", 89 89 + array: ["x", "y"], 90 90 + def: 1, 91 91 + }); 92 92 + assertEquals(paramResult, { 93 93 + boolean: true, 94 94 + integer: 123, 95 95 + string: "string", 96 96 + array: ["x", "y"], 97 97 + def: 1, 98 98 + }); 99 99 + }); 100 100 + 101 101 + Deno.test("Handles required correctly", () => { 102 102 + lex.assertValidXrpcParams("com.example.query", { 103 103 + boolean: true, 104 104 + integer: 123, 105 105 + }); 106 106 + assertThrows(() => { 107 107 + lex.assertValidXrpcParams("com.example.query", { 108 108 + boolean: true, 109 109 + }); 110 110 + }, 'Params must have the property "integer"'); 111 111 + assertThrows(() => { 112 112 + lex.assertValidXrpcParams("com.example.query", { 113 113 + boolean: true, 114 114 + integer: undefined, 115 115 + }); 116 116 + }, 'Params must have the property "integer"'); 117 117 + }); 118 118 + 119 119 + Deno.test("Validates parameter types", () => { 120 120 + assertThrows(() => { 121 121 + lex.assertValidXrpcParams("com.example.query", { 122 122 + boolean: "string", 123 123 + integer: 123, 124 124 + string: "string", 125 125 + }); 126 126 + }, "boolean must be a boolean"); 127 127 + assertThrows(() => { 128 128 + lex.assertValidXrpcParams("com.example.query", { 129 129 + boolean: true, 130 130 + float: 123.45, 131 131 + integer: 123, 132 132 + string: "string", 133 133 + array: "x", 134 134 + }); 135 135 + }, "array must be an array"); 136 136 + });

+509

lexicon/types.ts

reviewed

··· 1 1 + import { z } from "zod"; 2 2 + import { validateLanguage } from "@atp/common"; 3 3 + import { isValidNsid } from "@atp/syntax"; 4 4 + import { requiredPropertiesRefinement } from "./util.ts"; 5 5 + 6 6 + export const languageSchema = z 7 7 + .string() 8 8 + .refine(validateLanguage, "Invalid BCP47 language tag"); 9 9 + 10 10 + export const lexLang = z.record(languageSchema, z.string().optional()); 11 11 + 12 12 + export type LexLang = z.infer<typeof lexLang>; 13 13 + 14 14 + // primitives 15 15 + // = 16 16 + 17 17 + export const lexBoolean = z.object({ 18 18 + type: z.literal("boolean"), 19 19 + description: z.string().optional(), 20 20 + default: z.boolean().optional(), 21 21 + const: z.boolean().optional(), 22 22 + }); 23 23 + export type LexBoolean = z.infer<typeof lexBoolean>; 24 24 + 25 25 + export const lexInteger = z.object({ 26 26 + type: z.literal("integer"), 27 27 + description: z.string().optional(), 28 28 + default: z.number().int().optional(), 29 29 + minimum: z.number().int().optional(), 30 30 + maximum: z.number().int().optional(), 31 31 + enum: z.number().int().array().optional(), 32 32 + const: z.number().int().optional(), 33 33 + }); 34 34 + export type LexInteger = z.infer<typeof lexInteger>; 35 35 + 36 36 + export const lexStringFormat = z.enum([ 37 37 + "datetime", 38 38 + "uri", 39 39 + "at-uri", 40 40 + "did", 41 41 + "handle", 42 42 + "at-identifier", 43 43 + "nsid", 44 44 + "cid", 45 45 + "language", 46 46 + "tid", 47 47 + "record-key", 48 48 + ]); 49 49 + export type LexStringFormat = z.infer<typeof lexStringFormat>; 50 50 + 51 51 + export const lexString = z.object({ 52 52 + type: z.literal("string"), 53 53 + format: lexStringFormat.optional(), 54 54 + description: z.string().optional(), 55 55 + default: z.string().optional(), 56 56 + minLength: z.number().int().optional(), 57 57 + maxLength: z.number().int().optional(), 58 58 + minGraphemes: z.number().int().optional(), 59 59 + maxGraphemes: z.number().int().optional(), 60 60 + enum: z.string().array().optional(), 61 61 + const: z.string().optional(), 62 62 + knownValues: z.string().array().optional(), 63 63 + }); 64 64 + export type LexString = z.infer<typeof lexString>; 65 65 + 66 66 + export const lexUnknown = z.object({ 67 67 + type: z.literal("unknown"), 68 68 + description: z.string().optional(), 69 69 + }); 70 70 + export type LexUnknown = z.infer<typeof lexUnknown>; 71 71 + 72 72 + export const lexPrimitive = z.discriminatedUnion("type", [ 73 73 + lexBoolean, 74 74 + lexInteger, 75 75 + lexString, 76 76 + lexUnknown, 77 77 + ]); 78 78 + export type LexPrimitive = z.infer<typeof lexPrimitive>; 79 79 + 80 80 + // ipld types 81 81 + // = 82 82 + 83 83 + export const lexBytes = z.object({ 84 84 + type: z.literal("bytes"), 85 85 + description: z.string().optional(), 86 86 + maxLength: z.number().optional(), 87 87 + minLength: z.number().optional(), 88 88 + }); 89 89 + export type LexBytes = z.infer<typeof lexBytes>; 90 90 + 91 91 + export const lexCidLink = z.object({ 92 92 + type: z.literal("cid-link"), 93 93 + description: z.string().optional(), 94 94 + }); 95 95 + export type LexCidLink = z.infer<typeof lexCidLink>; 96 96 + 97 97 + export const lexIpldType = z.discriminatedUnion("type", [lexBytes, lexCidLink]); 98 98 + export type LexIpldType = z.infer<typeof lexIpldType>; 99 99 + 100 100 + // references 101 101 + // = 102 102 + 103 103 + export const lexRef = z.object({ 104 104 + type: z.literal("ref"), 105 105 + description: z.string().optional(), 106 106 + ref: z.string(), 107 107 + }); 108 108 + export type LexRef = z.infer<typeof lexRef>; 109 109 + 110 110 + export const lexRefUnion = z.object({ 111 111 + type: z.literal("union"), 112 112 + description: z.string().optional(), 113 113 + refs: z.string().array(), 114 114 + closed: z.boolean().optional(), 115 115 + }); 116 116 + export type LexRefUnion = z.infer<typeof lexRefUnion>; 117 117 + 118 118 + export const lexRefVariant = z.discriminatedUnion("type", [ 119 119 + lexRef, 120 120 + lexRefUnion, 121 121 + ]); 122 122 + export type LexRefVariant = z.infer<typeof lexRefVariant>; 123 123 + 124 124 + // blobs 125 125 + // = 126 126 + 127 127 + export const lexBlob = z.object({ 128 128 + type: z.literal("blob"), 129 129 + description: z.string().optional(), 130 130 + accept: z.string().array().optional(), 131 131 + maxSize: z.number().optional(), 132 132 + }); 133 133 + export type LexBlob = z.infer<typeof lexBlob>; 134 134 + 135 135 + // complex types 136 136 + // = 137 137 + 138 138 + export const lexArray = z.object({ 139 139 + type: z.literal("array"), 140 140 + description: z.string().optional(), 141 141 + items: z.discriminatedUnion("type", [ 142 142 + // lexPrimitive 143 143 + lexBoolean, 144 144 + lexInteger, 145 145 + lexString, 146 146 + lexUnknown, 147 147 + // lexIpldType 148 148 + lexBytes, 149 149 + lexCidLink, 150 150 + // lexRefVariant 151 151 + lexRef, 152 152 + lexRefUnion, 153 153 + // other 154 154 + lexBlob, 155 155 + ]), 156 156 + minLength: z.number().int().optional(), 157 157 + maxLength: z.number().int().optional(), 158 158 + }); 159 159 + export type LexArray = z.infer<typeof lexArray>; 160 160 + 161 161 + export const lexPrimitiveArray = z.object({ 162 162 + ...lexArray.shape, 163 163 + items: lexPrimitive, 164 164 + }); 165 165 + 166 166 + export type LexPrimitiveArray = z.infer<typeof lexPrimitiveArray>; 167 167 + 168 168 + export const lexToken = z.object({ 169 169 + type: z.literal("token"), 170 170 + description: z.string().optional(), 171 171 + }); 172 172 + export type LexToken = z.infer<typeof lexToken>; 173 173 + 174 174 + export const lexObject = z 175 175 + .object({ 176 176 + type: z.literal("object"), 177 177 + description: z.string().optional(), 178 178 + required: z.string().array().optional(), 179 179 + nullable: z.string().array().optional(), 180 180 + properties: z.record( 181 181 + z.string(), 182 182 + z.discriminatedUnion("type", [ 183 183 + lexArray, 184 184 + 185 185 + // lexPrimitive 186 186 + lexBoolean, 187 187 + lexInteger, 188 188 + lexString, 189 189 + lexUnknown, 190 190 + // lexIpldType 191 191 + lexBytes, 192 192 + lexCidLink, 193 193 + // lexRefVariant 194 194 + lexRef, 195 195 + lexRefUnion, 196 196 + // other 197 197 + lexBlob, 198 198 + ]), 199 199 + ), 200 200 + }) 201 201 + .superRefine(requiredPropertiesRefinement); 202 202 + export type LexObject = z.infer<typeof lexObject>; 203 203 + 204 204 + // permissions 205 205 + // = 206 206 + 207 207 + const lexPermission = z.intersection( 208 208 + z.object({ 209 209 + type: z.literal("permission"), 210 210 + resource: z.string().min(1), 211 211 + }), 212 212 + z.record( 213 213 + z.string(), 214 214 + z 215 215 + .union([ 216 216 + z.array(z.union([z.string(), z.number().int(), z.boolean()])), 217 217 + 218 218 + z.boolean(), 219 219 + z.number().int(), 220 220 + z.string(), 221 221 + ]) 222 222 + .optional(), 223 223 + ), 224 224 + ); 225 225 + 226 226 + export type LexPermission = z.infer<typeof lexPermission>; 227 227 + 228 228 + export const lexPermissionSet = z.object({ 229 229 + type: z.literal("permission-set"), 230 230 + description: z.string().optional(), 231 231 + title: z.string().optional(), 232 232 + "title:lang": lexLang.optional(), 233 233 + detail: z.string().optional(), 234 234 + "detail:lang": lexLang.optional(), 235 235 + permissions: z.array(lexPermission), 236 236 + }); 237 237 + 238 238 + export type LexPermissionSet = z.infer<typeof lexPermissionSet>; 239 239 + 240 240 + // xrpc 241 241 + // = 242 242 + 243 243 + export const lexXrpcParameters = z 244 244 + .object({ 245 245 + type: z.literal("params"), 246 246 + description: z.string().optional(), 247 247 + required: z.string().array().optional(), 248 248 + properties: z.record( 249 249 + z.string(), 250 250 + z.discriminatedUnion("type", [ 251 251 + lexPrimitiveArray, 252 252 + 253 253 + // lexPrimitive 254 254 + lexBoolean, 255 255 + lexInteger, 256 256 + lexString, 257 257 + lexUnknown, 258 258 + ]), 259 259 + ), 260 260 + }) 261 261 + .superRefine(requiredPropertiesRefinement); 262 262 + export type LexXrpcParameters = z.infer<typeof lexXrpcParameters>; 263 263 + 264 264 + export const lexXrpcBody = z.object({ 265 265 + description: z.string().optional(), 266 266 + encoding: z.string(), 267 267 + // @NOTE using discriminatedUnion with a refined schema requires zod >= 4 268 268 + schema: z.union([lexRefVariant, lexObject]).optional(), 269 269 + }); 270 270 + export type LexXrpcBody = z.infer<typeof lexXrpcBody>; 271 271 + 272 272 + export const lexXrpcSubscriptionMessage = z.object({ 273 273 + description: z.string().optional(), 274 274 + // @NOTE using discriminatedUnion with a refined schema requires zod >= 4 275 275 + schema: z.union([lexRefVariant, lexObject]).optional(), 276 276 + }); 277 277 + export type LexXrpcSubscriptionMessage = z.infer< 278 278 + typeof lexXrpcSubscriptionMessage 279 279 + >; 280 280 + 281 281 + export const lexXrpcError = z.object({ 282 282 + name: z.string(), 283 283 + description: z.string().optional(), 284 284 + }); 285 285 + export type LexXrpcError = z.infer<typeof lexXrpcError>; 286 286 + 287 287 + export const lexXrpcQuery = z.object({ 288 288 + type: z.literal("query"), 289 289 + description: z.string().optional(), 290 290 + parameters: lexXrpcParameters.optional(), 291 291 + output: lexXrpcBody.optional(), 292 292 + errors: lexXrpcError.array().optional(), 293 293 + }); 294 294 + export type LexXrpcQuery = z.infer<typeof lexXrpcQuery>; 295 295 + 296 296 + export const lexXrpcProcedure = z.object({ 297 297 + type: z.literal("procedure"), 298 298 + description: z.string().optional(), 299 299 + parameters: lexXrpcParameters.optional(), 300 300 + input: lexXrpcBody.optional(), 301 301 + output: lexXrpcBody.optional(), 302 302 + errors: lexXrpcError.array().optional(), 303 303 + }); 304 304 + export type LexXrpcProcedure = z.infer<typeof lexXrpcProcedure>; 305 305 + 306 306 + export const lexXrpcSubscription = z.object({ 307 307 + type: z.literal("subscription"), 308 308 + description: z.string().optional(), 309 309 + parameters: lexXrpcParameters.optional(), 310 310 + message: lexXrpcSubscriptionMessage.optional(), 311 311 + errors: lexXrpcError.array().optional(), 312 312 + }); 313 313 + export type LexXrpcSubscription = z.infer<typeof lexXrpcSubscription>; 314 314 + 315 315 + // database 316 316 + // = 317 317 + 318 318 + export const lexRecord = z.object({ 319 319 + type: z.literal("record"), 320 320 + description: z.string().optional(), 321 321 + key: z.string().optional(), 322 322 + record: lexObject, 323 323 + }); 324 324 + export type LexRecord = z.infer<typeof lexRecord>; 325 325 + 326 326 + // core 327 327 + // = 328 328 + 329 329 + // We need to use `z.custom` here because 330 330 + // lexXrpcProperty and lexObject are refined 331 331 + // `z.union` would work, but it's too slow 332 332 + // see #915 for details 333 333 + export const lexUserType = z.custom< 334 334 + | LexRecord 335 335 + | LexPermissionSet 336 336 + | LexXrpcQuery 337 337 + | LexXrpcProcedure 338 338 + | LexXrpcSubscription 339 339 + | LexBlob 340 340 + | LexArray 341 341 + | LexToken 342 342 + | LexObject 343 343 + | LexBoolean 344 344 + | LexInteger 345 345 + | LexString 346 346 + | LexBytes 347 347 + | LexCidLink 348 348 + | LexUnknown 349 349 + >( 350 350 + (val) => { 351 351 + if (!val || typeof val !== "object") { 352 352 + return false; 353 353 + } 354 354 + 355 355 + const obj = val as Record<string, unknown>; 356 356 + 357 357 + if (obj["type"] === undefined) { 358 358 + return false; 359 359 + } 360 360 + 361 361 + try { 362 362 + switch (obj["type"]) { 363 363 + case "record": 364 364 + lexRecord.parse(val); 365 365 + return true; 366 366 + 367 367 + case "permission-set": 368 368 + lexPermissionSet.parse(val); 369 369 + return true; 370 370 + 371 371 + case "query": 372 372 + lexXrpcQuery.parse(val); 373 373 + return true; 374 374 + case "procedure": 375 375 + lexXrpcProcedure.parse(val); 376 376 + return true; 377 377 + case "subscription": 378 378 + lexXrpcSubscription.parse(val); 379 379 + return true; 380 380 + 381 381 + case "blob": 382 382 + lexBlob.parse(val); 383 383 + return true; 384 384 + 385 385 + case "array": 386 386 + lexArray.parse(val); 387 387 + return true; 388 388 + case "token": 389 389 + lexToken.parse(val); 390 390 + return true; 391 391 + case "object": 392 392 + lexObject.parse(val); 393 393 + return true; 394 394 + 395 395 + case "boolean": 396 396 + lexBoolean.parse(val); 397 397 + return true; 398 398 + case "integer": 399 399 + lexInteger.parse(val); 400 400 + return true; 401 401 + case "string": 402 402 + lexString.parse(val); 403 403 + return true; 404 404 + case "bytes": 405 405 + lexBytes.parse(val); 406 406 + return true; 407 407 + case "cid-link": 408 408 + lexCidLink.parse(val); 409 409 + return true; 410 410 + case "unknown": 411 411 + lexUnknown.parse(val); 412 412 + return true; 413 413 + 414 414 + default: 415 415 + return false; 416 416 + } 417 417 + } catch { 418 418 + return false; 419 419 + } 420 420 + }, 421 421 + { 422 422 + error: (val) => { 423 423 + if (!val || typeof val !== "object") { 424 424 + return "Must be an object"; 425 425 + } 426 426 + 427 427 + if (val["type"] === undefined) { 428 428 + return "Must have a type"; 429 429 + } 430 430 + 431 431 + if (typeof val["type"] !== "string") { 432 432 + return "Type property must be a string"; 433 433 + } 434 434 + 435 435 + return `Invalid type: ${ 436 436 + val["type"] 437 437 + } must be one of: record, query, procedure, subscription, blob, array, token, object, boolean, integer, string, bytes, cid-link, unknown`; 438 438 + }, 439 439 + }, 440 440 + ); 441 441 + export type LexUserType = z.infer<typeof lexUserType>; 442 442 + 443 443 + export const lexiconDoc = z 444 444 + .object({ 445 445 + lexicon: z.literal(1), 446 446 + id: z.string().refine(isValidNsid, { 447 447 + message: "Must be a valid NSID", 448 448 + }), 449 449 + revision: z.number().optional(), 450 450 + description: z.string().optional(), 451 451 + defs: z.record(z.string(), lexUserType), 452 452 + }) 453 453 + .refine( 454 454 + (doc) => { 455 455 + for (const [defId, def] of Object.entries(doc.defs)) { 456 456 + if ( 457 457 + defId !== "main" && 458 458 + (def.type === "record" || 459 459 + def.type === "permission-set" || 460 460 + def.type === "procedure" || 461 461 + def.type === "query" || 462 462 + def.type === "subscription") 463 463 + ) { 464 464 + return false; 465 465 + } 466 466 + } 467 467 + return true; 468 468 + }, 469 469 + { 470 470 + message: 471 471 + `Records, permission sets, procedures, queries, and subscriptions must be the main definition.`, 472 472 + }, 473 473 + ); 474 474 + export type LexiconDoc = z.infer<typeof lexiconDoc>; 475 475 + 476 476 + // helpers 477 477 + // = 478 478 + 479 479 + export function isValidLexiconDoc(v: unknown): v is LexiconDoc { 480 480 + return lexiconDoc.safeParse(v).success; 481 481 + } 482 482 + 483 483 + export function isObj<V>(v: V): v is V & object { 484 484 + return v != null && typeof v === "object"; 485 485 + } 486 486 + 487 487 + export type DiscriminatedObject = { $type: string }; 488 488 + export function isDiscriminatedObject(v: unknown): v is DiscriminatedObject { 489 489 + return isObj(v) && "$type" in v && typeof v.$type === "string"; 490 490 + } 491 491 + 492 492 + export function parseLexiconDoc(v: unknown): LexiconDoc { 493 493 + lexiconDoc.parse(v); 494 494 + return v as LexiconDoc; 495 495 + } 496 496 + 497 497 + export type ValidationResult<V = unknown> = 498 498 + | { 499 499 + success: true; 500 500 + value: V; 501 501 + } 502 502 + | { 503 503 + success: false; 504 504 + error: ValidationError; 505 505 + }; 506 506 + 507 507 + export class ValidationError extends Error {} 508 508 + export class InvalidLexiconError extends Error {} 509 509 + export class LexiconDefNotFoundError extends Error {}

+58

lexicon/util.ts

reviewed

··· 1 1 + import { z } from "zod"; 2 2 + 3 3 + export function toLexUri(str: string, baseUri?: string): string { 4 4 + if (str.split("#").length > 2) { 5 5 + throw new Error("Uri can only have one hash segment"); 6 6 + } 7 7 + 8 8 + if (str.startsWith("lex:")) { 9 9 + return str; 10 10 + } 11 11 + if (str.startsWith("#")) { 12 12 + if (!baseUri) { 13 13 + throw new Error(`Unable to resolve uri without anchor: ${str}`); 14 14 + } 15 15 + return `${baseUri}${str}`; 16 16 + } 17 17 + return `lex:${str}`; 18 18 + } 19 19 + 20 20 + export function requiredPropertiesRefinement< 21 21 + ObjectType extends { 22 22 + required?: string[]; 23 23 + properties?: Record<string, unknown>; 24 24 + }, 25 25 + >(object: ObjectType, ctx: z.RefinementCtx) { 26 26 + // Required fields check 27 27 + if (object.required === undefined) { 28 28 + return; 29 29 + } 30 30 + 31 31 + if (!Array.isArray(object.required)) { 32 32 + ctx.addIssue({ 33 33 + code: z.ZodIssueCode.invalid_type, 34 34 + received: typeof object.required, 35 35 + expected: "array", 36 36 + }); 37 37 + return; 38 38 + } 39 39 + 40 40 + if (object.properties === undefined) { 41 41 + if (object.required.length > 0) { 42 42 + ctx.addIssue({ 43 43 + code: z.ZodIssueCode.custom, 44 44 + message: `Required fields defined but no properties defined`, 45 45 + }); 46 46 + } 47 47 + return; 48 48 + } 49 49 + 50 50 + for (const field of object.required) { 51 51 + if (object.properties[field] === undefined) { 52 52 + ctx.addIssue({ 53 53 + code: z.ZodIssueCode.custom, 54 54 + message: `Required field "${field}" not defined`, 55 55 + }); 56 56 + } 57 57 + } 58 58 + }

+16

lexicon/validation/blob.ts

reviewed

··· 1 1 + import { BlobRef } from "../blob-refs.ts"; 2 2 + import { ValidationError, type ValidationResult } from "../types.ts"; 3 3 + 4 4 + export function blob( 5 5 + path: string, 6 6 + value: unknown, 7 7 + ): ValidationResult { 8 8 + // check 9 9 + if (!value || !(value instanceof BlobRef)) { 10 10 + return { 11 11 + success: false, 12 12 + error: new ValidationError(`${path} should be a blob ref`), 13 13 + }; 14 14 + } 15 15 + return { success: true, value }; 16 16 + }

+212

lexicon/validation/complex.ts

reviewed

··· 1 1 + import type { Lexicons } from "../lexicons.ts"; 2 2 + import { 3 3 + isDiscriminatedObject, 4 4 + isObj, 5 5 + type LexArray, 6 6 + type LexRefVariant, 7 7 + type LexUserType, 8 8 + ValidationError, 9 9 + type ValidationResult, 10 10 + } from "../types.ts"; 11 11 + import { toLexUri } from "../util.ts"; 12 12 + import { blob } from "./blob.ts"; 13 13 + import { validate as validatePrimitive } from "./primitives.ts"; 14 14 + 15 15 + export function validate( 16 16 + lexicons: Lexicons, 17 17 + path: string, 18 18 + def: LexUserType, 19 19 + value: unknown, 20 20 + ): ValidationResult { 21 21 + switch (def.type) { 22 22 + case "object": 23 23 + return object(lexicons, path, def, value); 24 24 + case "array": 25 25 + return array(lexicons, path, def, value); 26 26 + case "blob": 27 27 + return blob(path, value); 28 28 + default: 29 29 + return validatePrimitive(path, def, value); 30 30 + } 31 31 + } 32 32 + 33 33 + export function array( 34 34 + lexicons: Lexicons, 35 35 + path: string, 36 36 + def: LexArray, 37 37 + value: unknown, 38 38 + ): ValidationResult { 39 39 + // type 40 40 + if (!Array.isArray(value)) { 41 41 + return { 42 42 + success: false, 43 43 + error: new ValidationError(`${path} must be an array`), 44 44 + }; 45 45 + } 46 46 + 47 47 + // maxLength 48 48 + if (typeof def.maxLength === "number") { 49 49 + if ((value as Array<unknown>).length > def.maxLength) { 50 50 + return { 51 51 + success: false, 52 52 + error: new ValidationError( 53 53 + `${path} must not have more than ${def.maxLength} elements`, 54 54 + ), 55 55 + }; 56 56 + } 57 57 + } 58 58 + 59 59 + // minLength 60 60 + if (typeof def.minLength === "number") { 61 61 + if ((value as Array<unknown>).length < def.minLength) { 62 62 + return { 63 63 + success: false, 64 64 + error: new ValidationError( 65 65 + `${path} must not have fewer than ${def.minLength} elements`, 66 66 + ), 67 67 + }; 68 68 + } 69 69 + } 70 70 + 71 71 + // items 72 72 + const itemsDef = def.items; 73 73 + for (let i = 0; i < (value as Array<unknown>).length; i++) { 74 74 + const itemValue = value[i]; 75 75 + const itemPath = `${path}/${i}`; 76 76 + const res = validateOneOf(lexicons, itemPath, itemsDef, itemValue); 77 77 + if (!res.success) { 78 78 + return res; 79 79 + } 80 80 + } 81 81 + 82 82 + return { success: true, value }; 83 83 + } 84 84 + 85 85 + export function object( 86 86 + lexicons: Lexicons, 87 87 + path: string, 88 88 + def: LexUserType, 89 89 + value: unknown, 90 90 + ): ValidationResult { 91 91 + // type 92 92 + if (!isObj(value)) { 93 93 + return { 94 94 + success: false, 95 95 + error: new ValidationError(`${path} must be an object`), 96 96 + }; 97 97 + } 98 98 + 99 99 + // properties 100 100 + let resultValue = value as Record<string, unknown>; 101 101 + if ("properties" in def && def.properties != null) { 102 102 + for (const key in def.properties) { 103 103 + const keyValue = resultValue[key]; 104 104 + if (keyValue === null && def.nullable?.includes(key)) { 105 105 + continue; 106 106 + } 107 107 + const propDef = def.properties[key]; 108 108 + if (keyValue === undefined && !def.required?.includes(key)) { 109 109 + // Fast path for non-required undefined props. 110 110 + if ( 111 111 + propDef.type === "integer" || 112 112 + propDef.type === "boolean" || 113 113 + propDef.type === "string" 114 114 + ) { 115 115 + if (propDef.default === undefined) { 116 116 + continue; 117 117 + } 118 118 + } else { 119 119 + // Other types have no defaults. 120 120 + continue; 121 121 + } 122 122 + } 123 123 + const propPath = `${path}/${key}`; 124 124 + const validated = validateOneOf(lexicons, propPath, propDef, keyValue); 125 125 + const propValue = validated.success ? validated.value : keyValue; 126 126 + 127 127 + // Return error for bad validation, giving required rule precedence 128 128 + if (propValue === undefined) { 129 129 + if (def.required?.includes(key)) { 130 130 + return { 131 131 + success: false, 132 132 + error: new ValidationError( 133 133 + `${path} must have the property "${key}"`, 134 134 + ), 135 135 + }; 136 136 + } 137 137 + } else { 138 138 + if (!validated.success) { 139 139 + return validated; 140 140 + } 141 141 + } 142 142 + 143 143 + // Adjust value based on e.g. applied defaults, cloning shallowly if there was a changed value 144 144 + if (propValue !== keyValue) { 145 145 + if (resultValue === value) { 146 146 + // Lazy shallow clone 147 147 + resultValue = { ...value }; 148 148 + } 149 149 + resultValue[key] = propValue; 150 150 + } 151 151 + } 152 152 + } 153 153 + 154 154 + return { success: true, value: resultValue }; 155 155 + } 156 156 + 157 157 + export function validateOneOf( 158 158 + lexicons: Lexicons, 159 159 + path: string, 160 160 + def: LexRefVariant | LexUserType, 161 161 + value: unknown, 162 162 + mustBeObj = false, // this is the only type constraint we need currently (used by xrpc body schema validators) 163 163 + ): ValidationResult { 164 164 + let concreteDef: LexUserType; 165 165 + 166 166 + if (def.type === "union") { 167 167 + if (!isDiscriminatedObject(value)) { 168 168 + return { 169 169 + success: false, 170 170 + error: new ValidationError( 171 171 + `${path} must be an object which includes the "$type" property`, 172 172 + ), 173 173 + }; 174 174 + } 175 175 + if (!refsContainType(def.refs, value.$type)) { 176 176 + if (def.closed) { 177 177 + return { 178 178 + success: false, 179 179 + error: new ValidationError( 180 180 + `${path} $type must be one of ${def.refs.join(", ")}`, 181 181 + ), 182 182 + }; 183 183 + } 184 184 + return { success: true, value }; 185 185 + } else { 186 186 + concreteDef = lexicons.getDefOrThrow(value.$type); 187 187 + } 188 188 + } else if (def.type === "ref") { 189 189 + concreteDef = lexicons.getDefOrThrow(def.ref); 190 190 + } else { 191 191 + concreteDef = def; 192 192 + } 193 193 + 194 194 + return mustBeObj 195 195 + ? object(lexicons, path, concreteDef, value) 196 196 + : validate(lexicons, path, concreteDef, value); 197 197 + } 198 198 + 199 199 + // to avoid bugs like #0189 this needs to handle both 200 200 + // explicit and implicit #main 201 201 + const refsContainType = (refs: string[], type: string) => { 202 202 + const lexUri = toLexUri(type); 203 203 + if (refs.includes(lexUri)) { 204 204 + return true; 205 205 + } 206 206 + 207 207 + if (lexUri.endsWith("#main")) { 208 208 + return refs.includes(lexUri.slice(0, -5)); 209 209 + } else { 210 210 + return !lexUri.includes("#") && refs.includes(`${lexUri}#main`); 211 211 + } 212 212 + };

+155

lexicon/validation/formats.ts

reviewed

··· 1 1 + import { CID } from "multiformats/cid"; 2 2 + import { isValidISODateString, validateLanguage } from "@atp/common"; 3 3 + import { 4 4 + ensureValidAtUri, 5 5 + ensureValidDid, 6 6 + ensureValidHandle, 7 7 + ensureValidRecordKey, 8 8 + isValidNsid, 9 9 + isValidTid, 10 10 + } from "@atp/syntax"; 11 11 + import { ValidationError, type ValidationResult } from "../types.ts"; 12 12 + 13 13 + export function datetime(path: string, value: string): ValidationResult { 14 14 + try { 15 15 + if (!isValidISODateString(value)) { 16 16 + throw new Error(); 17 17 + } 18 18 + } catch { 19 19 + return { 20 20 + success: false, 21 21 + error: new ValidationError( 22 22 + `${path} must be an valid atproto datetime (both RFC-3339 and ISO-8601)`, 23 23 + ), 24 24 + }; 25 25 + } 26 26 + return { success: true, value }; 27 27 + } 28 28 + 29 29 + export function uri(path: string, value: string): ValidationResult { 30 30 + const isUri = value.match(/^\w+:(?:\/\/)?[^\s/][^\s]*$/) !== null; 31 31 + if (!isUri) { 32 32 + return { 33 33 + success: false, 34 34 + error: new ValidationError(`${path} must be a uri`), 35 35 + }; 36 36 + } 37 37 + return { success: true, value }; 38 38 + } 39 39 + 40 40 + export function atUri(path: string, value: string): ValidationResult { 41 41 + try { 42 42 + ensureValidAtUri(value); 43 43 + } catch { 44 44 + return { 45 45 + success: false, 46 46 + error: new ValidationError(`${path} must be a valid at-uri`), 47 47 + }; 48 48 + } 49 49 + 50 50 + return { success: true, value }; 51 51 + } 52 52 + 53 53 + export function did(path: string, value: string): ValidationResult { 54 54 + try { 55 55 + ensureValidDid(value); 56 56 + } catch { 57 57 + return { 58 58 + success: false, 59 59 + error: new ValidationError(`${path} must be a valid did`), 60 60 + }; 61 61 + } 62 62 + 63 63 + return { success: true, value }; 64 64 + } 65 65 + 66 66 + export function handle(path: string, value: string): ValidationResult { 67 67 + try { 68 68 + ensureValidHandle(value); 69 69 + } catch { 70 70 + return { 71 71 + success: false, 72 72 + error: new ValidationError(`${path} must be a valid handle`), 73 73 + }; 74 74 + } 75 75 + 76 76 + return { success: true, value }; 77 77 + } 78 78 + 79 79 + export function atIdentifier(path: string, value: string): ValidationResult { 80 80 + // We can discriminate based on the "did:" prefix 81 81 + if (value.startsWith("did:")) { 82 82 + const didResult = did(path, value); 83 83 + if (didResult.success) return didResult; 84 84 + } else { 85 85 + const handleResult = handle(path, value); 86 86 + if (handleResult.success) return handleResult; 87 87 + } 88 88 + 89 89 + return { 90 90 + success: false, 91 91 + error: new ValidationError(`${path} must be a valid did or a handle`), 92 92 + }; 93 93 + } 94 94 + 95 95 + export function nsid(path: string, value: string): ValidationResult { 96 96 + if (isValidNsid(value)) { 97 97 + return { 98 98 + success: true, 99 99 + value, 100 100 + }; 101 101 + } else { 102 102 + return { 103 103 + success: false, 104 104 + error: new ValidationError(`${path} must be a valid nsid`), 105 105 + }; 106 106 + } 107 107 + } 108 108 + 109 109 + export function cid(path: string, value: string): ValidationResult { 110 110 + try { 111 111 + CID.parse(value); 112 112 + } catch { 113 113 + return { 114 114 + success: false, 115 115 + error: new ValidationError(`${path} must be a cid string`), 116 116 + }; 117 117 + } 118 118 + return { success: true, value }; 119 119 + } 120 120 + 121 121 + // The language format validates well-formed BCP 47 language tags: https://www.rfc-editor.org/info/bcp47 122 122 + export function language(path: string, value: string): ValidationResult { 123 123 + if (validateLanguage(value)) { 124 124 + return { success: true, value }; 125 125 + } 126 126 + return { 127 127 + success: false, 128 128 + error: new ValidationError( 129 129 + `${path} must be a well-formed BCP 47 language tag`, 130 130 + ), 131 131 + }; 132 132 + } 133 133 + 134 134 + export function tid(path: string, value: string): ValidationResult { 135 135 + if (isValidTid(value)) { 136 136 + return { success: true, value }; 137 137 + } 138 138 + 139 139 + return { 140 140 + success: false, 141 141 + error: new ValidationError(`${path} must be a valid TID`), 142 142 + }; 143 143 + } 144 144 + 145 145 + export function recordKey(path: string, value: string): ValidationResult { 146 146 + try { 147 147 + ensureValidRecordKey(value); 148 148 + } catch { 149 149 + return { 150 150 + success: false, 151 151 + error: new ValidationError(`${path} must be a valid Record Key`), 152 152 + }; 153 153 + } 154 154 + return { success: true, value }; 155 155 + }

+84

lexicon/validation/index.ts

reviewed

··· 1 1 + import type { Lexicons } from "../lexicons.ts"; 2 2 + import type { 3 3 + LexRecord, 4 4 + LexRefVariant, 5 5 + LexUserType, 6 6 + LexXrpcProcedure, 7 7 + LexXrpcQuery, 8 8 + LexXrpcSubscription, 9 9 + } from "../types.ts"; 10 10 + import { object, validateOneOf } from "./complex.ts"; 11 11 + import { params } from "./xrpc.ts"; 12 12 + 13 13 + export function assertValidRecord( 14 14 + lexicons: Lexicons, 15 15 + def: LexRecord, 16 16 + value: unknown, 17 17 + ) { 18 18 + const res = object(lexicons, "Record", def.record, value); 19 19 + if (!res.success) throw res.error; 20 20 + return res.value; 21 21 + } 22 22 + 23 23 + export function assertValidXrpcParams( 24 24 + lexicons: Lexicons, 25 25 + def: LexXrpcProcedure | LexXrpcQuery | LexXrpcSubscription, 26 26 + value: unknown, 27 27 + ) { 28 28 + if (def.parameters) { 29 29 + const res = params(lexicons, "Params", def.parameters, value); 30 30 + if (!res.success) throw res.error; 31 31 + return res.value; 32 32 + } 33 33 + } 34 34 + 35 35 + export function assertValidXrpcInput( 36 36 + lexicons: Lexicons, 37 37 + def: LexXrpcProcedure, 38 38 + value: unknown, 39 39 + ) { 40 40 + if (def.input?.schema) { 41 41 + // loop: all input schema definitions 42 42 + return assertValidOneOf(lexicons, "Input", def.input.schema, value, true); 43 43 + } 44 44 + } 45 45 + 46 46 + export function assertValidXrpcOutput( 47 47 + lexicons: Lexicons, 48 48 + def: LexXrpcProcedure | LexXrpcQuery, 49 49 + value: unknown, 50 50 + ) { 51 51 + if (def.output?.schema) { 52 52 + // loop: all output schema definitions 53 53 + return assertValidOneOf(lexicons, "Output", def.output.schema, value, true); 54 54 + } 55 55 + } 56 56 + 57 57 + export function assertValidXrpcMessage( 58 58 + lexicons: Lexicons, 59 59 + def: LexXrpcSubscription, 60 60 + value: unknown, 61 61 + ) { 62 62 + if (def.message?.schema) { 63 63 + // loop: all output schema definitions 64 64 + return assertValidOneOf( 65 65 + lexicons, 66 66 + "Message", 67 67 + def.message.schema, 68 68 + value, 69 69 + true, 70 70 + ); 71 71 + } 72 72 + } 73 73 + 74 74 + function assertValidOneOf( 75 75 + lexicons: Lexicons, 76 76 + path: string, 77 77 + def: LexRefVariant | LexUserType, 78 78 + value: unknown, 79 79 + mustBeObj = false, 80 80 + ) { 81 81 + const res = validateOneOf(lexicons, path, def, value, mustBeObj); 82 82 + if (!res.success) throw res.error; 83 83 + return res.value; 84 84 + }

+406

lexicon/validation/primitives.ts

reviewed

··· 1 1 + import { CID } from "multiformats/cid"; 2 2 + import { graphemeLen, utf8Len } from "@atp/common"; 3 3 + import { 4 4 + type LexBoolean, 5 5 + type LexBytes, 6 6 + type LexInteger, 7 7 + type LexString, 8 8 + type LexUserType, 9 9 + ValidationError, 10 10 + type ValidationResult, 11 11 + } from "../types.ts"; 12 12 + import * as formats from "./formats.ts"; 13 13 + 14 14 + export function validate( 15 15 + path: string, 16 16 + def: LexUserType, 17 17 + value: unknown, 18 18 + ): ValidationResult { 19 19 + switch (def.type) { 20 20 + case "boolean": 21 21 + return boolean(path, def, value); 22 22 + case "integer": 23 23 + return integer(path, def, value); 24 24 + case "string": 25 25 + return string(path, def, value); 26 26 + case "bytes": 27 27 + return bytes(path, def, value); 28 28 + case "cid-link": 29 29 + return cidLink(path, value); 30 30 + case "unknown": 31 31 + return unknown(path, value); 32 32 + default: 33 33 + return { 34 34 + success: false, 35 35 + error: new ValidationError(`Unexpected lexicon type: ${def.type}`), 36 36 + }; 37 37 + } 38 38 + } 39 39 + 40 40 + function boolean( 41 41 + path: string, 42 42 + def: LexUserType, 43 43 + value: unknown, 44 44 + ): ValidationResult { 45 45 + def = def as LexBoolean; 46 46 + 47 47 + // type 48 48 + const type = typeof value; 49 49 + if (type === "undefined") { 50 50 + if (typeof def.default === "boolean") { 51 51 + return { success: true, value: def.default }; 52 52 + } 53 53 + return { 54 54 + success: false, 55 55 + error: new ValidationError(`${path} must be a boolean`), 56 56 + }; 57 57 + } else if (type !== "boolean") { 58 58 + return { 59 59 + success: false, 60 60 + error: new ValidationError(`${path} must be a boolean`), 61 61 + }; 62 62 + } 63 63 + 64 64 + // const 65 65 + if (typeof def.const === "boolean") { 66 66 + if (value !== def.const) { 67 67 + return { 68 68 + success: false, 69 69 + error: new ValidationError(`${path} must be ${def.const}`), 70 70 + }; 71 71 + } 72 72 + } 73 73 + 74 74 + return { success: true, value }; 75 75 + } 76 76 + 77 77 + function integer( 78 78 + path: string, 79 79 + def: LexUserType, 80 80 + value: unknown, 81 81 + ): ValidationResult { 82 82 + def = def as LexInteger; 83 83 + 84 84 + // type 85 85 + const type = typeof value; 86 86 + if (type === "undefined") { 87 87 + if (typeof def.default === "number") { 88 88 + return { success: true, value: def.default }; 89 89 + } 90 90 + return { 91 91 + success: false, 92 92 + error: new ValidationError(`${path} must be an integer`), 93 93 + }; 94 94 + } else if (!Number.isInteger(value)) { 95 95 + return { 96 96 + success: false, 97 97 + error: new ValidationError(`${path} must be an integer`), 98 98 + }; 99 99 + } 100 100 + 101 101 + // const 102 102 + if (typeof def.const === "number") { 103 103 + if (value !== def.const) { 104 104 + return { 105 105 + success: false, 106 106 + error: new ValidationError(`${path} must be ${def.const}`), 107 107 + }; 108 108 + } 109 109 + } 110 110 + 111 111 + // enum 112 112 + if (Array.isArray(def.enum)) { 113 113 + if (!def.enum.includes(value as number)) { 114 114 + return { 115 115 + success: false, 116 116 + error: new ValidationError( 117 117 + `${path} must be one of (${def.enum.join("|")})`, 118 118 + ), 119 119 + }; 120 120 + } 121 121 + } 122 122 + 123 123 + // maximum 124 124 + if (typeof def.maximum === "number") { 125 125 + if ((value as number) > def.maximum) { 126 126 + return { 127 127 + success: false, 128 128 + error: new ValidationError( 129 129 + `${path} can not be greater than ${def.maximum}`, 130 130 + ), 131 131 + }; 132 132 + } 133 133 + } 134 134 + 135 135 + // minimum 136 136 + if (typeof def.minimum === "number") { 137 137 + if ((value as number) < def.minimum) { 138 138 + return { 139 139 + success: false, 140 140 + error: new ValidationError( 141 141 + `${path} can not be less than ${def.minimum}`, 142 142 + ), 143 143 + }; 144 144 + } 145 145 + } 146 146 + 147 147 + return { success: true, value }; 148 148 + } 149 149 + 150 150 + function string( 151 151 + path: string, 152 152 + def: LexUserType, 153 153 + value: unknown, 154 154 + ): ValidationResult { 155 155 + def = def as LexString; 156 156 + 157 157 + // type 158 158 + if (typeof value === "undefined") { 159 159 + if (typeof def.default === "string") { 160 160 + return { success: true, value: def.default }; 161 161 + } 162 162 + return { 163 163 + success: false, 164 164 + error: new ValidationError(`${path} must be a string`), 165 165 + }; 166 166 + } else if (typeof value !== "string") { 167 167 + return { 168 168 + success: false, 169 169 + error: new ValidationError(`${path} must be a string`), 170 170 + }; 171 171 + } 172 172 + 173 173 + // const 174 174 + if (typeof def.const === "string") { 175 175 + if (value !== def.const) { 176 176 + return { 177 177 + success: false, 178 178 + error: new ValidationError(`${path} must be ${def.const}`), 179 179 + }; 180 180 + } 181 181 + } 182 182 + 183 183 + // enum 184 184 + if (Array.isArray(def.enum)) { 185 185 + if (!def.enum.includes(value as string)) { 186 186 + return { 187 187 + success: false, 188 188 + error: new ValidationError( 189 189 + `${path} must be one of (${def.enum.join("|")})`, 190 190 + ), 191 191 + }; 192 192 + } 193 193 + } 194 194 + 195 195 + // maxLength and minLength 196 196 + if (typeof def.minLength === "number" || typeof def.maxLength === "number") { 197 197 + // If the JavaScript string length * 3 is below the maximum limit, 198 198 + // its UTF8 length (which <= .length * 3) will also be below. 199 199 + if (typeof def.minLength === "number" && value.length * 3 < def.minLength) { 200 200 + return { 201 201 + success: false, 202 202 + error: new ValidationError( 203 203 + `${path} must not be shorter than ${def.minLength} characters`, 204 204 + ), 205 205 + }; 206 206 + } 207 207 + 208 208 + // If the JavaScript string length * 3 is within the maximum limit, 209 209 + // its UTF8 length (which <= .length * 3) will also be within. 210 210 + // When there's no minimal length, this lets us skip the UTF8 length check. 211 211 + let canSkipUtf8LenChecks = false; 212 212 + if ( 213 213 + typeof def.minLength === "undefined" && 214 214 + typeof def.maxLength === "number" && 215 215 + value.length * 3 <= def.maxLength 216 216 + ) { 217 217 + canSkipUtf8LenChecks = true; 218 218 + } 219 219 + 220 220 + if (!canSkipUtf8LenChecks) { 221 221 + const len = utf8Len(value); 222 222 + 223 223 + if (typeof def.maxLength === "number") { 224 224 + if (len > def.maxLength) { 225 225 + return { 226 226 + success: false, 227 227 + error: new ValidationError( 228 228 + `${path} must not be longer than ${def.maxLength} characters`, 229 229 + ), 230 230 + }; 231 231 + } 232 232 + } 233 233 + 234 234 + if (typeof def.minLength === "number") { 235 235 + if (len < def.minLength) { 236 236 + return { 237 237 + success: false, 238 238 + error: new ValidationError( 239 239 + `${path} must not be shorter than ${def.minLength} characters`, 240 240 + ), 241 241 + }; 242 242 + } 243 243 + } 244 244 + } 245 245 + } 246 246 + 247 247 + // maxGraphemes and minGraphemes 248 248 + if ( 249 249 + typeof def.maxGraphemes === "number" || 250 250 + typeof def.minGraphemes === "number" 251 251 + ) { 252 252 + let needsMaxGraphemesCheck = false; 253 253 + let needsMinGraphemesCheck = false; 254 254 + 255 255 + if (typeof def.maxGraphemes === "number") { 256 256 + if (value.length <= def.maxGraphemes) { 257 257 + // If the JavaScript string length (UTF-16) is within the maximum limit, 258 258 + // its grapheme length (which <= .length) will also be within. 259 259 + needsMaxGraphemesCheck = false; 260 260 + } else { 261 261 + needsMaxGraphemesCheck = true; 262 262 + } 263 263 + } 264 264 + 265 265 + if (typeof def.minGraphemes === "number") { 266 266 + if (value.length < def.minGraphemes) { 267 267 + // If the JavaScript string length (UTF-16) is below the minimal limit, 268 268 + // its grapheme length (which <= .length) will also be below. 269 269 + // Fail early. 270 270 + return { 271 271 + success: false, 272 272 + error: new ValidationError( 273 273 + `${path} must not be shorter than ${def.minGraphemes} graphemes`, 274 274 + ), 275 275 + }; 276 276 + } else { 277 277 + needsMinGraphemesCheck = true; 278 278 + } 279 279 + } 280 280 + 281 281 + if (needsMaxGraphemesCheck || needsMinGraphemesCheck) { 282 282 + const len = graphemeLen(value); 283 283 + 284 284 + if (typeof def.maxGraphemes === "number") { 285 285 + if (len > def.maxGraphemes) { 286 286 + return { 287 287 + success: false, 288 288 + error: new ValidationError( 289 289 + `${path} must not be longer than ${def.maxGraphemes} graphemes`, 290 290 + ), 291 291 + }; 292 292 + } 293 293 + } 294 294 + 295 295 + if (typeof def.minGraphemes === "number") { 296 296 + if (len < def.minGraphemes) { 297 297 + return { 298 298 + success: false, 299 299 + error: new ValidationError( 300 300 + `${path} must not be shorter than ${def.minGraphemes} graphemes`, 301 301 + ), 302 302 + }; 303 303 + } 304 304 + } 305 305 + } 306 306 + } 307 307 + 308 308 + if (typeof def.format === "string") { 309 309 + switch (def.format) { 310 310 + case "datetime": 311 311 + return formats.datetime(path, value); 312 312 + case "uri": 313 313 + return formats.uri(path, value); 314 314 + case "at-uri": 315 315 + return formats.atUri(path, value); 316 316 + case "did": 317 317 + return formats.did(path, value); 318 318 + case "handle": 319 319 + return formats.handle(path, value); 320 320 + case "at-identifier": 321 321 + return formats.atIdentifier(path, value); 322 322 + case "nsid": 323 323 + return formats.nsid(path, value); 324 324 + case "cid": 325 325 + return formats.cid(path, value); 326 326 + case "language": 327 327 + return formats.language(path, value); 328 328 + case "tid": 329 329 + return formats.tid(path, value); 330 330 + case "record-key": 331 331 + return formats.recordKey(path, value); 332 332 + } 333 333 + } 334 334 + 335 335 + return { success: true, value }; 336 336 + } 337 337 + 338 338 + function bytes( 339 339 + path: string, 340 340 + def: LexUserType, 341 341 + value: unknown, 342 342 + ): ValidationResult { 343 343 + def = def as LexBytes; 344 344 + 345 345 + if (!value || !(value instanceof Uint8Array)) { 346 346 + return { 347 347 + success: false, 348 348 + error: new ValidationError(`${path} must be a byte array`), 349 349 + }; 350 350 + } 351 351 + 352 352 + // maxLength 353 353 + if (typeof def.maxLength === "number") { 354 354 + if (value.byteLength > def.maxLength) { 355 355 + return { 356 356 + success: false, 357 357 + error: new ValidationError( 358 358 + `${path} must not be larger than ${def.maxLength} bytes`, 359 359 + ), 360 360 + }; 361 361 + } 362 362 + } 363 363 + 364 364 + // minLength 365 365 + if (typeof def.minLength === "number") { 366 366 + if (value.byteLength < def.minLength) { 367 367 + return { 368 368 + success: false, 369 369 + error: new ValidationError( 370 370 + `${path} must not be smaller than ${def.minLength} bytes`, 371 371 + ), 372 372 + }; 373 373 + } 374 374 + } 375 375 + 376 376 + return { success: true, value }; 377 377 + } 378 378 + 379 379 + function cidLink( 380 380 + path: string, 381 381 + value: unknown, 382 382 + ): ValidationResult { 383 383 + if (CID.asCID(value) === null) { 384 384 + return { 385 385 + success: false, 386 386 + error: new ValidationError(`${path} must be a CID`), 387 387 + }; 388 388 + } 389 389 + 390 390 + return { success: true, value }; 391 391 + } 392 392 + 393 393 + function unknown( 394 394 + path: string, 395 395 + value: unknown, 396 396 + ): ValidationResult { 397 397 + // type 398 398 + if (!value || typeof value !== "object") { 399 399 + return { 400 400 + success: false, 401 401 + error: new ValidationError(`${path} must be an object`), 402 402 + }; 403 403 + } 404 404 + 405 405 + return { success: true, value }; 406 406 + }

+52

lexicon/validation/xrpc.ts

reviewed

··· 1 1 + import type { Lexicons } from "../lexicons.ts"; 2 2 + import { 3 3 + type LexXrpcParameters, 4 4 + ValidationError, 5 5 + type ValidationResult, 6 6 + } from "../types.ts"; 7 7 + import { array } from "./complex.ts"; 8 8 + import * as PrimitiveValidators from "./primitives.ts"; 9 9 + 10 10 + export function params( 11 11 + lexicons: Lexicons, 12 12 + path: string, 13 13 + def: LexXrpcParameters, 14 14 + val: unknown, 15 15 + ): ValidationResult<Record<string, unknown>> { 16 16 + // type 17 17 + const value = val && typeof val === "object" ? val : {}; 18 18 + 19 19 + const requiredProps = new Set(def.required ?? []); 20 20 + 21 21 + // properties 22 22 + let resultValue = value as Record<string, unknown>; 23 23 + if (typeof def.properties === "object") { 24 24 + for (const key in def.properties) { 25 25 + const propDef = def.properties[key]; 26 26 + const validated = propDef.type === "array" 27 27 + ? array(lexicons, key, propDef, resultValue[key]) 28 28 + : PrimitiveValidators.validate(key, propDef, resultValue[key]); 29 29 + const propValue = validated.success ? validated.value : resultValue[key]; 30 30 + const propIsUndefined = typeof propValue === "undefined"; 31 31 + // Return error for bad validation, giving required rule precedence 32 32 + if (propIsUndefined && requiredProps.has(key)) { 33 33 + return { 34 34 + success: false, 35 35 + error: new ValidationError(`${path} must have the property "${key}"`), 36 36 + }; 37 37 + } else if (!propIsUndefined && !validated.success) { 38 38 + return validated; 39 39 + } 40 40 + // Adjust value based on e.g. applied defaults, cloning shallowly if there was a changed value 41 41 + if (propValue !== resultValue[key]) { 42 42 + if (resultValue === value) { 43 43 + // Lazy shallow clone 44 44 + resultValue = { ...value }; 45 45 + } 46 46 + resultValue[key] = propValue; 47 47 + } 48 48 + } 49 49 + } 50 50 + 51 51 + return { success: true, value: resultValue }; 52 52 + }

-1

xrpc-server/deno.json

reviewed

··· 5 5 "license": "MIT", 6 6 "imports": { 7 7 "@atproto/crypto": "npm:@atproto/crypto@^0.4.4", 8 8 - "@atproto/lexicon": "npm:@atproto/lexicon@^0.4.11", 9 8 "@std/assert": "jsr:@std/assert@^1.0.14", 10 9 "@std/cbor": "jsr:@std/cbor@^0.1.8", 11 10 "@std/encoding": "jsr:@std/encoding@^1.0.10",

+1 -2

xrpc-server/lexicon/index.ts

reviewed

··· 1 1 import { Hono } from "hono"; 2 2 - import { Lexicons } from "@atproto/lexicon"; 2 2 + import { type LexiconDoc, Lexicons } from "@atp/lexicon"; 3 3 import type { Context, Next } from "hono"; 4 4 - import type { LexiconDoc } from "@atproto/lexicon"; 5 4 6 5 export function createServer(lexicons?: LexiconDoc[]) { 7 6 const routes = new Hono();

+1 -1

xrpc-server/mod.ts

reviewed

··· 22 22 * @example Basic server setup with a simple endpoint 23 23 * ```ts 24 24 * import { createServer } from "jsr:@atp/xrpc-server"; 25 25 - * import type { LexiconDoc } from "@atproto/lexicon"; 25 25 + * import type { LexiconDoc } from "@atp/lexicon"; 26 26 * 27 27 * const lexicons: LexiconDoc[] = [{ 28 28 * lexicon: 1,

+1 -1

xrpc-server/server.ts

reviewed

··· 6 6 type LexXrpcProcedure, 7 7 type LexXrpcQuery, 8 8 type LexXrpcSubscription, 9 9 - } from "@atproto/lexicon"; 9 9 + } from "@atp/lexicon"; 10 10 import { 11 11 excludeErrorResult, 12 12 InternalServerError,

+6 -6

xrpc-server/stream/types.ts

reviewed

··· 33 33 t?: string; 34 34 }; 35 35 36 36 - export const messageFrameHeader = z.object({ 36 36 + export const messageFrameHeader = z.strictObject({ 37 37 op: z.literal(FrameType.Message), // Frame op 38 38 t: z.string().optional(), // Message body type discriminator 39 39 - }).strict() as z.ZodType<MessageFrameHeader>; 39 39 + }) as z.ZodType<MessageFrameHeader>; 40 40 41 41 /** 42 42 * Header for error frames. ··· 47 47 op: FrameType.Error; 48 48 }; 49 49 50 50 - export const errorFrameHeader = z.object({ 50 50 + export const errorFrameHeader = z.strictObject({ 51 51 op: z.literal(FrameType.Error), 52 52 - }).strict() as z.ZodType<ErrorFrameHeader>; 52 52 + }) as z.ZodType<ErrorFrameHeader>; 53 53 54 54 /** 55 55 * Base type for error frame bodies. ··· 74 74 message?: string; 75 75 }; 76 76 77 77 - export const errorFrameBody = z.object({ 77 77 + export const errorFrameBody = z.strictObject({ 78 78 error: z.string(), // Error code 79 79 message: z.string().optional(), // Error message 80 80 - }).strict() as z.ZodType<ErrorFrameBodyBase>; 80 80 + }) as z.ZodType<ErrorFrameBodyBase>; 81 81 82 82 /** 83 83 * Union type for all frame headers.

+1 -1

xrpc-server/tests/auth_test.ts

reviewed

··· 1 1 import { MINUTE } from "@atp/common"; 2 2 import { Secp256k1Keypair } from "@atproto/crypto"; 3 3 - import type { LexiconDoc } from "@atproto/lexicon"; 3 3 + import type { LexiconDoc } from "@atp/lexicon"; 4 4 import { XrpcClient, XRPCError } from "@atp/xrpc"; 5 5 import * as xrpcServer from "../mod.ts"; 6 6

+1 -1

xrpc-server/tests/bodies_test.ts

reviewed

··· 1 1 import { cidForCbor } from "@atp/common"; 2 2 import { randomBytes } from "@atproto/crypto"; 3 3 - import type { LexiconDoc } from "@atproto/lexicon"; 3 3 + import type { LexiconDoc } from "@atp/lexicon"; 4 4 import { ResponseType, XrpcClient, XRPCError } from "@atp/xrpc"; 5 5 import * as xrpcServer from "../mod.ts"; 6 6 import { logger } from "../logger.ts";

+1 -1

xrpc-server/tests/errors_test.ts

reviewed

··· 1 1 - import type { LexiconDoc } from "@atproto/lexicon"; 1 1 + import type { LexiconDoc } from "@atp/lexicon"; 2 2 import { XrpcClient, XRPCError, XRPCInvalidResponseError } from "@atp/xrpc"; 3 3 import * as xrpcServer from "../mod.ts"; 4 4 import { closeServer, createServer } from "./_util.ts";

+1 -1

xrpc-server/tests/ipld_test.ts

reviewed

··· 1 1 import { CID } from "multiformats/cid"; 2 2 - import type { LexiconDoc } from "@atproto/lexicon"; 2 2 + import type { LexiconDoc } from "@atp/lexicon"; 3 3 import { XrpcClient } from "@atp/xrpc"; 4 4 import * as xrpcServer from "../mod.ts"; 5 5 import { closeServer, createServer } from "./_util.ts";

+1 -1

xrpc-server/tests/parameters_test.ts

reviewed

··· 1 1 - import type { LexiconDoc } from "@atproto/lexicon"; 1 1 + import type { LexiconDoc } from "@atp/lexicon"; 2 2 import { XrpcClient } from "@atp/xrpc"; 3 3 import * as xrpcServer from "../mod.ts"; 4 4 import { closeServer, createServer } from "./_util.ts";

+1 -1

xrpc-server/tests/procedures_test.ts

reviewed

··· 1 1 - import type { LexiconDoc } from "@atproto/lexicon"; 1 1 + import type { LexiconDoc } from "@atp/lexicon"; 2 2 import { XrpcClient } from "@atp/xrpc"; 3 3 import * as xrpcServer from "../mod.ts"; 4 4 import { closeServer, createServer } from "./_util.ts";

+1 -1

xrpc-server/tests/queries_test.ts

reviewed

··· 1 1 - import type { LexiconDoc } from "@atproto/lexicon"; 1 1 + import type { LexiconDoc } from "@atp/lexicon"; 2 2 import { XrpcClient } from "@atp/xrpc"; 3 3 import * as xrpcServer from "../mod.ts"; 4 4 import { closeServer, createServer } from "./_util.ts";

+1 -1

xrpc-server/tests/rate-limiter_test.ts

reviewed

··· 1 1 import { MINUTE } from "@atp/common"; 2 2 - import type { LexiconDoc } from "@atproto/lexicon"; 2 2 + import type { LexiconDoc } from "@atp/lexicon"; 3 3 import { XrpcClient } from "@atp/xrpc"; 4 4 import * as xrpcServer from "../mod.ts"; 5 5 import { closeServer, createServer } from "./_util.ts";

+1 -1

xrpc-server/tests/responses_test.ts

reviewed

··· 1 1 import { byteIterableToStream } from "@atp/common"; 2 2 - import type { LexiconDoc } from "@atproto/lexicon"; 2 2 + import type { LexiconDoc } from "@atp/lexicon"; 3 3 import { XrpcClient } from "@atp/xrpc"; 4 4 import * as xrpcServer from "../mod.ts"; 5 5 import { closeServer, createServer } from "./_util.ts";

+1 -1

xrpc-server/tests/subscriptions_test.ts

reviewed

··· 1 1 import { WebSocket, type WebSocketServer } from "ws"; 2 2 import { wait } from "@atp/common"; 3 3 - import type { LexiconDoc } from "@atproto/lexicon"; 3 3 + import type { LexiconDoc } from "@atp/lexicon"; 4 4 import { 5 5 byFrame, 6 6 ErrorFrame,

+8 -8

xrpc-server/util.ts

reviewed

··· 1 1 - import type { 2 2 - Lexicons, 3 3 - LexXrpcProcedure, 4 4 - LexXrpcQuery, 5 5 - LexXrpcSubscription, 6 6 - } from "@atproto/lexicon"; 7 7 - import { jsonToLex } from "@atproto/lexicon"; 1 1 + import { 2 2 + jsonToLex, 3 3 + type Lexicons, 4 4 + type LexXrpcBody, 5 5 + type LexXrpcProcedure, 6 6 + type LexXrpcQuery, 7 7 + type LexXrpcSubscription, 8 8 + } from "@atp/lexicon"; 8 9 import { 9 10 InternalServerError, 10 11 InvalidRequestError, ··· 20 21 RouteOptions, 21 22 } from "./types.ts"; 22 23 import type { Context, HonoRequest } from "hono"; 23 23 - import type { LexXrpcBody } from "@atproto/lexicon"; 24 24 import { createDecoders, MaxSizeChecker } from "@atp/common"; 25 25 26 26 function assert(condition: unknown, message?: string): asserts condition {

+1 -1

xrpc/client.ts

reviewed

··· 1 1 - import { type LexiconDoc, Lexicons, ValidationError } from "@atproto/lexicon"; 1 1 + import { type LexiconDoc, Lexicons, ValidationError } from "@atp/lexicon"; 2 2 import { 3 3 buildFetchHandler, 4 4 type FetchHandler,

-1

xrpc/deno.json

reviewed

··· 4 4 "exports": "./mod.ts", 5 5 "license": "MIT", 6 6 "imports": { 7 7 - "@atproto/lexicon": "npm:@atproto/lexicon@^0.5.1", 8 7 "zod": "jsr:@zod/zod@^4.1.11" 9 8 }, 10 9 "lint": {

+1 -1

xrpc/types.ts

reviewed

··· 1 1 import { z } from "zod"; 2 2 - import type { ValidationError } from "@atproto/lexicon"; 2 2 + import type { ValidationError } from "@atp/lexicon"; 3 3 4 4 export type QueryParams = Record<string, unknown>; 5 5 export type HeadersMap = Record<string, string | undefined>;

+1 -1

xrpc/util.ts

reviewed

··· 3 3 type LexXrpcProcedure, 4 4 type LexXrpcQuery, 5 5 stringifyLex, 6 6 - } from "@atproto/lexicon"; 6 6 + } from "@atp/lexicon"; 7 7 import { 8 8 type CallOptions, 9 9 type ErrorResponseBody,