chadtmiller.com/hud
A remote MCP server that shows atproto records as interactive UI inside MCP Apps hosts
place.hud.hudkit 0.4.0 Latest 5 packages
0
0
//! Views: how a collection's records are drawn, as data. A view document
//! (`place.hud.view`) names the collection it renders and, for a
//! page of records (`list`) and for one record (`record`), the joins that
//! gather their related records (run by the server, `join`), the summary a
//! tool answers with (`summary`), and a layout: a tree of components from a
//! fixed catalog (`catalog`) whose props are literal values or bindings,
//! paths into the data. A mode left out is drawn generically. A mode, a
//! query view's too, may also join a few related queries, each called once
//! on the whole answer (`QueryJoin`).
//!
//! A view is anyone's document: a model writes one inline, and later views
//! will be records anyone publishes. So it is held to its shape strictly,
//! every problem collected with where it is, for a model to fix them all at
//! once. The bundled views (`views/<id>.json`) are checked the same way,
//! and they and the operator's (`operator`, added at startup) are the only
//! ones trusted: only they may name `origins`, the https
//! origins whose URLs their bindings may load, which the UI resource's CSP
//! then allows, and `thumbnails`, where on those origins a picture drawn
//! small (an avatar) is had smaller. A view given inline can neither name
//! origins nor widen the CSP, and its description reaches no tool
//! description. A trusted view also names its app (`app`, as "Bluesky",
//! `apps`) and may add a section to accounts' profiles (`profile`,
//! `Section`), which `describe_repo` draws with the view's own layout.
//! Everything that reads the trusted views reads them through `bundled()`:
//! the bundled ones, as the operator's replace and add to them (`Views`).
use crate::catalog::{self, Given, Ty};
use serde_json::{Map, Value};
use std::collections::BTreeSet;
use std::sync::{Arc, LazyLock, OnceLock};
/// The most thumbnail rules a trusted view may name.
const MAX_THUMBNAILS: usize = 8;
include!(concat!(env!("OUT_DIR"), "/views.rs"));
/// The view document's type.
pub const TYPE: &str = "place.hud.view";
/// How wide a view would be drawn, where its host can give it the room: the
/// host's reading width (the default), a wider one, or all it has.
pub const MEASURES: &[&str] = &["content", "wide", "full"];
/// The most bytes a view document may take, as JSON.
pub const MAX_BYTES: usize = 64 * 1024;
/// The deepest a layout may nest.
const MAX_DEPTH: usize = 12;
/// The most nodes a layout may have.
const MAX_NODES: usize = 200;
/// The deepest joins may nest.
const MAX_JOIN_DEPTH: usize = 3;
/// The most joins in one join array.
const MAX_JOINS: usize = 8;
/// The most keys a path may have.
const MAX_PATH_KEYS: usize = 10;
/// The most paths one binding may try.
const MAX_BINDING_PATHS: usize = 4;
/// The most `orderBy` paths of a join.
const MAX_ORDER_BY: usize = 4;
/// The most names a counts join counts.
const MAX_COUNTS: usize = 8;
/// A join's limit, by default and at most.
pub const JOIN_LIMIT: usize = 50;
pub const JOIN_LIMIT_MAX: usize = 500;
/// The most origins a trusted view may name.
const MAX_ORIGINS: usize = 8;
/// The most problems an error names.
const PROBLEMS_SHOWN: usize = 20;
/// The most bytes an action's record may take, as JSON.
const ACTION_RECORD_MAX: usize = 4096;
/// The most params an `open` query names.
const MAX_OPEN_PARAMS: usize = 8;
/// The most query joins a mode makes.
pub const MAX_QUERY_JOINS: usize = 6;
/// The keys of the main scope a query join's params read, by mode: never
/// `joins`, another join's result. A query's `at` is what its view shows
/// first, where it shows one at a time (a story's archive, opened at it).
const QUERY_SCOPE: &[&str] = &["method", "service", "params", "response", "me", "at"];
const LIST_SCOPE: &[&str] = &["did", "handle", "collection", "records", "cursor"];
const RECORD_SCOPE: &[&str] = &[
"did",
"handle",
"collection",
"records",
"cursor",
"uri",
"cid",
"value",
];
/// An app page's main scope (`describe_app`): the app, the page's account
/// and the signed-in one, whether they are one (`mine`), and the app's
/// entry points.
const PAGE_SCOPE: &[&str] = &["domain", "name", "icon", "actor", "me", "mine", "entries"];
/// A path into data: keys from a scope, an array's taken as its index.
#[derive(Clone, Debug, PartialEq)]
pub struct Path(Vec<String>);
impl Path {
/// A dotted path, each key `[A-Za-z0-9_$]+`, at most 10; or `.`, the
/// scope itself (an item of an array of strings, say: a post's tags);
/// none if neither. A key `@name` takes the element of an array whose
/// `$type` is named so (`preferences.@photoMetadataPref`: its
/// `…#photoMetadataPref`), as a union's array holds one of each.
pub fn parse(s: &str) -> Option<Path> {
if s == "." {
return Some(Path(Vec::new()));
}
let keys: Vec<String> = s.split('.').map(str::to_string).collect();
let key = |k: &String| {
let name = k.strip_prefix('@').unwrap_or(k);
!name.is_empty()
&& name
.bytes()
.all(|b| b.is_ascii_alphanumeric() || b == b'_' || b == b'$')
};
(keys.len() <= MAX_PATH_KEYS && keys.iter().all(key)).then_some(Path(keys))
}
/// The value at the path in `v`, if there is one: an object's key, or
/// an array's element by its index, or by its type (`@name`).
pub fn get<'a>(&self, v: &'a Value) -> Option<&'a Value> {
Self::get_rest(&self.0, v)
}
/// The path's first key, and the rest.
pub fn split_first(&self) -> Option<(&str, &[String])> {
self.0.split_first().map(|(k, rest)| (k.as_str(), rest))
}
/// The value at the path below a first key already taken.
pub fn get_rest<'a>(rest: &[String], v: &'a Value) -> Option<&'a Value> {
rest.iter().try_fold(v, |v, k| match v {
Value::Object(o) => o.get(k),
Value::Array(a) => match k.strip_prefix('@') {
Some(name) => a.iter().find(|e| {
e["$type"]
.as_str()
.is_some_and(|t| t.rsplit_once('#').map_or(t, |(_, n)| n) == name)
}),
None => a.get(k.parse::<usize>().ok()?),
},
_ => None,
})
}
}
/// A value from the data: the first of its paths that resolves to
/// something other than null.
#[derive(Clone, Debug, PartialEq)]
pub struct Binding(Vec<Path>);
impl Binding {
pub fn get<'a>(&self, scope: &'a Value) -> Option<&'a Value> {
self.0
.iter()
.find_map(|p| p.get(scope).filter(|v| !v.is_null()))
}
}
/// A literal value, or a binding to one.
#[derive(Clone, Debug, PartialEq)]
pub enum Prop {
Literal(Value),
Bound(Binding),
}
impl Prop {
pub fn get<'a>(&'a self, scope: &'a Value) -> Option<&'a Value> {
match self {
Prop::Literal(v) => Some(v),
Prop::Bound(b) => b.get(scope),
}
}
}
/// How a join finds its records.
#[derive(Clone, Debug, PartialEq)]
pub enum Source {
/// The record an at-uri or strongRef at this path names.
Ref(Path),
/// The records each element of an array names, at `ref` within it.
Each { each: Path, at: Path },
/// The records of `collection` in the same repository whose `path`
/// holds the record's uri.
Backlinks { collection: String, path: Path },
/// Counts from a backlink index of the records pointing at the record:
/// each name's collection and path (as the index writes it).
Counts(Vec<(String, String, String)>),
}
/// A join: gathers related records for each record in scope, at `joins.<as>`.
#[derive(Clone, Debug, PartialEq)]
pub struct Join {
pub name: String,
pub source: Source,
/// The collection a ref's target must be of.
pub collection: Option<String>,
pub order_by: Vec<Path>,
pub limit: usize,
/// Joins of its result records.
pub join: Vec<Join>,
}
/// A query join: one query called once on the whole answer (a query
/// view's, or a page of records, never each record), after it and beside
/// the others, its answer at `joins.<as>`, or null.
#[derive(Clone, Debug, PartialEq)]
pub struct QueryJoin {
pub name: String,
/// Where it is in its document, as its problems name it
/// (`query.join[0]`).
pub at: String,
pub method: String,
/// `did:…#fragment`; none for the view's own (a query view's), or else
/// the method's bundled view's.
pub service: Option<String>,
pub params: Vec<(String, Param)>,
/// What the tool's text says of its answer, if anything.
pub say: Option<Say>,
/// Paths in the main scope: called only where `when` holds something
/// (an app page's `mine`: one's own favorites) and `unless` nothing
/// (another's known followers).
pub when: Option<Path>,
pub unless: Option<Path>,
/// Asked each time, never an answer HUD keeps (`xrpc`).
pub fresh: bool,
}
impl QueryJoin {
/// The service it calls: its own, else `own` (a query view's), else
/// its method's trusted view's.
pub fn service_or(&self, own: Option<&str>) -> Option<String> {
self.service_among(own, views())
}
/// `service_or`, the method's view among `views`.
pub fn service_among(&self, own: Option<&str>, views: &Views) -> Option<String> {
self.service
.clone()
.or_else(|| own.map(str::to_string))
.or_else(|| views.service(&self.method).map(str::to_string))
}
/// Whether it reads the page: a page of records' `records`, or a
/// query's answer (`response`), so runs on every page of them, not on
/// the first alone.
pub fn per_page(&self) -> bool {
self.bound().any(|p| {
p.0.first()
.is_some_and(|k| k == "records" || k == "response")
})
}
/// Whether all it reads of its main scope, its params, `when` and
/// `unless`, is under the keys `known`: so it can run once those are,
/// before the rest of the scope (a query's, beside its call).
pub fn reads_only(&self, known: &[&str]) -> bool {
self.bound()
.chain(&self.when)
.chain(&self.unless)
.all(|p| p.0.first().is_some_and(|k| known.contains(&k.as_str())))
}
/// It asking for the page at `cursor`, in place of any cursor it names.
pub fn at_cursor(&self, cursor: &str) -> QueryJoin {
let mut j = self.clone();
j.params.retain(|(k, _)| k != "cursor");
j.params
.push(("cursor".into(), Param::Literal(cursor.into())));
j
}
/// The paths in the main scope its params read.
fn bound(&self) -> impl Iterator<Item = &Path> {
self.params.iter().flat_map(|(_, p)| match p {
Param::Literal(_) => &[][..],
Param::Bound(b) => &b.0[..],
Param::Each { each, .. } => std::slice::from_ref(each),
})
}
}
/// A query join's param: a literal, a value from the main scope, or the
/// values at `at` in each element of the array at `each` there (each
/// record's uri), each once, at most `MAX_PARAM_ARRAY` and the method's
/// `maxLength` for it.
#[derive(Clone, Debug, PartialEq)]
pub enum Param {
Literal(Value),
Bound(Binding),
Each { each: Path, at: Path },
}
/// What a tool's text says of a query join's answer: how many there are
/// (`count`, an array or an integer in it: `5 recent posts`), or its
/// `label`'s first line (`README: knotless keeps…`).
#[derive(Clone, Debug, PartialEq)]
pub struct Say {
pub noun: [String; 2],
pub count: Option<Path>,
pub label: Option<Path>,
}
/// The summary a tool answers with.
#[derive(Clone, Debug, PartialEq)]
pub struct Summary {
pub noun: [String; 2],
pub label: Option<Prop>,
/// Who an answer that is one thing is by: a query mode's without items.
pub by: Option<Prop>,
/// A count and its noun; a count bound to an array counts its
/// elements, and with the path to each one's children (as `replies`),
/// theirs too, all the way down.
pub detail: Option<(Prop, [String; 2], Option<Path>)>,
}
/// A mode of a view: a page of records, or one.
#[derive(Clone, Debug, PartialEq)]
pub struct Mode {
pub join: Vec<Join>,
/// The queries it joins, once a page.
pub queries: Vec<QueryJoin>,
pub summary: Option<Summary>,
}
/// A method view's one mode: a query's answer.
#[derive(Clone, Debug, PartialEq)]
pub struct QueryMode {
/// The answer's array of items, from the answer (`feed`); none for an
/// answer that is one thing (a thread).
pub items: Option<Path>,
/// The answer's cursor for the next page, from the answer.
pub cursor: Option<Path>,
/// Each item's key, within it (`post.uri`): with it, a tree says how
/// to tell something newer came (`_meta.ui.latest`).
pub latest: Option<Path>,
pub summary: Option<Summary>,
/// The queries it joins, once an answer.
pub queries: Vec<QueryJoin>,
/// Its query asked each time, never an answer HUD keeps (`xrpc`).
pub fresh: bool,
}
/// An app page view's one mode: the queries it joins on the page's main
/// scope (`PAGE_SCOPE`), its layout, in `doc`, what a #tag in its
/// app's text opens (`{ query, params, service? }`, its params read from
/// `{ tag }`), where the app has a search for one, and the join that pages
/// the page (`pages`, its `as`): its answer's `cursor` the page more.
#[derive(Clone, Debug, PartialEq)]
pub struct PageMode {
pub queries: Vec<QueryJoin>,
pub tag: Option<Value>,
pub pages: Option<String>,
}
impl PageMode {
/// The join that pages the page, asking for the page at `cursor`.
pub fn more(&self, cursor: &str) -> Option<QueryJoin> {
let name = self.pages.as_deref()?;
let found = self.queries.iter().find(|j| j.name == name);
Some(found?.at_cursor(cursor))
}
}
/// A view, checked: of a collection's records (`list`, `record`), of a
/// query's answers (`query`), or a bundled app's page (`domain`, `page`).
/// Its layouts stay in `doc`, which the view draws.
#[derive(Clone, Debug, PartialEq)]
pub struct View {
/// The collection it draws, for a collection view.
pub collection: Option<String>,
/// The query it draws, for a method view.
pub method: Option<String>,
/// The app whose page it draws, for an app page view: its domain, as
/// `apps` names one (`knotless.dev`).
pub domain: Option<String>,
/// A method view's service, the query tool's default; an app page's,
/// its joins': `did:…#fragment`.
pub service: Option<String>,
pub description: String,
/// The https origins its URL bindings may load: a trusted view's alone.
pub origins: Vec<String>,
pub page_size: Option<u32>,
pub list: Option<Mode>,
pub record: Option<Mode>,
pub query: Option<QueryMode>,
pub page: Option<PageMode>,
/// The feed interactions a trusted method view reports for its items.
pub interactions: Option<Interactions>,
/// What a trusted method view asks a person signed out to do when its
/// query needs an account: "Sign in to see your notifications".
pub sign_in: Option<String>,
/// What a trusted method view offers a workspace's launcher: each a
/// title and the query's params, `{"$me": "did" | "handle"}` the person.
pub launch: Vec<Launch>,
/// The records a trusted method view draws as its query (`get_record`
/// of one answers as the query does): each its collection and the
/// query's params read from the record.
pub records: Vec<Routed>,
/// The app a trusted view's records or query are of, as people name it
/// ("Bluesky"): its NSID's domain is named so (`apps`).
pub app: Option<String>,
/// The section a trusted view adds to an account's profile
/// (`describe_repo`), where the account uses what it draws.
pub profile: Option<Section>,
/// What an account did in making one of a trusted collection view's
/// records, a short past-tense verb ("Posted"), for its profile's
/// recent activity: the verb, then the record's summary label.
pub activity: Option<String>,
/// The procedures its layouts call (`Action`'s `call`, `Messages`'
/// `send`), and the queries whose deletion plans they delete
/// (`deletes`): a trusted view's alone.
pub calls: Vec<Call>,
/// What its layouts' `deletes` say beyond their query (`Plan`): a
/// trusted view's alone.
pub plans: Vec<Plan>,
/// The document as given.
pub doc: Value,
}
/// What a trusted feed view reports to its feed as the person reads it:
/// the feed's at-uri, bound in the query's scope, and the paths within
/// each item to its uri and the feed's own context for it.
#[derive(Clone, Debug, PartialEq)]
pub struct Interactions {
pub feed: Binding,
pub item: Path,
pub feed_context: Option<Path>,
pub req_id: Option<Path>,
}
/// A procedure a trusted view's layout calls as the signed-in person: its
/// method, the service it is sent to, and its input as a template, whose
/// values the view fills in (bindings, `{"$root": path}`, `{"$now": true}`,
/// `{"$strongRef": path}`, and in a `Messages`' `send`, `{"$text": true}`,
/// what the person wrote). With `deletes`, the method is a query of the
/// service answering a deletion plan, the input its params, and what it
/// plans is deleted (`Action`'s and select's `deletes`).
#[derive(Clone, Debug, PartialEq)]
pub struct Call {
pub method: String,
pub service: String,
pub input: Value,
pub deletes: bool,
}
/// What a trusted view's `deletes` says beyond its query, which HUD reads
/// from the view as it deletes (`Hud::delete_planned`), so no client
/// changes it: the query and its service; whether it is asked again until
/// a plan comes back empty (`repeat`, an account's data, a part at a
/// time); the collections its deletes may reach beyond those the views
/// write, which sign-in asks to delete; and the procedure called once
/// nothing is left (`then`), its input literal but `{"$did": true}`, the
/// account's DID.
#[derive(Clone, Debug, PartialEq)]
pub struct Plan {
pub method: String,
pub service: String,
pub repeat: bool,
pub collections: Vec<String>,
pub then: Option<Call>,
}
/// The problems found in a document, each where it is; whether the
/// document is trusted; whether a layout sends interactions; the
/// procedures its layouts call; the service each trusted method view
/// names, by its method, which a records view's query join calls when it
/// names none; and the plans its layouts commit.
struct Problems<'a>(
Vec<String>,
bool,
bool,
Vec<Call>,
&'a [(String, String)],
Vec<Plan>,
);
impl Problems<'_> {
fn add(&mut self, at: &str, what: impl std::fmt::Display) {
self.0.push(format!("{at}: {what}"));
}
/// `v` as an object with only `allowed` keys, the others each a problem.
fn object<'a>(
&mut self,
v: &'a Value,
at: &str,
allowed: &[&str],
) -> Option<&'a Map<String, Value>> {
let Some(o) = v.as_object() else {
self.add(at, "must be an object");
return None;
};
self.keys(o, at, allowed);
Some(o)
}
/// Each of an object's keys but `allowed` a problem.
fn keys(&mut self, o: &Map<String, Value>, at: &str, allowed: &[&str]) {
for k in o.keys().filter(|k| !allowed.contains(&k.as_str())) {
self.add(at, format_args!("unknown key \"{k}\""));
}
}
fn path(&mut self, v: &Value, at: &str) -> Option<Path> {
match v.as_str() {
Some(s) => {
let p = Path::parse(s);
if p.is_none() {
self.add(at, format_args!("unknown path syntax \"{s}\""));
}
p
}
None => {
self.add(at, "must be a path, keys joined by dots");
None
}
}
}
fn nsid(&mut self, v: Option<&Value>, at: &str) -> Option<String> {
match v.and_then(Value::as_str) {
Some(s) if atproto::syntax::is_nsid(s) => Some(s.to_string()),
_ => {
self.add(at, "must be an NSID");
None
}
}
}
/// `v`, true or false; false where it is missing or neither.
fn flag(&mut self, v: Option<&Value>, at: &str) -> bool {
match v {
None => false,
Some(Value::Bool(b)) => *b,
Some(_) => {
self.add(at, "must be true or false");
false
}
}
}
fn line(&mut self, v: Option<&Value>, at: &str, max: usize) -> Option<String> {
match v.and_then(Value::as_str) {
Some(s)
if !s.trim().is_empty()
&& s.chars().count() <= max
&& !s.chars().any(char::is_control) =>
{
Some(s.to_string())
}
_ => {
self.add(
at,
format_args!("must be one line of text, {max} characters at most"),
);
None
}
}
}
fn nouns(&mut self, v: Option<&Value>, at: &str) -> Option<[String; 2]> {
match v.and_then(Value::as_array).map(Vec::as_slice) {
Some([Value::String(a), Value::String(b)])
if [a, b]
.iter()
.all(|w| (1..=32).contains(&w.len()) && !w.contains(char::is_control)) =>
{
Some([a.clone(), b.clone()])
}
_ => {
self.add(at, "must be [singular, plural]");
None
}
}
}
fn int(&mut self, v: &Value, at: &str, max: u64) -> Option<u64> {
let n = v.as_u64().filter(|n| (1..=max).contains(n));
if n.is_none() {
self.add(at, format_args!("must be an integer from 1 to {max}"));
}
n
}
/// A binding, if `v` is one: `{"$": path}` or `{"$": [paths]}`.
fn binding(&mut self, v: &Value, at: &str) -> Option<Option<Binding>> {
let o = v.as_object().filter(|o| o.contains_key("$"))?;
if o.len() != 1 {
self.add(at, "a binding has the key \"$\" alone");
return Some(None);
}
let paths: Vec<&Value> = match &o["$"] {
Value::Array(a) if (1..=MAX_BINDING_PATHS).contains(&a.len()) => a.iter().collect(),
Value::Array(_) => {
self.add(
at,
format_args!("a binding tries 1 to {MAX_BINDING_PATHS} paths"),
);
return Some(None);
}
p => vec![p],
};
let paths: Vec<Option<Path>> = paths
.into_iter()
.map(|p| self.path(p, &format!("{at}.$")))
.collect();
Some(paths.into_iter().collect::<Option<Vec<_>>>().map(Binding))
}
/// `{"$root": path}`: a path from the view's own scope.
fn root(&mut self, v: &Value, at: &str) {
let Some(o) = v.as_object() else { return };
if o.len() != 1 {
self.add(at, "a root binding has the key \"$root\" alone");
return;
}
self.path(&o["$root"], &format!("{at}.$root"));
}
/// A summary value: a binding, or a literal checked by `literal`.
fn prop(
&mut self,
v: &Value,
at: &str,
literal: impl Fn(&Value) -> bool,
want: &str,
) -> Option<Prop> {
match self.binding(v, at) {
Some(b) => b.map(Prop::Bound),
None if literal(v) => Some(Prop::Literal(v.clone())),
None => {
self.add(at, format_args!("must be {want} or a binding"));
None
}
}
}
}
/// What only a bundled view may say at its top, which a view given inline
/// may not.
const BUNDLED_ONLY: [&str; 7] = [
"interactions",
"signIn",
"launch",
"records",
"app",
"profile",
"activity",
];
/// A bundled view's document as a view given inline may be, for the
/// playground to start from: less what only a bundled view may say at its
/// top. What its layout does that only a bundled view may (a procedure
/// called, a feed told what was read) stays, a problem to take out.
pub fn inline_copy(doc: &Value) -> Value {
let mut copy = doc.clone();
let top = copy.as_object_mut().into_iter();
top.for_each(|o| o.retain(|k, _| !BUNDLED_ONLY.contains(&k.as_str())));
copy
}
/// Check a document; a view, or every problem with it. An untrusted
/// view may not name origins.
pub fn parse(doc: &Value, trusted: bool) -> Result<View, Vec<String>> {
parse_in(doc, trusted, &views().services)
}
/// `parse`, a records view's query joins calling by default the services
/// `services` names, by method.
fn parse_in(
doc: &Value,
trusted: bool,
services: &[(String, String)],
) -> Result<View, Vec<String>> {
let size = serde_json::to_vec(doc).map_or(usize::MAX, |b| b.len());
if size > MAX_BYTES {
return Err(vec![format!(
"view: {size} bytes, more than the {MAX_BYTES} a view may take"
)]);
}
let mut p = Problems(Vec::new(), trusted, false, Vec::new(), services, Vec::new());
let view = parse_view(&mut p, doc, trusted);
match view {
Some(v) if p.0.is_empty() => Ok(v),
_ => Err(p.0),
}
}
/// A view's problems as a tool's one-line error.
pub fn error_text(problems: &[String]) -> String {
let n = problems.len();
let shown: Vec<&str> = problems
.iter()
.take(PROBLEMS_SHOWN)
.map(String::as_str)
.collect();
let more = if n > PROBLEMS_SHOWN {
format!("; and {} more", n - PROBLEMS_SHOWN)
} else {
String::new()
};
format!(
"Invalid view: {n} problem{}: {}{more}",
if n == 1 { "" } else { "s" },
shown.join("; ")
)
}
fn parse_view(p: &mut Problems, doc: &Value, trusted: bool) -> Option<View> {
let o = p.object(
doc,
"view",
&[
"$schema",
"$type",
"collection",
"method",
"service",
"description",
"origins",
"thumbnails",
"pageSize",
"list",
"record",
"query",
"interactions",
"signIn",
"launch",
"records",
"app",
"profile",
"activity",
"domain",
"page",
"measure",
"measureWhen",
],
)?;
if let Some(t) = o.get("$type")
&& t != TYPE
{
p.add("view.$type", format_args!("must be {TYPE}"));
}
// A view draws a collection's records, a query's answers, or an app's
// page: one.
let is_page = o.contains_key("domain") || o.contains_key("page");
let (collection, method) = match (o.get("collection"), o.get("method")) {
(Some(_), _) | (_, Some(_)) if is_page => {
p.add(
"view",
"an app page draws its domain, not a collection or a method",
);
return None;
}
_ if is_page => (Some(None), Some(None)),
(Some(_), Some(_)) => {
// Which the rest should be checked as is unknown: say only this.
p.add("view", "a view draws a collection or a method, not both");
return None;
}
(Some(c), None) => (p.nsid(Some(c), "view.collection").map(Some), Some(None)),
(None, Some(m)) => (Some(None), p.nsid(Some(m), "view.method").map(Some)),
(None, None) => {
p.add("view", "collection or method required");
(None, None)
}
};
let is_method = matches!(method, Some(Some(_)));
let description = p.line(o.get("description"), "view.description", 200);
let origins = match o.get("origins") {
None => Vec::new(),
Some(v) => origins(p, v, trusted),
};
if let Some(v) = o.get("thumbnails") {
thumbnails(p, v, &origins);
}
// How wide it would be drawn, where its host can give it the room: by
// the answer, the first of 1 to 8 cases whose `when` it holds, else
// `measure`.
let measure = |p: &mut Problems, m: &Value, at: &str| {
if !MEASURES.iter().any(|w| m == *w) {
p.add(at, format_args!("must be one of {}", MEASURES.join(", ")));
}
};
if let Some(m) = o.get("measure") {
measure(p, m, "view.measure");
}
match o.get("measureWhen").map(Value::as_array) {
None => {}
Some(Some(cases)) if (1..=8).contains(&cases.len()) => {
for (i, case) in cases.iter().enumerate() {
let at = format!("view.measureWhen[{i}]");
if p.object(case, &at, &["when", "measure"]).is_some() {
p.path(&case["when"], &format!("{at}.when"));
measure(p, &case["measure"], &format!("{at}.measure"));
}
}
}
Some(_) => p.add("view.measureWhen", "must be 1 to 8 cases"),
}
let refuse = |p: &mut Problems, k: &str, why: &str| {
if o.contains_key(k) {
p.add(&format!("view.{k}"), why);
}
};
let service = if is_method || is_page {
match o.get("service").and_then(Value::as_str) {
Some(s) => match crate::xrpc::Service::parse(s) {
Ok(s) => Some(s.name()),
Err(_) => {
p.add("view.service", "must be a DID with its service's #fragment, as did:web:api.bsky.app#bsky_appview");
None
}
},
None => {
let why = if is_page {
"an app page names the service its joins call"
} else {
"a method view names the service it calls"
};
p.add("view.service", why);
None
}
}
} else {
refuse(
p,
"service",
"only a method view or an app page names a service",
);
None
};
let mode = |p: &mut Problems, k: &str| o.get(k).map(|m| parse_mode(p, m, k));
let (page_size, list, record, query) = if is_page {
for k in ["pageSize", "list", "record", "query"] {
refuse(p, k, "an app page has its page alone");
}
(None, None, None, None)
} else if is_method {
for k in ["pageSize", "list", "record"] {
refuse(p, k, "a method view has the query mode alone");
}
let query = match o.get("query") {
Some(q) => parse_query_mode(p, q),
None => {
p.add("view", "a method view needs its query mode");
None
}
};
(None, None, None, query)
} else {
refuse(p, "query", "only a method view has a query mode");
let page_size = o
.get("pageSize")
.and_then(|v| p.int(v, "view.pageSize", 100))
.map(|n| n as u32);
let list = mode(p, "list");
let record = mode(p, "record");
if list.is_none() && record.is_none() {
p.add("view", "list or record required");
}
(page_size, list.flatten(), record.flatten(), None)
};
let interactions = match o.get("interactions") {
None => None,
Some(_) if !trusted => {
p.add(
"view.interactions",
"only a bundled view reports interactions",
);
None
}
Some(v) => {
if !query.as_ref().is_some_and(|q| q.items.is_some()) {
p.add(
"view.interactions",
"only a method view with query.items reports interactions, for its items",
);
}
parse_interactions(p, v)
}
};
let sign_in = match o.get("signIn") {
None => None,
Some(_) if !trusted => {
p.add(
"view.signIn",
"only a bundled view says what signing in shows",
);
None
}
Some(_) if !is_method => {
p.add("view.signIn", "only a method view's query asks for sign-in");
None
}
Some(v) => p.line(Some(v), "view.signIn", 80),
};
let launch = match o.get("launch") {
None => Vec::new(),
Some(_) if !trusted => {
p.add("view.launch", "only a bundled view offers launchers");
Vec::new()
}
Some(_) if !is_method => {
p.add("view.launch", "only a method view's query is launched");
Vec::new()
}
Some(v) => parse_launch(p, v),
};
let records = match o.get("records") {
None => Vec::new(),
Some(_) if !trusted => {
p.add(
"view.records",
"only a bundled view names the records it draws",
);
Vec::new()
}
Some(_) if !is_method => {
p.add(
"view.records",
"only a method view draws records, as its query",
);
Vec::new()
}
Some(v) => parse_records(p, v),
};
let app = match o.get("app") {
None => None,
Some(_) if !trusted => {
p.add("view.app", "only a bundled view names its app");
None
}
Some(v) => p.line(Some(v), "view.app", MAX_APP),
};
let profile = match o.get("profile") {
None => None,
Some(_) if is_page => {
p.add("view.profile", "an app page adds no section to profiles");
None
}
Some(_) if !trusted => {
p.add(
"view.profile",
"only a bundled view adds a section to profiles",
);
None
}
Some(v) => parse_section(p, v, is_method),
};
let activity = match o.get("activity") {
None => None,
Some(_) if !trusted => {
p.add("view.activity", "only a bundled view names its activity");
None
}
Some(_) if is_method => {
p.add(
"view.activity",
"only a collection view's records are activity",
);
None
}
Some(_) if list.as_ref().and_then(|m| m.summary.as_ref()).is_none() => {
p.add(
"view.activity",
"activity names its records by the list's summary, which it needs",
);
None
}
Some(v) => p.line(Some(v), "view.activity", MAX_ACTIVITY),
};
let app_page = if is_page {
Some(parse_app_page(p, o, trusted)?)
} else {
None
};
let (domain, page) = app_page.unzip();
// An action that sends an interaction sends it for an item of the
// feed the view reports to.
if p.2 && trusted && !o.contains_key("interactions") {
p.add(
"view",
"an Action with interaction needs the view's interactions, naming the feed and its items",
);
}
Some(View {
collection: collection?,
method: method?,
domain,
service,
description: description?,
origins,
page_size,
list,
record,
query,
page,
interactions,
sign_in,
launch,
records,
app,
profile,
activity,
calls: std::mem::take(&mut p.3),
plans: std::mem::take(&mut p.5),
doc: doc.clone(),
})
}
/// An app page view's `domain` and `page`: `{ join?, layout, tag?, pages? }`,
/// its joins query joins alone, their params reading the page's main scope
/// (`PAGE_SCOPE`), `pages` one of them by its `as`. A bundled view's alone:
/// a page is the app's own.
fn parse_app_page(
p: &mut Problems,
o: &Map<String, Value>,
trusted: bool,
) -> Option<(String, PageMode)> {
if !trusted {
p.add("view.page", "only a bundled view is an app's page");
}
let domain = match o.get("domain").and_then(Value::as_str) {
Some(d) => match crate::icons::checked_domain(d, false) {
Some(c) if c == d => Some(c),
_ => {
p.add(
"view.domain",
"must be an app's domain, in lower case, as knotless.dev",
);
None
}
},
None => {
p.add("view.domain", "an app page names its app's domain");
None
}
};
let Some(v) = o.get("page") else {
p.add(
"view.page",
"an app page needs its page: { join?, layout, tag?, pages? }",
);
return None;
};
let at = "page";
let po = p.object(v, at, &["join", "layout", "tag", "pages", "head"])?;
let queries = match po.get("join") {
Some(j) => joins(p, j, "page.join", 1, Some((PAGE_SCOPE, false))).1,
None => Vec::new(),
};
layout(p, po.get("layout"), at);
if let Some(h) = po.get("head") {
head(p, h, "page.head");
}
let tag = po.get("tag").cloned();
if let Some(t) = &tag {
open_query(p, t, "page.tag");
}
let pages = match po.get("pages") {
None => None,
Some(Value::String(s)) if queries.iter().any(|j| &j.name == s) => Some(s.clone()),
Some(_) => {
p.add("page.pages", "the as of one of the page's joins");
None
}
};
Some((
domain?,
PageMode {
queries,
tag,
pages,
},
))
}
/// The most characters an app's name takes.
const MAX_APP: usize = 40;
/// The most characters a view's activity verb takes.
const MAX_ACTIVITY: usize = 20;
/// The most records a collection view's profile section shows, and how
/// many where it names none.
const MAX_SECTION: u64 = 10;
const SECTION_LIMIT: u32 = 3;
/// The section a bundled view adds to an account's profile: its title, and
/// what it shows. A method view's calls its query with `params`, each a
/// literal or `{"$actor": "did"}`, the account's DID, or an array of those;
/// a collection view's shows that collection's newest `limit` records. A
/// method view's `head` section is drawn in the profile's head, untitled,
/// for anyone the signed-in person looks at (a Message button), not where
/// the account uses its app.
#[derive(Clone, Debug, PartialEq)]
pub struct Section {
pub title: String,
pub params: Map<String, Value>,
pub limit: u32,
pub head: bool,
}
impl Section {
/// Its params with `$actor` made the account's DID.
pub fn params_for(&self, did: &str) -> Map<String, Value> {
let made = |v: &Value| match actor(v) {
Some(_) => Value::String(did.to_string()),
None => v.clone(),
};
self.params
.iter()
.map(|(k, v)| {
let v = match v {
Value::Array(items) => Value::Array(items.iter().map(made).collect()),
v => made(v),
};
(k.clone(), v)
})
.collect()
}
}
/// What `{"$actor": …}` names, if `v` is that.
fn actor(v: &Value) -> Option<&str> {
v.as_object()
.filter(|o| o.len() == 1)
.and_then(|o| o.get("$actor"))
.and_then(Value::as_str)
}
/// A view's `profile`: `{ title, params?, head? }` for a method view, each
/// param a string, number or boolean, or `{"$actor": "did"}`, or an array
/// of those; `{ title, limit? }` for a collection view, 1 to 10 records, 3
/// where it names none.
fn parse_section(p: &mut Problems, v: &Value, method: bool) -> Option<Section> {
let at = "view.profile";
let keys: &[&str] = if method {
&["title", "params", "head"]
} else {
&["title", "limit"]
};
let o = p.object(v, at, keys)?;
let title = p.line(o.get("title"), &format!("{at}.title"), MAX_APP);
let limit = match o.get("limit") {
None => SECTION_LIMIT,
Some(l) => p
.int(l, &format!("{at}.limit"), MAX_SECTION)
.map_or(SECTION_LIMIT, |n| n as u32),
};
let head = match o.get("head") {
None => false,
Some(Value::Bool(b)) => *b,
Some(_) => {
p.add(&format!("{at}.head"), "must be true or false");
false
}
};
let one = |v: &Value| match v {
Value::String(_) | Value::Number(_) | Value::Bool(_) => true,
Value::Object(_) => actor(v) == Some("did"),
_ => false,
};
let mut params = Map::new();
match o.get("params") {
None => {}
Some(Value::Object(given)) if given.len() <= MAX_OPEN_PARAMS => {
for (k, v) in given {
let ok = match v {
Value::Array(items) => {
(1..=MAX_OPEN_ARRAY).contains(&items.len()) && items.iter().all(one)
}
v => one(v),
};
if ok {
params.insert(k.clone(), v.clone());
} else {
p.add(
&format!("{at}.params.{k}"),
"must be a string, number, boolean or {\"$actor\": \"did\"}, or an array of those",
);
}
}
}
Some(_) => p.add(
&format!("{at}.params"),
format_args!("must be an object of at most {MAX_OPEN_PARAMS} params"),
),
}
Some(Section {
title: title?,
params,
limit,
head,
})
}
/// The most launchers a view offers.
const MAX_LAUNCH: usize = 4;
/// A launcher a bundled method view offers: a title, and the query's params,
/// each a literal or `{"$me": "did" | "handle"}`, the person launching it.
#[derive(Clone, Debug, PartialEq)]
pub struct Launch {
pub title: String,
pub params: Map<String, Value>,
}
impl Launch {
/// Its params with `$me` made the person's DID or handle; none when
/// one names the handle and the person has none.
pub fn params_for(&self, did: &str, handle: Option<&str>) -> Option<Map<String, Value>> {
self.params
.iter()
.map(|(k, v)| {
let v = match me(v) {
Some("did") => Value::String(did.to_string()),
Some(_) => Value::String(handle?.to_string()),
None => v.clone(),
};
Some((k.clone(), v))
})
.collect()
}
/// Whether it names the person launching it (`$me`), so needs one
/// signed in.
pub fn names_me(&self) -> bool {
self.params.values().any(|v| me(v).is_some())
}
}
/// What `{"$me": …}` names, if `v` is that.
fn me(v: &Value) -> Option<&str> {
v.as_object()
.filter(|o| o.len() == 1)
.and_then(|o| o.get("$me"))
.and_then(Value::as_str)
}
/// A view's `launch`: 1 to 4 of `{ title, params? }`, each param a string,
/// number or boolean, or `{"$me": "did" | "handle"}`.
fn parse_launch(p: &mut Problems, v: &Value) -> Vec<Launch> {
let Some(items) = v.as_array().filter(|a| (1..=MAX_LAUNCH).contains(&a.len())) else {
p.add(
"view.launch",
format_args!("must be 1 to {MAX_LAUNCH} launchers"),
);
return Vec::new();
};
let mut out = Vec::new();
for (i, item) in items.iter().enumerate() {
let at = format!("view.launch[{i}]");
let Some(o) = p.object(item, &at, &["title", "params"]) else {
continue;
};
let title = p.line(o.get("title"), &format!("{at}.title"), 40);
let mut params = Map::new();
match o.get("params") {
None => {}
Some(Value::Object(given)) => {
for (k, v) in given {
let kat = format!("{at}.params.{k}");
let ok = match v {
Value::String(_) | Value::Number(_) | Value::Bool(_) => true,
Value::Object(_) => matches!(me(v), Some("did" | "handle")),
_ => false,
};
if ok {
params.insert(k.clone(), v.clone());
} else {
p.add(
&kat,
"must be a string, number, boolean or {\"$me\": \"did\" | \"handle\"}",
);
}
}
}
Some(_) => p.add(&format!("{at}.params"), "must be an object of params"),
}
if let Some(title) = title {
out.push(Launch { title, params });
}
}
out
}
/// The most collections a view names in `records`.
const MAX_RECORDS: usize = 8;
/// What a `records` entry's bindings read: a record as `join::rec` gives
/// it.
const ROUTED_SCOPE: &[&str] = &["uri", "cid", "did", "value"];
/// A collection a bundled method view draws as its query: a record of it
/// opened by its at-uri (`get_record`) answers as the query does, with
/// `params` read from the record, each a literal or a binding into
/// `{ uri, cid, did, value }`, and `at`, what the answer shows first where
/// it shows one at a time (a story in its account's archive), a binding
/// into it too; and what making one is, for a profile's recent activity.
#[derive(Clone, Debug, PartialEq)]
pub struct Routed {
pub collection: String,
pub params: Vec<(String, Prop)>,
pub at: Option<Prop>,
pub activity: Option<RecordActivity>,
}
/// What making a record is, as an account's recent activity says it: a
/// short past-tense verb ("Posted"), then the record's label, or its noun
/// where it has none, as `summary` gives them.
#[derive(Clone, Debug, PartialEq)]
pub struct RecordActivity {
pub verb: String,
pub summary: Summary,
}
impl Routed {
/// Whether a param, or `at`, reads what only reading the record gives:
/// its `value` or `cid`.
pub fn reads_record(&self) -> bool {
let mut props = self.params.iter().map(|(_, p)| p).chain(&self.at);
props.any(|p| match p {
Prop::Literal(_) => false,
Prop::Bound(b) => {
b.0.iter()
.any(|p| matches!(p.0.first().map(String::as_str), Some("value" | "cid")))
}
})
}
/// The query's params for the record `rec` (as `join::rec` gives it);
/// none where a binding finds no string, number or boolean.
pub fn params_for(&self, rec: &Value) -> Option<Map<String, Value>> {
self.params
.iter()
.map(|(k, p)| {
let v = p.get(rec).filter(|v| match v {
Value::String(s) => !s.is_empty(),
v => v.is_number() || v.is_boolean(),
})?;
Some((k.clone(), v.clone()))
})
.collect()
}
/// The `query` tool's arguments for the record `rec`: `method`, its
/// params (`params_for`) and, where `at` finds a string, what the
/// answer shows first. None where a param finds nothing.
pub fn args_for(&self, method: &str, rec: &Value) -> Option<Value> {
let mut args = serde_json::json!({ "method": method, "params": self.params_for(rec)? });
if let Some(first) = self
.at
.as_ref()
.and_then(|a| a.get(rec))
.filter(|v| v.is_string())
{
args["at"] = first.clone();
}
Some(args)
}
}
/// A view's `records`: 1 to 8 of `{ collection, params, at?, activity? }`,
/// each collection once; each param a string, number or boolean, or a
/// binding into the record (`ROUTED_SCOPE`); at a binding into the record;
/// activity `{ verb, noun, label? }`, the verb one line of at most 20
/// characters, the label a binding into the record.
fn parse_records(p: &mut Problems, v: &Value) -> Vec<Routed> {
let Some(items) = v
.as_array()
.filter(|a| (1..=MAX_RECORDS).contains(&a.len()))
else {
p.add(
"view.records",
format_args!("must be 1 to {MAX_RECORDS} collections"),
);
return Vec::new();
};
// A binding into the record.
let bound = |p: &mut Problems, v: &Value, at: &str| -> Option<Binding> {
let b = match p.binding(v, at) {
Some(b) => b?,
None => {
p.add(at, "must be a binding {\"$\": path} into the record");
return None;
}
};
let into = |path: &Path| {
path.0
.first()
.is_some_and(|k| ROUTED_SCOPE.contains(&k.as_str()))
};
if !b.0.iter().all(into) {
p.add(
at,
format_args!("reads the record: a path from {}", ROUTED_SCOPE.join(", ")),
);
return None;
}
Some(b)
};
let mut out: Vec<Routed> = Vec::new();
for (i, item) in items.iter().enumerate() {
let at = format!("view.records[{i}]");
let Some(o) = p.object(item, &at, &["collection", "params", "at", "activity"]) else {
continue;
};
let collection = p.nsid(o.get("collection"), &format!("{at}.collection"));
if let Some(c) = &collection
&& out.iter().any(|r| r.collection == *c)
{
p.add(
&format!("{at}.collection"),
format_args!("{c} is named twice"),
);
}
let mut params = Vec::new();
match o.get("params") {
Some(Value::Object(given)) if (1..=MAX_OPEN_PARAMS).contains(&given.len()) => {
for (k, v) in given {
let kat = format!("{at}.params.{k}");
let prop = match v {
Value::String(_) | Value::Number(_) | Value::Bool(_) => {
Some(Prop::Literal(v.clone()))
}
v => bound(p, v, &kat).map(Prop::Bound),
};
if let Some(prop) = prop {
params.push((k.clone(), prop));
}
}
}
_ => p.add(
&format!("{at}.params"),
format_args!("must be an object of 1 to {MAX_OPEN_PARAMS} params"),
),
}
let first = o
.get("at")
.and_then(|a| bound(p, a, &format!("{at}.at")).map(Prop::Bound));
let activity = o.get("activity").and_then(|a| {
let aat = format!("{at}.activity");
let ao = p.object(a, &aat, &["verb", "noun", "label"])?;
let verb = p.line(ao.get("verb"), &format!("{aat}.verb"), MAX_ACTIVITY);
let noun = p.nouns(ao.get("noun"), &format!("{aat}.noun"));
let label = match ao.get("label") {
None => None,
Some(l) => Some(Prop::Bound(bound(p, l, &format!("{aat}.label"))?)),
};
Some(RecordActivity {
verb: verb?,
summary: Summary {
noun: noun?,
label,
by: None,
detail: None,
},
})
});
if let Some(collection) = collection {
out.push(Routed {
collection,
params,
at: first,
activity,
});
}
}
out
}
/// Whether a launcher's params are its method's, as its lexicon's
/// `def` takes them, `$me` standing for a DID and a handle and a feed
/// named as a person names them (`feeds::names_feeds`) for an at-uri:
/// every problem.
pub fn launch_problems(
launch: &Launch,
lexicons: &atproto::lexicon::Lexicons,
method: &str,
def: &Value,
) -> Vec<String> {
let mut params = launch
.params_for(
"did:plc:abcdefghijklmnopqrstuvwx",
Some("alice.example.com"),
)
.unwrap_or_default();
crate::feeds::stand_in(method, &mut params);
crate::xrpc::params_problems(lexicons, method, def, ¶ms)
}
/// The launchers every bundled view gives, for a workspace's "New tile",
/// each `{ app, domain, title, method, service, params }`: its app as
/// `apps` names it for its method's domain (`dev.knotless.getFeed`:
/// knotless.dev, knotless; `app.bsky.feed.getTimeline`: bsky.app,
/// Bluesky), its params made the person's (`did`, `handle`). One whose
/// params need a handle the person lacks is left out.
pub fn launchers(did: &str, handle: Option<&str>) -> Vec<Value> {
bundled()
.iter()
.filter_map(|b| {
Some((
b.view.method.as_deref()?,
b.view.service.as_deref()?,
&b.view.launch,
))
})
.flat_map(|(method, service, launch)| {
let domain = crate::apps::domain(method).unwrap_or_default();
let app = crate::apps::name(&domain);
launch.iter().filter_map(move |l| {
let params = l.params_for(did, handle)?;
Some(
serde_json::json!({ "app": &app, "domain": &domain, "title": l.title,
"method": method, "service": service, "params": params }),
)
})
})
.collect()
}
/// A view's `interactions`: `{ feed: binding, item: path, feedContext?:
/// path, reqId?: path }`.
fn parse_interactions(p: &mut Problems, v: &Value) -> Option<Interactions> {
let at = "view.interactions";
let o = p.object(v, at, &["feed", "item", "feedContext", "reqId"])?;
let feed = match o.get("feed") {
Some(f) => match p.binding(f, &format!("{at}.feed")) {
Some(b) => b,
None => {
p.add(
&format!("{at}.feed"),
"must be a binding {\"$\": path} to the feed's at-uri, as params.feed",
);
None
}
},
None => {
p.add(&format!("{at}.feed"), "required");
None
}
};
let item = match o.get("item") {
Some(i) => p.path(i, &format!("{at}.item")),
None => {
p.add(&format!("{at}.item"), "required: the path to an item's uri");
None
}
};
let feed_context = o
.get("feedContext")
.and_then(|c| p.path(c, &format!("{at}.feedContext")));
let req_id = o
.get("reqId")
.and_then(|r| p.path(r, &format!("{at}.reqId")));
Some(Interactions {
feed: feed?,
item: item?,
feed_context,
req_id,
})
}
/// A method view's `query` mode: where the answer's items and cursor are,
/// if it has them, the queries it joins, its summary, its layout.
fn parse_query_mode(p: &mut Problems, v: &Value) -> Option<QueryMode> {
let at = "query";
let o = p.object(
v,
at,
&[
"items", "cursor", "latest", "join", "summary", "head", "layout", "fresh",
],
)?;
let items = o.get("items").and_then(|i| p.path(i, "query.items"));
let cursor = o.get("cursor").and_then(|c| p.path(c, "query.cursor"));
if o.contains_key("cursor") && !o.contains_key("items") {
p.add(
"query.cursor",
"a cursor pages items: name query.items too, or no cursor",
);
}
let latest = o.get("latest").and_then(|l| p.path(l, "query.latest"));
if o.contains_key("latest") && !o.contains_key("items") {
p.add(
"query.latest",
"the path to each item's key: name query.items too, or no latest",
);
}
let queries = match o.get("join") {
Some(j) => joins(p, j, "query.join", 1, Some((QUERY_SCOPE, false))).1,
None => Vec::new(),
};
let summary = o
.get("summary")
.and_then(|s| summary(p, s, "query.summary", true));
if let Some(h) = o.get("head") {
head(p, h, "query.head");
}
layout(p, o.get("layout"), at);
let fresh = p.flag(o.get("fresh"), "query.fresh");
Some(QueryMode {
items,
cursor,
latest,
summary,
queries,
fresh,
})
}
/// Check a mode's layout, and its size.
fn layout(p: &mut Problems, v: Option<&Value>, at: &str) {
match v {
Some(l) => {
let mut nodes = 0;
node(p, l, &format!("{at}.layout"), 1, &mut nodes);
// A Compose for another names one drawn in its scope.
for (path, label, form) in crate::ui::fors(l) {
if form.is_none() {
let path: String = path.iter().map(|i| format!(".children[{i}]")).collect();
p.add(
&format!("{at}.layout{path}.props.for"),
format_args!("no Compose labelled \"{label}\" is drawn in its scope"),
);
}
}
if nodes > MAX_NODES {
p.add(
&format!("{at}.layout"),
format_args!("{nodes} nodes, more than {MAX_NODES}"),
);
}
}
None => p.add(at, "layout required"),
}
}
/// A view's origins: `https://host[:port]` each, written as the URL
/// standard serializes it (lower case, no default port, at most a trailing
/// `/`). A bundled view may name any; a view given inline only those a
/// bundled view names, which every page that draws a view lets it load
/// already (`csp_origins`), so its CSP is never wider.
fn origins(p: &mut Problems, v: &Value, trusted: bool) -> Vec<String> {
let Some(a) = v
.as_array()
.filter(|a| (1..=MAX_ORIGINS).contains(&a.len()))
else {
p.add(
"view.origins",
format_args!("must be 1 to {MAX_ORIGINS} origins, as https://host[:port]"),
);
return Vec::new();
};
let mut out = Vec::new();
for (i, o) in a.iter().enumerate() {
let at = format!("view.origins[{i}]");
match o.as_str().and_then(origin) {
Some(o) if !trusted && !bundled_origins().contains(&o) => p.add(
&at,
format_args!(
"a view given inline names only origins a bundled view names: {}",
bundled_origins().join(", ")
),
),
Some(o) => out.push(o),
None => p.add(&at, "must be an origin, as https://host[:port]"),
}
}
out
}
/// Every origin the trusted views name (the bundled and the operator's), sorted, each once.
fn bundled_origins() -> &'static [String] {
static ALL: LazyLock<Vec<String>> = LazyLock::new(|| {
let mut all: Vec<String> = bundled()
.iter()
.flat_map(|b| b.view.origins.iter().cloned())
.collect();
all.sort();
all.dedup();
all
});
&ALL
}
/// An origin written as `https://host[:port]` and nothing more.
pub fn origin(s: &str) -> Option<String> {
let u = url::Url::parse(s).ok()?;
let origin = u.origin().ascii_serialization();
(u.scheme() == "https" && s.strip_suffix('/').unwrap_or(s) == origin).then_some(origin)
}
/// A trusted view's thumbnails: `{ from, to }` each, two https URL
/// prefixes on its origins, each ending in `/`: a picture the view draws
/// small (an avatar) whose URL starts with `from` is loaded from `to`
/// instead, with the rest of its URL, as a CDN serves a smaller size there.
fn thumbnails(p: &mut Problems, v: &Value, origins: &[String]) {
let Some(a) = v
.as_array()
.filter(|a| (1..=MAX_THUMBNAILS).contains(&a.len()))
else {
p.add(
"view.thumbnails",
format_args!("must be 1 to {MAX_THUMBNAILS} rules, as {{ from, to }}"),
);
return;
};
for (i, rule) in a.iter().enumerate() {
let at = format!("view.thumbnails[{i}]");
let Some(o) = p.object(rule, &at, &["from", "to"]) else {
continue;
};
for k in ["from", "to"] {
let prefix = o.get(k).and_then(Value::as_str).and_then(|s| {
let u = url::Url::parse(s).ok()?;
(u.scheme() == "https"
&& u.as_str() == s
&& s.ends_with('/')
&& u.query().is_none()
&& origins.contains(&u.origin().ascii_serialization()))
.then_some(s)
});
if prefix.is_none() {
p.add(
&format!("{at}.{k}"),
"must be an https URL ending in / on one of the view's origins",
);
}
}
}
}
fn parse_mode(p: &mut Problems, v: &Value, at: &str) -> Option<Mode> {
let o = p.object(v, at, &["join", "summary", "head", "layout"])?;
let keys = if at == "list" {
LIST_SCOPE
} else {
RECORD_SCOPE
};
let (join, queries) = match o.get("join") {
Some(j) => joins(p, j, &format!("{at}.join"), 1, Some((keys, true))),
None => (Vec::new(), Vec::new()),
};
let summary = o
.get("summary")
.and_then(|s| summary(p, s, &format!("{at}.summary"), false));
if let Some(h) = o.get("head") {
head(p, h, &format!("{at}.head"));
}
layout(p, o.get("layout"), at);
Some(Mode {
join,
queries,
summary,
})
}
/// A join array: record joins and, at a mode's top level (`top`: the keys
/// of the main scope its query joins read, and whether record joins go
/// there too, as in a records mode), query joins.
fn joins(
p: &mut Problems,
v: &Value,
at: &str,
depth: usize,
top: Option<(&[&str], bool)>,
) -> (Vec<Join>, Vec<QueryJoin>) {
let Some(a) = v.as_array() else {
p.add(at, "must be an array of joins");
return (Vec::new(), Vec::new());
};
if depth > MAX_JOIN_DEPTH {
p.add(at, format_args!("joins nest at most {MAX_JOIN_DEPTH} deep"));
return (Vec::new(), Vec::new());
}
if a.len() > MAX_JOINS {
p.add(at, format_args!("{} joins, more than {MAX_JOINS}", a.len()));
}
let mut out: Vec<Join> = Vec::new();
let mut queries: Vec<QueryJoin> = Vec::new();
let mut names: Vec<String> = Vec::new();
for (i, j) in a.iter().enumerate() {
let at = format!("{at}[{i}]");
let is_query = j.as_object().is_some_and(|o| o.contains_key("query"));
let name = match (is_query, top) {
(true, Some((keys, records))) => query_join(p, j, &at, keys, records).map(|q| {
let name = q.name.clone();
queries.push(q);
name
}),
(true, None) => {
p.add(
&at,
"a query join runs once on the whole answer, at a mode's top level: it never nests in a join",
);
None
}
(false, Some((_, false))) => {
p.add(
&at,
"a query view's joins are query joins: { as, query, params?, service?, say? }",
);
None
}
(false, _) => join(p, j, &at, depth).map(|j| {
let name = j.name.clone();
out.push(j);
name
}),
};
if let Some(name) = name {
if names.contains(&name) {
p.add(
&format!("{at}.as"),
format_args!("\"{name}\" is used twice"),
);
}
names.push(name);
}
}
if queries.len() > MAX_QUERY_JOINS {
p.add(
at,
format_args!("{} query joins, more than {MAX_QUERY_JOINS}", queries.len()),
);
}
(out, queries)
}
/// A query join: `{ as, query, params?, service?, say? }`, its params each
/// literal JSON (a string, number or boolean, or an array of them), a
/// binding or `{"$root": path}` into the main scope's `keys`, never a
/// join's result.
fn query_join(
p: &mut Problems,
v: &Value,
at: &str,
keys: &[&str],
records: bool,
) -> Option<QueryJoin> {
let o = p.object(
v,
at,
&[
"as", "query", "params", "service", "say", "when", "unless", "fresh",
],
)?;
let name = match o.get("as").and_then(Value::as_str) {
Some(s) if Path::parse(s).is_some_and(|p| p.0.len() == 1) => Some(s.to_string()),
_ => {
p.add(&format!("{at}.as"), "must be a key, [A-Za-z0-9_$]+");
None
}
};
let method = p.nsid(o.get("query"), &format!("{at}.query"));
let pat = format!("{at}.params");
let mut params = Vec::new();
match o.get("params") {
None => {}
Some(Value::Object(given)) => {
if given.len() > MAX_OPEN_PARAMS {
p.add(
&pat,
format_args!("{} params, more than {MAX_OPEN_PARAMS}", given.len()),
);
}
for (k, v) in given {
let kat = format!("{pat}.{k}");
let named = (1..=64).contains(&k.len())
&& k.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_');
if !named {
p.add(&kat, "a param's name is [A-Za-z0-9_]+");
}
if let Some(param) = query_param(p, v, &kat, keys) {
params.push((k.clone(), param));
}
}
}
Some(_) => p.add(&pat, "must be an object of params"),
}
let service = match o.get("service") {
None => None,
Some(s) => match s.as_str().map(crate::xrpc::Service::parse) {
Some(Ok(s)) => Some(s.name()),
_ => {
p.add(
&format!("{at}.service"),
"must be a DID with its service's #fragment, as did:web:api.bsky.app#bsky_appview",
);
None
}
},
};
// A query view's joins call its own service by default; a records
// view has none, so its method's trusted view's.
if records
&& !o.contains_key("service")
&& let Some(m) = &method
&& service_in(p.4, m).is_none()
{
p.add(
&format!("{at}.service"),
format_args!("required: no bundled view of {m} names its service"),
);
}
let say = o.get("say").and_then(|s| say(p, s, &format!("{at}.say")));
let gate = |p: &mut Problems, key: &str| {
let w = o.get(key)?;
let wat = format!("{at}.{key}");
let path = p.path(w, &wat);
if let Some(path) = &path
&& !path.0.first().is_some_and(|k| keys.contains(&k.as_str()))
{
p.add(
&wat,
format_args!("a path in the main scope: from {}", keys.join(", ")),
);
}
path
};
let when = gate(p, "when");
let unless = gate(p, "unless");
let fresh = p.flag(o.get("fresh"), &format!("{at}.fresh"));
Some(QueryJoin {
name: name?,
at: at.to_string(),
method: method?,
service,
params,
say,
when,
unless,
fresh,
})
}
/// The most elements a query join's array param holds: a literal, or an `$each`'s.
pub(crate) const MAX_PARAM_ARRAY: usize = 50;
/// A query join's param: a binding or `{"$root": path}`, each path into the
/// main scope's `keys` and through no `joins`; `{"$each": [array, path]}`,
/// the value at `path` in each element of `array` there; else a literal
/// string, number or boolean, or an array of them.
fn query_param(p: &mut Problems, v: &Value, at: &str, keys: &[&str]) -> Option<Param> {
// A path the main scope has: through no join's result.
let main = |p: &mut Problems, path: &Path| {
let first = path.0.first().map(String::as_str);
if path.0.iter().any(|k| k == "joins") {
p.add(
at,
"a query join reads the main answer, never a join's result",
);
false
} else if !first.is_some_and(|k| keys.contains(&k)) {
p.add(
at,
format_args!(
"a query join's params read the main scope: a path from {}",
keys.join(", ")
),
);
false
} else {
true
}
};
if let Some(each) = v.as_object().and_then(|o| o.get("$each")) {
let pair = v.as_object().filter(|o| o.len() == 1).and(each.as_array());
let Some([array, path]) = pair.map(Vec::as_slice) else {
p.add(
at,
"$each is [array, path] alone: the path within each element of the array",
);
return None;
};
let each = p.path(array, &format!("{at}.$each[0]"))?;
let item = p.path(path, &format!("{at}.$each[1]"))?;
return main(p, &each).then_some(Param::Each { each, at: item });
}
let binding = match (p.binding(v, at), root(v)) {
(Some(b), _) => Some(b?),
(None, Some(r)) => {
if v.as_object().is_some_and(|o| o.len() != 1) {
p.add(at, "a root binding has the key \"$root\" alone");
return None;
}
Some(Binding(vec![p.path(r, &format!("{at}.$root"))?]))
}
(None, None) => None,
};
if let Some(b) = binding {
let mut ok = true;
for path in &b.0 {
ok &= main(p, path);
}
return ok.then_some(Param::Bound(b));
}
let scalar = |v: &Value| matches!(v, Value::String(_) | Value::Number(_) | Value::Bool(_));
let ok = match v {
Value::Array(items) => items.len() <= MAX_PARAM_ARRAY && items.iter().all(scalar),
v => scalar(v),
};
if !ok {
p.add(
at,
format_args!(
"must be a string, number or boolean (or an array of at most {MAX_PARAM_ARRAY} of them), a binding {{\"$\": path}} or {{\"$root\": path}}"
),
);
return None;
}
Some(Param::Literal(v.clone()))
}
/// A query join's `say`: `{ noun: [singular, plural], count: path }` or
/// `{ noun, label: path }`, its path into the join's answer.
fn say(p: &mut Problems, v: &Value, at: &str) -> Option<Say> {
let o = p.object(v, at, &["noun", "count", "label"])?;
let noun = p.nouns(o.get("noun"), &format!("{at}.noun"));
if o.contains_key("count") == o.contains_key("label") {
p.add(at, "takes exactly one of count or label");
return None;
}
let count = o
.get("count")
.and_then(|c| p.path(c, &format!("{at}.count")));
let label = o
.get("label")
.and_then(|l| p.path(l, &format!("{at}.label")));
if count.is_none() && label.is_none() {
return None;
}
Some(Say {
noun: noun?,
count,
label,
})
}
/// The problems a query join's params have against its method's lexicon
/// (`docs`, its own among them, as `Hud::lexicon_docs` gathers them): a
/// method that is no query, params it does not take, required ones not
/// given, and literal values it refuses. What a binding gives is checked
/// when the join runs.
pub fn query_join_problems(j: &QueryJoin, docs: &[std::sync::Arc<Value>]) -> Vec<String> {
let at = &j.at;
let method = j.method.as_str();
let Some(doc) = docs.iter().find(|d| d["id"] == method) else {
return vec![format!("{at}.query: no lexicon for {method}")];
};
let def = match crate::xrpc::query_def(method, doc) {
Ok(def) => def,
Err(why) => return vec![format!("{at}.query: {why}")],
};
let taken = def["parameters"]["properties"].as_object();
let mut out: Vec<String> = j
.params
.iter()
.filter(|(k, _)| taken.is_none_or(|t| !t.contains_key(k)))
.map(|(k, _)| format!("{at}.params.{k}: not a parameter of {method}"))
.collect();
for k in def["parameters"]["required"]
.as_array()
.into_iter()
.flatten()
.filter_map(Value::as_str)
{
if !j.params.iter().any(|(n, _)| n == k) {
out.push(format!("{at}.params.{k}: {method} requires it"));
}
}
// The literals alone, checked as if nothing were required: a bound
// param is had only when the join runs.
let literals: Map<String, Value> = j
.params
.iter()
.filter_map(|(k, v)| match v {
Param::Literal(v) => Some((k.clone(), v.clone())),
Param::Bound(_) | Param::Each { .. } => None,
})
.collect();
let docs: Vec<std::sync::Arc<Value>> = docs
.iter()
.map(|d| {
if d["id"] != method {
return d.clone();
}
let mut d = (**d).clone();
if let Some(params) = d["defs"]["main"]["parameters"].as_object_mut() {
params.remove("required");
}
std::sync::Arc::new(d)
})
.collect();
let lexicons = crate::xrpc::lexicons_for(method, &docs);
if let Err(e) = lexicons.validate_params(method, &literals) {
out.push(format!("{at}.{e}"));
}
out
}
fn join(p: &mut Problems, v: &Value, at: &str, depth: usize) -> Option<Join> {
let o = p.object(
v,
at,
&[
"as",
"ref",
"each",
"backlinks",
"counts",
"collection",
"orderBy",
"limit",
"join",
],
)?;
let name = match o.get("as").and_then(Value::as_str) {
Some(s) if Path::parse(s).is_some_and(|p| p.0.len() == 1) => Some(s.to_string()),
_ => {
p.add(&format!("{at}.as"), "must be a key, [A-Za-z0-9_$]+");
None
}
};
if let Some(c) = o.get("counts") {
for k in o.keys().filter(|k| !matches!(k.as_str(), "as" | "counts")) {
p.add(
&format!("{at}.{k}"),
"a counts join takes \"as\" and \"counts\" alone",
);
}
let counted = counts(p, c, &format!("{at}.counts"));
return Some(Join {
name: name?,
source: Source::Counts(counted?),
collection: None,
order_by: Vec::new(),
limit: JOIN_LIMIT,
join: Vec::new(),
});
}
let path = |p: &mut Problems, k: &str| o.get(k).and_then(|v| p.path(v, &format!("{at}.{k}")));
let source = match (o.get("ref"), o.get("each"), o.get("backlinks")) {
(_, _, Some(b)) => {
if o.contains_key("ref") || o.contains_key("each") {
p.add(at, "backlinks takes no \"ref\" or \"each\"");
}
if o.contains_key("collection") {
p.add(
&format!("{at}.collection"),
"backlinks names its collection in backlinks.collection",
);
}
let bat = format!("{at}.backlinks");
p.object(b, &bat, &["collection", "path"]).and_then(|b| {
let collection = p.nsid(b.get("collection"), &format!("{bat}.collection"));
let path = match b.get("path") {
Some(v) => p.path(v, &format!("{bat}.path")),
None => {
p.add(&format!("{bat}.path"), "required");
None
}
};
Some(Source::Backlinks {
collection: collection?,
path: path?,
})
})
}
(Some(_), Some(_), None) => Some(Source::Each {
each: path(p, "each")?,
at: path(p, "ref")?,
}),
(Some(_), None, None) => path(p, "ref").map(Source::Ref),
(None, Some(_), None) => {
p.add(at, "\"each\" needs \"ref\", the path within each element");
None
}
(None, None, None) => {
p.add(at, "\"ref\", \"backlinks\" or \"counts\" required");
None
}
};
let collection = o
.get("collection")
.filter(|_| !o.contains_key("backlinks"))
.and_then(|c| p.nsid(Some(c), &format!("{at}.collection")));
let backlinks = matches!(source, Some(Source::Backlinks { .. }));
let single = matches!(source, Some(Source::Ref(_)));
let order_by = match o.get("orderBy") {
None => Vec::new(),
Some(_) if !backlinks => {
p.add(&format!("{at}.orderBy"), "only backlinks are ordered");
Vec::new()
}
Some(Value::Array(a)) if a.len() <= MAX_ORDER_BY => a
.iter()
.enumerate()
.filter_map(|(i, k)| p.path(k, &format!("{at}.orderBy[{i}]")))
.collect(),
Some(_) => {
p.add(
&format!("{at}.orderBy"),
format_args!("must be at most {MAX_ORDER_BY} paths"),
);
Vec::new()
}
};
let limit = match o.get("limit") {
None => JOIN_LIMIT,
Some(_) if single => {
p.add(
&format!("{at}.limit"),
"a ref joins one record; limit is for each and backlinks",
);
JOIN_LIMIT
}
Some(v) => p
.int(v, &format!("{at}.limit"), JOIN_LIMIT_MAX as u64)
.map_or(JOIN_LIMIT, |n| n as usize),
};
let nested = match o.get("join") {
Some(j) => joins(p, j, &format!("{at}.join"), depth + 1, None).0,
None => Vec::new(),
};
Some(Join {
name: name?,
source: source?,
collection,
order_by,
limit,
join: nested,
})
}
/// A counts join's names: 1 to 8, each `[A-Za-z0-9_]+`, counting records
/// of a collection whose field at a path (as the index writes it, from
/// `.`) names the record.
fn counts(p: &mut Problems, v: &Value, at: &str) -> Option<Vec<(String, String, String)>> {
let Some(o) = v.as_object() else {
p.add(at, "must be an object of names to { collection, path }");
return None;
};
if !(1..=MAX_COUNTS).contains(&o.len()) {
p.add(at, format_args!("must name 1 to {MAX_COUNTS} counts"));
}
let mut out = Some(Vec::new());
for (name, c) in o {
let cat = format!("{at}.{name}");
let named = (1..=64).contains(&name.len())
&& name.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_');
if !named {
p.add(&cat, "a count's name is [A-Za-z0-9_]+");
}
let Some(c) = p.object(c, &cat, &["collection", "path"]) else {
out = None;
continue;
};
let collection = p.nsid(c.get("collection"), &format!("{cat}.collection"));
let path = c
.get("path")
.and_then(Value::as_str)
.filter(|s| is_index_path(s));
if path.is_none() {
p.add(
&format!("{cat}.path"),
"must be a field's path as the index writes it, starting with \".\", as \".subject.uri\"",
);
}
match (named, collection, path, &mut out) {
(true, Some(collection), Some(path), Some(v)) => {
v.push((name.clone(), collection, path.to_string()))
}
_ => out = None,
}
}
out
}
/// A path as a backlink index writes it: `.`, then keys (and its own
/// markers for arrays and union types), as `.subject.uri`.
fn is_index_path(s: &str) -> bool {
s.len() > 1
&& s.len() <= 256
&& s.starts_with('.')
&& s.bytes()
.all(|b| b.is_ascii_alphanumeric() || b"._$#[]-".contains(&b))
}
/// What a mode's `head` may say.
pub(crate) const HEAD: [&str; 8] = [
"title",
"description",
"image",
"imageAlt",
"type",
"canonical",
"noindex",
"jsonLd",
];
/// The kinds of page a head's `type` names, as Open Graph names them.
const HEAD_TYPES: [&str; 3] = ["website", "article", "profile"];
/// A mode's `head`: what a page showing it says of itself to search
/// engines and link previews (`ui::head`). Its text, image, canonical
/// path and noindex are templates, as an action's record is; its type a
/// word of `HEAD_TYPES`; its jsonLd an object of templates (`structured`).
fn head(p: &mut Problems, v: &Value, at: &str) {
let Some(o) = p.object(v, at, &HEAD) else {
return;
};
for (k, x) in o.iter().filter(|(k, _)| HEAD.contains(&k.as_str())) {
let kat = format!("{at}.{k}");
match k.as_str() {
"type" if !x.as_str().is_some_and(|t| HEAD_TYPES.contains(&t)) => {
p.add(&kat, "must be website, article or profile");
}
"type" => {}
"jsonLd" if !x.is_object() => p.add(&kat, "must be an object"),
"jsonLd" => structured(p, x, &kat, 1),
_ => record_value(p, x, &kat, 1, None),
}
}
}
/// A head's structured data: an object or array of templates, keys as
/// schema.org's (`@type`), where `{"$each": [array, template]}` is the
/// template read against each element of the array.
fn structured(p: &mut Problems, v: &Value, at: &str, depth: usize) {
if depth > MAX_DEPTH {
p.add(
at,
format_args!("structured data nests at most {MAX_DEPTH} deep"),
);
return;
}
match v {
Value::Object(o) if o.contains_key("$each") => match o["$each"].as_array() {
Some(a) if o.len() == 1 && a.len() == 2 => {
record_value(p, &a[0], &format!("{at}.$each[0]"), depth + 1, None);
structured(p, &a[1], &format!("{at}.$each[1]"), depth + 1);
}
_ => p.add(
at,
"{\"$each\": [array, template]} has the key $each alone, an array and a template",
),
},
Value::Object(o) if o.keys().any(|k| k.starts_with('$')) => {
record_value(p, v, at, depth, None);
}
Value::Object(o) => {
for (k, c) in o {
structured(p, c, &format!("{at}.{k}"), depth + 1);
}
}
Value::Array(a) => {
for (i, c) in a.iter().enumerate() {
structured(p, c, &format!("{at}[{i}]"), depth + 1);
}
}
_ => {}
}
}
/// A summary; `by` only in a query mode's, where an answer may be one
/// thing with its own author.
fn summary(p: &mut Problems, v: &Value, at: &str, query: bool) -> Option<Summary> {
let o = p.object(v, at, &["noun", "label", "by", "detail"])?;
let noun = p.nouns(o.get("noun"), &format!("{at}.noun"));
let label = o
.get("label")
.and_then(|l| p.prop(l, &format!("{at}.label"), Value::is_string, "a string"));
let by = match o.get("by") {
Some(_) if !query => {
p.add(
&format!("{at}.by"),
"only a query mode's summary names who by; a record's is its repository's",
);
None
}
Some(b) => p.prop(b, &format!("{at}.by"), Value::is_string, "a string"),
None => None,
};
let detail = o.get("detail").and_then(|d| {
let dat = format!("{at}.detail");
let d = p.object(d, &dat, &["count", "noun", "children"])?;
let count = match d.get("count") {
Some(c) => p.prop(c, &format!("{dat}.count"), Value::is_u64, "an integer"),
None => {
p.add(&format!("{dat}.count"), "required");
None
}
};
let noun = p.nouns(d.get("noun"), &format!("{dat}.noun"));
let children = match d.get("children") {
Some(c) => Some(p.path(c, &format!("{dat}.children"))?),
None => None,
};
Some((count?, noun?, children))
});
Some(Summary {
noun: noun?,
label,
by,
detail,
})
}
/// Check a layout node, its props against the catalog, its children, and
/// its fallback, a node a kit that doesn't know its component draws.
fn node(p: &mut Problems, v: &Value, at: &str, depth: usize, nodes: &mut usize) {
*nodes += 1;
if depth > MAX_DEPTH {
p.add(at, format_args!("layouts nest at most {MAX_DEPTH} deep"));
return;
}
let Some(o) = p.object(v, at, &["component", "props", "children", "fallback"]) else {
return;
};
if let Some(fallback) = o.get("fallback") {
node(p, fallback, &format!("{at}.fallback"), depth + 1, nodes);
}
let Some(name) = o.get("component").and_then(Value::as_str) else {
p.add(&format!("{at}.component"), "required: a component's name");
return;
};
let Some(c) = catalog::component(name) else {
p.add(
&format!("{at}.component"),
format_args!("unknown component \"{name}\""),
);
return;
};
// A conversation pages at its top, as the layout's own: never inside
// another node.
if name == "Messages" && depth != 1 {
p.add(
&format!("{at}.component"),
"Messages is a layout's top node alone",
);
}
// The host's accounts are the host's to draw, where a bundled view asks.
if name == "Accounts" && !p.1 {
p.add(
&format!("{at}.component"),
"only a bundled view asks the host",
);
}
let empty = Map::new();
let props = match o.get("props") {
None => &empty,
Some(Value::Object(props)) => props,
Some(_) => {
p.add(&format!("{at}.props"), "must be an object");
&empty
}
};
for (k, v) in props {
let pat = format!("{at}.props.{k}");
match c.props.iter().find(|d| d.name == k) {
Some(d) => prop(p, v, &pat, d.ty, d.given),
None => p.add(&pat, format_args!("{name} has no prop \"{k}\"")),
}
}
for d in c.props.iter().filter(|d| d.required) {
if !props.contains_key(d.name) {
p.add(
&format!("{at}.props.{}", d.name),
format_args!("{name} requires it"),
);
}
}
// A composer's writes read its fields' and given values' names alone.
if name == "Compose" {
let (_, mut names) =
crate::compose::fields_problems(&props.get("fields").cloned().unwrap_or_default(), "");
names.extend(
props
.get("given")
.and_then(Value::as_object)
.into_iter()
.flatten()
.map(|(k, _)| k.clone()),
);
if props.contains_key("writes") {
for problem in crate::compose::problems(
&props.get("writes").cloned().unwrap_or_default(),
Some(&names),
) {
p.add(&format!("{at}.props"), problem);
}
}
// A text's or line's limit: its record's lexicon's, narrowed by max.
for problem in crate::compose::limit_problems(
props.get("fields").unwrap_or(&Value::Null),
props.get("writes").unwrap_or(&Value::Null),
) {
p.add(&format!("{at}.props"), problem);
}
// One for another takes that one's form; the rest ask their own.
if props.contains_key("for") {
for k in [
"fields", "given", "count", "closed", "icon", "title", "about", "send", "form",
] {
if props.contains_key(k) {
p.add(
&format!("{at}.props.{k}"),
"a Compose for another takes that one's",
);
}
}
} else if !props.contains_key("fields") {
p.add(&format!("{at}.props.fields"), "Compose requires it");
}
}
// A photo's review draws its first field, its one photo, full-bleed.
if name == "Compose"
&& props.contains_key("form")
&& !props
.get("fields")
.and_then(|f| f.get(0))
.is_some_and(|f| f["kind"] == "photos" && f["max"] == 1)
{
p.add(
&format!("{at}.props.form"),
"photo: its first field is photos of max 1",
);
}
// A choice's default is one of its options' values.
if name == "Choice"
&& let Some(d) = props.get("default")
&& !props
.get("options")
.and_then(Value::as_array)
.is_some_and(|a| a.iter().any(|o| o["value"] == *d))
{
p.add(
&format!("{at}.props.default"),
"must be one of its options' values",
);
}
// A split is two sides.
if name == "Split" && o.get("children").and_then(Value::as_array).map(Vec::len) != Some(2) {
p.add(&format!("{at}.children"), "Split takes two children");
}
// A map's pins are somewhere: at a cell, or at lat and lng.
if name == "Map"
&& !props.contains_key("cell")
&& !(props.contains_key("lat") && props.contains_key("lng"))
{
p.add(&format!("{at}.props"), "Map takes cell, or lat and lng");
}
let one = catalog::exclusive(name);
if !one.is_empty() && one.iter().filter(|k| props.contains_key(**k)).count() != 1 {
p.add(
&format!("{at}.props"),
format_args!("{name} takes exactly one of {}", one.join(", ")),
);
}
match o.get("children") {
None => {}
Some(_) if !c.children => {
p.add(
&format!("{at}.children"),
format_args!("{name} takes no children"),
);
}
Some(Value::Array(children)) => {
for (i, child) in children.iter().enumerate() {
node(p, child, &format!("{at}.children[{i}]"), depth + 1, nodes);
}
}
Some(_) => p.add(&format!("{at}.children"), "must be an array of nodes"),
}
}
/// Check a prop's value against its catalog entry.
fn prop(p: &mut Problems, v: &Value, at: &str, ty: Ty, given: Given) {
if given == Given::EitherOrRoot && root(v).is_some() {
p.root(v, at);
return;
}
match p.binding(v, at) {
Some(_) if given == Given::Literal => {
p.add(at, "must be a literal value, not a binding");
}
Some(_) => {}
None if given == Given::Binding => {
p.add(at, "must be a binding {\"$\": path}");
}
None => {
if let Err(why) = ty.check_literal(v) {
p.add(at, why);
return;
}
// The catalog's check has made a Create, Delete, Interaction or
// Call an object.
match (ty, v) {
// An array of strings may hold bindings among its literals.
(Ty::Strings, _) => {
for (i, item) in v.as_array().into_iter().flatten().enumerate() {
let iat = format!("{at}[{i}]");
if p.binding(item, &iat).is_none() && !item.is_string() {
p.add(&iat, "must be a string or a binding");
}
}
}
(Ty::Path, _) | (Ty::Gate, Value::String(_)) => {
p.path(v, at);
}
// false: the item opens nothing.
(Ty::Open, Value::Bool(_)) => {}
(Ty::Open, Value::Object(o)) if o.contains_key("url") || o.contains_key("host") => {
open_elsewhere(p, o, at)
}
(Ty::Open, _) => open_query(p, v, at),
(Ty::Where, _) => {
for (k, path) in v.as_object().into_iter().flatten() {
let kat = format!("{at}.{k}");
if Path::parse(k).is_none() {
p.add(&kat, "a key is a path within each element");
}
let (path, _) = catalog::negated(path);
if !catalog::is_literal(path) {
p.path(path, &kat);
}
}
}
(Ty::Create, Value::Object(o)) => action_create(p, o, at),
(Ty::Fields, _) => {
for problem in crate::compose::fields_problems(v, at).0 {
p.0.push(problem);
}
// What a field opens holding: a binding's paths.
for (i, f) in v.as_array().into_iter().flatten().enumerate() {
p.binding(&f["value"], &format!("{at}[{i}].value"));
}
}
(Ty::Given, _) => {
for (k, x) in v.as_object().into_iter().flatten() {
if !k.chars().next().is_some_and(|c| c.is_ascii_lowercase())
|| !k.chars().all(|c| c.is_ascii_alphanumeric())
{
p.add(&format!("{at}.{k}"), "a name, lowercase letters and digits");
}
record_value(p, x, &format!("{at}.{k}"), 1, None);
}
}
// Checked with its fields' names (`node`).
(Ty::Writes, _) => {}
(Ty::Delete, Value::Object(o)) => action_delete(p, o, at),
(Ty::Interaction, Value::Object(o)) => action_interaction(p, o, at),
(Ty::Items, _) => literal_items(p, v, at),
(Ty::Row, _) => literal_row(p, v, at),
(Ty::Tabs, _) => tabs(p, v, at),
(Ty::More, Value::Object(o)) => tab(p, o, at, "chip"),
(Ty::Cases, _) => cases(p, v, at),
(Ty::Call { fill }, Value::Object(o)) => call_to(p, o, at, fill),
(Ty::Deletes, Value::Object(o)) => deletes_to(p, o, at),
(Ty::Select, Value::Object(o)) => select_to(p, o, at),
_ => {}
}
}
}
}
/// A List's literal items: each element one `literal_row`.
fn literal_items(p: &mut Problems, v: &Value, at: &str) {
for (i, element) in v.as_array().into_iter().flatten().enumerate() {
literal_row(p, element, &format!("{at}[{i}]"));
}
}
/// One literal item (a List's literal items' each, its `first`): its `open`
/// an `Open`, its other values literal JSON or `{"$root": path}` at any depth.
fn literal_row(p: &mut Problems, element: &Value, at: &str) {
for (k, x) in element.as_object().into_iter().flatten() {
let kat = format!("{at}.{k}");
if k == "open" {
prop(p, x, &kat, Ty::Open, Given::Either);
} else {
literal_value(p, x, &kat);
}
}
}
/// A value in a literal item: `{"$root": path}`, or literal JSON whose
/// objects name no key starting with `$` but `$type`.
fn literal_value(p: &mut Problems, v: &Value, at: &str) {
if root(v).is_some() {
p.root(v, at);
return;
}
match v {
Value::Object(o) => {
if o.keys().any(|k| k.starts_with('$') && k != "$type") {
p.add(
at,
"a literal item's value is literal JSON or {\"$root\": path}",
);
return;
}
for (k, x) in o {
literal_value(p, x, &format!("{at}.{k}"));
}
}
Value::Array(a) => {
for (i, x) in a.iter().enumerate() {
literal_value(p, x, &format!("{at}[{i}]"));
}
}
_ => {}
}
}
/// Tabs: each `{ label, open }`, label one short line and open an `Open`
/// that opens something; each an object, as the catalog's check made it.
fn tabs(p: &mut Problems, v: &Value, at: &str) {
let tabs = v.as_array().into_iter().flatten();
for (i, o) in tabs.filter_map(Value::as_object).enumerate() {
tab(p, o, &format!("{at}[{i}]"), "tab");
}
}
/// One `{ label, open }` (a tab, a List's `more` chip): label one short
/// line and open an `Open` that names a query.
fn tab(p: &mut Problems, o: &Map<String, Value>, at: &str, what: &str) {
p.keys(o, at, &["label", "open"]);
p.line(o.get("label"), &format!("{at}.label"), 40);
let oat = format!("{at}.open");
match o.get("open") {
None | Some(Value::Bool(_)) => p.add(
&oat,
format!("required: what the {what} opens, as List's open"),
),
Some(open) if open.get("url").or_else(|| open.get("host")).is_some() => p.add(
&oat,
format!("a {what} opens a query, not a page or the host's own"),
),
Some(open) => prop(p, open, &oat, Ty::Open, Given::Either),
}
}
/// Opens by case: each `{ where?, open }`, where a `Where` and open an
/// `Open`; each an object, as the catalog's check made it.
fn cases(p: &mut Problems, v: &Value, at: &str) {
let cases = v.as_array().into_iter().flatten();
for (i, o) in cases.filter_map(Value::as_object).enumerate() {
let cat = format!("{at}[{i}]");
p.keys(o, &cat, &["where", "open"]);
if let Some(w) = o.get("where") {
prop(p, w, &format!("{cat}.where"), Ty::Where, Given::Literal);
}
match o.get("open") {
Some(open) => prop(p, open, &format!("{cat}.open"), Ty::Open, Given::Literal),
None => p.add(&format!("{cat}.open"), "required: what the element opens"),
}
}
}
/// What the host does itself where an `open` asks it (`{"host": …}`): sign
/// the account out of the app, as an app's own Settings' Sign out.
pub const HOSTED: &[&str] = &["signOut"];
/// An `open` that opens no query: `{ url }`, an https page opened in the
/// host's browser (a site's page the app has no view of), or, in a bundled
/// view alone, `{ host }`, one of `HOSTED`, which the host does itself.
fn open_elsewhere(p: &mut Problems, o: &Map<String, Value>, at: &str) {
let one: &[&str] = if o.contains_key("url") {
&["url"]
} else {
&["host"]
};
p.keys(o, at, one);
if let Some(url) = o.get("url") {
let page = url
.as_str()
.and_then(|s| url::Url::parse(s).ok())
.is_some_and(|u| u.scheme() == "https" && u.host().is_some());
if !page {
p.add(&format!("{at}.url"), "must be an https URL");
}
}
let Some(host) = o.get("host") else {
return;
};
if !p.1 {
p.add(at, "only a bundled view asks the host");
} else if !host.as_str().is_some_and(|h| HOSTED.contains(&h)) {
p.add(
&format!("{at}.host"),
format_args!("must be one of {}", HOSTED.join(", ")),
);
}
}
/// An `open` that calls a query: `{ query, params?, service?, at?, sheet?,
/// compose?, unless? }`, the query an NSID, its params at most 8, each named
/// as a lexicon names one and a param value (`open_param`), the service as
/// the query tool's, `at` (what its view shows first) a param value too,
/// `sheet` (its screen over what is open) a flag, `compose` (the form its
/// screen opens at) true or a Compose's label, and `unless` a path in the
/// scope that, holding something, drops `compose`, so given only with it.
fn open_query(p: &mut Problems, v: &Value, at: &str) {
let keys = [
"query", "params", "service", "at", "sheet", "compose", "unless",
];
let Some(o) = p.object(v, at, &keys) else {
return;
};
if let Some(first) = o.get("at") {
open_param(p, first, &format!("{at}.at"), false);
}
if o.get("sheet").is_some_and(|s| !s.is_boolean()) {
p.add(&format!("{at}.sheet"), "must be true or false");
}
if o.get("compose").is_some_and(|f| !crate::ui::is_compose(f)) {
p.add(
&format!("{at}.compose"),
"must be true or a Compose's label, 1 to 64 characters",
);
}
if let Some(unless) = o.get("unless") {
let uat = format!("{at}.unless");
p.path(unless, &uat);
if !o.contains_key("compose") {
p.add(&uat, "is only for a compose");
}
}
p.nsid(o.get("query"), &format!("{at}.query"));
let pat = format!("{at}.params");
match o.get("params") {
None => {}
Some(Value::Object(params)) => {
if params.len() > MAX_OPEN_PARAMS {
p.add(
&pat,
format_args!("{} params, more than {MAX_OPEN_PARAMS}", params.len()),
);
}
for (k, v) in params {
let kat = format!("{pat}.{k}");
let named = (1..=64).contains(&k.len())
&& k.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_');
if !named {
p.add(&kat, "a param's name is [A-Za-z0-9_]+");
}
open_param(p, v, &kat, true);
}
}
Some(_) => p.add(&pat, "must be an object of params"),
}
if let Some(s) = o.get("service") {
let ok = s
.as_str()
.is_some_and(|s| crate::xrpc::Service::parse(s).is_ok());
if !ok {
p.add(
&format!("{at}.service"),
"must be a DID with its service's #fragment, as did:web:api.bsky.app#bsky_appview",
);
}
}
}
/// The value of `{"$root": …}`, if `v` is that.
fn root(v: &Value) -> Option<&Value> {
v.as_object()
.filter(|o| o.contains_key("$root"))
.map(|o| &o["$root"])
}
/// The most elements an open param's array holds.
const MAX_OPEN_ARRAY: usize = 50;
/// A param of an `open` query: a binding into the item, `{"$root": path}`
/// into the view's own scope, `{"$atUri": [authority, collection, rkey]}`,
/// each of the three a string or one of those bindings, or at the top an
/// array of any of those; anything else is a literal, as is, but an
/// object whose keys start with `$` is one of these or a mistake.
fn open_param(p: &mut Problems, v: &Value, at: &str, top: bool) {
if p.binding(v, at).is_some() {
return;
}
if root(v).is_some() {
p.root(v, at);
return;
}
match v {
Value::Object(o) if o.contains_key("$atUri") => {
if o.len() != 1 {
p.add(at, "an at-uri to build has the key \"$atUri\" alone");
return;
}
let aat = format!("{at}.$atUri");
match o["$atUri"].as_array() {
Some(parts) if parts.len() == 3 => {
for (i, part) in parts.iter().enumerate() {
let pat = format!("{aat}[{i}]");
if part.is_string() {
continue;
}
if p.binding(part, &pat).is_none() && root(part).is_none() {
p.add(&pat, "must be a string, a binding or {\"$root\": path}");
} else if root(part).is_some() {
p.root(part, &pat);
}
}
}
_ => p.add(&aat, "must be [authority, collection, rkey]"),
}
}
Value::Object(o) if o.contains_key("$after") => {
let args = o["$after"].as_array().filter(|a| o.len() == 1 && a.len() == 2);
match args {
Some(a) if a[1].as_str().is_some_and(|s| !s.is_empty()) => {
open_param(p, &a[0], &format!("{at}.$after[0]"), false)
}
_ => p.add(
at,
"{\"$after\": [value, prefix]} has the key $after alone, the prefix a string",
),
}
}
Value::Object(o) if o.keys().any(|k| k.starts_with('$')) => p.add(
at,
"an object with a key starting with $ is {\"$\": path}, {\"$root\": path}, {\"$atUri\": [authority, collection, rkey]} or {\"$after\": [value, prefix]}",
),
Value::Array(items) if top => {
if items.len() > MAX_OPEN_ARRAY {
p.add(at, format_args!("more than {MAX_OPEN_ARRAY} elements"));
}
for (i, item) in items.iter().enumerate() {
open_param(p, item, &format!("{at}[{i}]"), false);
}
}
Value::Array(_) => p.add(at, "an array of params holds no arrays"),
_ => {}
}
}
/// An action's `create`: `{ collection, record }`, the collection an NSID,
/// the record an object of at most 4 KiB whose values are checked by
/// `record_value`.
fn action_create(p: &mut Problems, o: &Map<String, Value>, at: &str) {
p.keys(o, at, &["collection", "record"]);
p.nsid(o.get("collection"), &format!("{at}.collection"));
let rat = format!("{at}.record");
match o.get("record") {
Some(r @ Value::Object(_)) if p.binding(r, &rat).is_none() => {
let size = serde_json::to_vec(r).map_or(usize::MAX, |b| b.len());
if size > ACTION_RECORD_MAX {
p.add(
&rat,
format_args!(
"{size} bytes, more than the {ACTION_RECORD_MAX} a record may take"
),
);
}
record_fields(p, r, &rat, 1, None);
}
Some(_) => p.add(&rat, "must be an object, the record"),
None => p.add(&rat, "required"),
}
}
/// An action's `interaction`: `{ event }`, asking the feed for more or
/// less like the item; a bundled view's alone.
fn action_interaction(p: &mut Problems, o: &Map<String, Value>, at: &str) {
if !p.1 {
p.add(at, "only a bundled view sends interactions");
return;
}
p.2 = true;
p.keys(o, at, &["event"]);
let ok = o
.get("event")
.and_then(Value::as_str)
.is_some_and(|e| crate::interactions::ASKED.contains(&e));
if !ok {
p.add(
&format!("{at}.event"),
format_args!("must be one of {}", crate::interactions::ASKED.join(", ")),
);
}
}
/// Covers' `select`: `{ label?, mine?, action, noun, confirm?, tone?, call
/// | deletes }`, its words short, `mine` a path in the scope, `noun` the
/// singular and plural, `tone` danger, and `call` a procedure as `call_to`
/// holds one, or `deletes` a deletion plan's query as `deletes_to` holds
/// one, its input or params read from each item picked.
fn select_to(p: &mut Problems, o: &Map<String, Value>, at: &str) {
p.keys(
o,
at,
&[
"label", "mine", "action", "noun", "confirm", "tone", "call", "deletes",
],
);
let words = |v: Option<&Value>, max: usize| {
v.and_then(Value::as_str).is_some_and(|s| {
(1..=max).contains(&s.chars().count()) && !s.contains(char::is_control)
})
};
for (k, max, needed) in [
("label", 40, false),
("action", 40, true),
("confirm", 300, false),
] {
if (needed || o.contains_key(k)) && !words(o.get(k), max) {
p.add(
&format!("{at}.{k}"),
format_args!("text of at most {max} characters"),
);
}
}
let noun = o.get("noun").and_then(Value::as_array);
if !noun.is_some_and(|n| n.len() == 2 && n.iter().all(|w| words(Some(w), 40))) {
p.add(&format!("{at}.noun"), "must be [singular, plural]");
}
if o.get("tone").is_some_and(|t| t != "danger") {
p.add(&format!("{at}.tone"), "must be danger");
}
if let Some(mine) = o.get("mine") {
p.path(mine, &format!("{at}.mine"));
}
match (o.get("call"), o.get("deletes")) {
(Some(Value::Object(c)), None) => call_to(p, c, &format!("{at}.call"), None),
(None, Some(Value::Object(d))) => deletes_to(p, d, &format!("{at}.deletes")),
_ => p.add(
at,
"takes one of call ({ method, service, input? }) and deletes ({ method, service, params? })",
),
}
}
/// A procedure a layout calls (`Action`'s `call`; `Messages`' `send`, the
/// box's text its `{"$text": true}`; a `Toggle`'s, its new state its
/// `{"$on": true}`): `{ method, service, input? }`, the method an NSID,
/// the service a DID with its service's #fragment, the input an object of
/// at most 4 KiB whose values `record_value` checks, holding `fill`, the
/// mark the person's own value takes, where there is one; a bundled view's
/// alone, kept for the server's list of the calls bundled views make.
fn call_to(p: &mut Problems, o: &Map<String, Value>, at: &str, fill: Option<&str>) {
called(p, o, at, fill, false);
}
/// The query whose deletion plan a layout deletes (`Action`'s and Covers'
/// select's `deletes`): `{ method, service, params?, repeat?, collections?,
/// then? }`, as `call_to` holds a call, its params the input; a bundled
/// view's alone, kept with its calls, marked as deleting, and what it says
/// beyond its query kept as its `Plan`: repeat true or false, collections
/// at most `PLAN_COLLECTIONS` NSIDs, and then `{ method, service, input?
/// }`, its input literal but `{"$did": true}`.
fn deletes_to(p: &mut Problems, o: &Map<String, Value>, at: &str) {
let before = p.3.len();
called(p, o, at, None, true);
if !p.1 {
return;
}
let repeat = match o.get("repeat") {
None => false,
Some(Value::Bool(b)) => *b,
Some(_) => {
p.add(&format!("{at}.repeat"), "must be true or false");
false
}
};
let mut collections = Vec::new();
match o.get("collections") {
None => {}
Some(Value::Array(a)) if a.len() <= PLAN_COLLECTIONS => {
for (i, c) in a.iter().enumerate() {
collections.extend(p.nsid(Some(c), &format!("{at}.collections[{i}]")));
}
}
Some(_) => p.add(
&format!("{at}.collections"),
format_args!("must be a list of at most {PLAN_COLLECTIONS} collections' NSIDs"),
),
}
let then = o
.get("then")
.and_then(|t| plan_then(p, t, &format!("{at}.then")));
if let Some(c) = p.3.get(before) {
let (method, service) = (c.method.clone(), c.service.clone());
p.5.push(Plan {
method,
service,
repeat,
collections,
then,
});
}
}
/// `call_to`'s and `deletes_to`'s checks: a call, or with `deletes` a
/// query whose plan is deleted, its template under `params`.
fn called(p: &mut Problems, o: &Map<String, Value>, at: &str, fill: Option<&str>, deletes: bool) {
let (key, what) = match deletes {
true => ("params", "the query's params"),
false => ("input", "the procedure's input"),
};
if !p.1 {
let why = match deletes {
true => "only a bundled view deletes what a query plans",
false => "only a bundled view calls procedures",
};
p.add(at, why);
return;
}
let keys: &[&str] = match deletes {
true => &[
"method",
"service",
"params",
"repeat",
"collections",
"then",
],
false => &["method", "service", "input"],
};
p.keys(o, at, keys);
let method = p.nsid(o.get("method"), &format!("{at}.method"));
let service = service_at(p, o, at);
let iat = format!("{at}.{key}");
let input = match o.get(key) {
None => Value::Object(Map::new()),
Some(i @ Value::Object(m)) if !m.contains_key("$") && root(i).is_none() => {
let size = serde_json::to_vec(i).map_or(usize::MAX, |b| b.len());
if size > ACTION_RECORD_MAX {
p.add(
&iat,
format_args!(
"{size} bytes, more than the {ACTION_RECORD_MAX} an input may take"
),
);
}
record_fields(p, i, &iat, 1, fill);
i.clone()
}
Some(_) => {
p.add(&iat, format_args!("must be an object, {what}"));
return;
}
};
if let Some(mark) = fill
&& !fills(&input, mark)
{
let what = if mark == "$text" { "writes" } else { "chooses" };
p.add(
&iat,
format_args!("holds no {{\"{mark}\": true}}, where what the person {what} goes"),
);
}
if let (Some(method), Some(service)) = (method, service) {
p.3.push(Call {
method,
service,
input,
deletes,
});
}
}
/// Whether a template holds `{mark: true}` anywhere.
fn fills(v: &Value, mark: &str) -> bool {
match v {
Value::Object(o) => {
o.get(mark) == Some(&Value::Bool(true)) || o.values().any(|c| fills(c, mark))
}
Value::Array(items) => items.iter().any(|c| fills(c, mark)),
_ => false,
}
}
/// The `service` of `o` at `at`: a DID with its service's #fragment; else
/// none, its problem added.
fn service_at(p: &mut Problems, o: &Map<String, Value>, at: &str) -> Option<String> {
match o.get("service").and_then(Value::as_str) {
Some(s) if crate::xrpc::Service::parse(s).is_ok() => Some(s.to_string()),
_ => {
p.add(
&format!("{at}.service"),
"required: a DID with its service's #fragment, as did:web:api.bsky.chat#bsky_chat",
);
None
}
}
}
/// The most collections a `deletes` names.
const PLAN_COLLECTIONS: usize = 32;
/// A plan's `then`: `{ method, service, input? }`, its input literal JSON
/// but `{"$did": true}`, the account's DID; else none, its problems added.
fn plan_then(p: &mut Problems, t: &Value, at: &str) -> Option<Call> {
let o = p.object(t, at, &["method", "service", "input"])?;
let method = p.nsid(o.get("method"), &format!("{at}.method"));
let service = service_at(p, o, at);
let input = o
.get("input")
.cloned()
.unwrap_or_else(|| Value::Object(Map::new()));
let iat = format!("{at}.input");
if !input.is_object() {
p.add(&iat, "must be an object, the procedure's input");
} else if let Some(wrong) = unbound(&input, &iat) {
p.add(
&wrong,
"is literal JSON but {\"$did\": true}, the account's DID",
);
}
Some(Call {
method: method?,
service: service?,
input,
deletes: false,
})
}
/// Where in a plan's `then` input a key starting with `$` is not `{"$did":
/// true}` alone, if anywhere.
fn unbound(v: &Value, at: &str) -> Option<String> {
match v {
Value::Object(o) if o.keys().any(|k| k.starts_with('$') && k != "$type") => {
(o.len() != 1 || o.get("$did") != Some(&Value::Bool(true))).then(|| at.to_string())
}
Value::Object(o) => o.iter().find_map(|(k, x)| unbound(x, &format!("{at}.{k}"))),
Value::Array(a) => a
.iter()
.enumerate()
.find_map(|(i, x)| unbound(x, &format!("{at}[{i}]"))),
_ => None,
}
}
/// An action's `delete`: `{ uri: binding }`.
fn action_delete(p: &mut Problems, o: &Map<String, Value>, at: &str) {
p.keys(o, at, &["uri"]);
let uat = format!("{at}.uri");
match o.get("uri") {
Some(u) => {
if p.binding(u, &uat).is_none() {
p.add(&uat, "must be a binding {\"$\": path} to the record's uri");
}
}
None => p.add(&uat, "required"),
}
}
/// A template's fields (an action's record, a procedure's input, a
/// composer's given values): keys starting with `$` are `$type`, a
/// string, alone; each value checked by `record_value`. With `fill`
/// (`Messages`' `send`, a `Toggle`'s call), it may take the person's own value.
fn record_fields(p: &mut Problems, v: &Value, at: &str, depth: usize, fill: Option<&str>) {
for (k, child) in v.as_object().into_iter().flatten() {
let kat = format!("{at}.{k}");
match k.as_str() {
"$type" if !child.is_string() => p.add(&kat, "must be a string"),
"$type" => {}
k if k.starts_with('$') => match fill {
Some(mark) => p.add(
&kat,
format_args!(
"a key starting with $ is $type, or a binding's, $root's, $now's, $strongRef's, $rkey's, $first's, $join's, $with's, $without's, $move's or {mark}'s alone"
),
),
None => p.add(
&kat,
"a key starting with $ is $type, or a binding's, $root's, $now's, $strongRef's, $rkey's, $first's, $join's, $with's, $without's or $move's alone",
),
},
_ => record_value(p, child, &kat, depth + 1, fill),
}
}
}
/// A value in a template: a literal; a binding; `{"$now": true}`;
/// `{"$strongRef": path}`; `{"$rkey": path}`, the record key of the at-uri
/// there; `{"$root": path}`; `{"$first": [values]}`, the
/// first of them that resolves; `{"$join": [values]}`, their strings
/// joined; an array's edit (`template_edit`); where the person writes or
/// chooses, its mark (`{"$text": true}`, `{"$on": true}`); or an object or
/// array of those.
fn record_value(p: &mut Problems, v: &Value, at: &str, depth: usize, fill: Option<&str>) {
if depth > MAX_DEPTH {
p.add(
at,
format_args!("a template nests at most {MAX_DEPTH} deep"),
);
return;
}
match v {
Value::Object(o) if o.contains_key("$") => {
p.binding(v, at);
}
Value::Object(o) if o.contains_key("$now") => {
if o.len() != 1 || o["$now"] != Value::Bool(true) {
p.add(at, "{\"$now\": true} has the key $now alone, true");
}
}
Value::Object(o) if o.contains_key("$strongRef") => {
if o.len() != 1 {
p.add(at, "{\"$strongRef\": path} has the key $strongRef alone");
} else {
p.path(&o["$strongRef"], &format!("{at}.$strongRef"));
}
}
Value::Object(o) if o.contains_key("$rkey") => {
if o.len() != 1 {
p.add(at, "{\"$rkey\": path} has the key $rkey alone");
} else {
p.path(&o["$rkey"], &format!("{at}.$rkey"));
}
}
Value::Object(o) if o.contains_key("$root") => {
p.root(v, at);
}
Value::Object(o) if o.contains_key("$first") => match o.get("$first") {
Some(Value::Array(a)) if o.len() == 1 && (2..=4).contains(&a.len()) => {
for (i, item) in a.iter().enumerate() {
record_value(p, item, &format!("{at}.$first[{i}]"), depth + 1, fill);
}
}
_ => p.add(
at,
"{\"$first\": [values]} has the key $first alone, 2 to 4 values",
),
},
Value::Object(o) if o.contains_key("$join") => match o.get("$join") {
Some(Value::Array(a)) if o.len() == 1 && (2..=8).contains(&a.len()) => {
for (i, item) in a.iter().enumerate() {
record_value(p, item, &format!("{at}.$join[{i}]"), depth + 1, fill);
}
}
_ => p.add(
at,
"{\"$join\": [values]} has the key $join alone, 2 to 8 values, each a string once read",
),
},
Value::Object(o) if EDITS.iter().any(|e| o.contains_key(*e)) => {
template_edit(p, o, at, depth, fill)
}
Value::Object(o) if fill.is_some_and(|mark| o.contains_key(mark)) => {
let mark = fill.unwrap_or_default();
if o.len() != 1 || o[mark] != Value::Bool(true) {
p.add(
at,
format_args!("{{\"{mark}\": true}} has the key {mark} alone, true"),
);
}
}
Value::Object(_) => record_fields(p, v, at, depth, fill),
Value::Array(items) => {
for (i, item) in items.iter().enumerate() {
record_value(p, item, &format!("{at}[{i}]"), depth + 1, fill);
}
}
_ => {}
}
}
/// The edits of an array a template makes (`ui::edit`).
const EDITS: [&str; 3] = ["$with", "$without", "$move"];
/// An array's edit in a template: `{"$with": [array, key, element]}`,
/// `{"$without": [array, key, value]}` or `{"$move": [array, key, value,
/// by]}`, its key alone, `key` a path within each element, `by` a whole
/// number but 0, the rest values.
fn template_edit(
p: &mut Problems,
o: &Map<String, Value>,
at: &str,
depth: usize,
fill: Option<&str>,
) {
let name = EDITS
.into_iter()
.find(|e| o.contains_key(*e))
.unwrap_or_default();
let shape = match name {
"$move" => "[array, key, value, by]",
_ => "[array, key, value]",
};
let arity = shape.split(',').count();
let args = o[name]
.as_array()
.filter(|a| o.len() == 1 && a.len() == arity);
let Some(args) = args else {
p.add(
at,
format_args!("{{\"{name}\": {shape}}} has the key {name} alone"),
);
return;
};
let aat = format!("{at}.{name}");
record_value(p, &args[0], &format!("{aat}[0]"), depth + 1, fill);
p.path(&args[1], &format!("{aat}[1]"));
record_value(p, &args[2], &format!("{aat}[2]"), depth + 1, fill);
if args
.get(3)
.is_some_and(|by| !by.as_i64().is_some_and(|by| by != 0))
{
p.add(
&format!("{aat}[3]"),
"must be a whole number but 0, the places it moves",
);
}
}
/// A trusted view: a bundled one, or its operator's. Its id, the name of
/// its file, and the file as a problem names it (`views/<id>.json`, or the
/// operator's file's path).
#[derive(Clone, Debug)]
pub struct Bundled {
pub id: String,
pub file: String,
pub view: View,
}
/// The trusted views, in their ids' order, and the service each method
/// view names, by its method: what a records view's query join calls when
/// it names none; the procedures the operator's app files call to
/// register a device for push (`operator::push_calls`); what each app
/// file calls to have its server read the account's writes back at once
/// (`operator::refresh_of`); the app files' own pages
/// (`operator::pages_of`); the domains of the apps whose files draw
/// their own sign-in screen (`signIn`); the permission sets their
/// files name (`operator::sets_of`); and the lexicons the operator's apps
/// ship beside their views (`operator::lexicons_of`).
#[derive(Clone, Debug)]
pub struct Views {
views: Vec<Bundled>,
services: Vec<(String, String)>,
pushes: Vec<Call>,
refreshes: Vec<Refresh>,
pages: Vec<Page>,
sign_ins: Vec<String>,
sets: Vec<crate::scope::Include>,
lexicons: Vec<Arc<Value>>,
}
/// One of an app file's own pages (`pages`): its app's domain and name,
/// its path on the app's site, its title and description, and its text,
/// Markdown as written and as blocks (`ui::page_blocks`), its links to the
/// app's own paths opening them on the app's site.
#[derive(Clone, Debug, PartialEq)]
pub struct Page {
pub domain: String,
pub app: String,
pub path: String,
pub title: String,
pub description: Option<String>,
pub markdown: String,
pub blocks: Vec<Value>,
}
/// An app file's `refresh`: the procedure of its own server that reads
/// records the account just wrote back from the account's PDS, called with
/// `{"uris": [...]}` after a write through HUD of one of `collections`, the
/// app's own: those its views write.
#[derive(Clone, Debug, PartialEq)]
pub struct Refresh {
pub method: String,
pub service: String,
pub collections: BTreeSet<String>,
}
/// The service each method view of `docs` names, by its method, read
/// from the documents as they are: what views are checked against before
/// they are views.
pub(crate) fn services_of<'a>(docs: impl IntoIterator<Item = &'a Value>) -> Vec<(String, String)> {
docs.into_iter()
.filter_map(|doc| {
Some((
doc["method"].as_str()?.to_string(),
doc["service"].as_str()?.to_string(),
))
})
.collect()
}
/// The service `services` names for the query `method`, if any.
fn service_in<'a>(services: &'a [(String, String)], method: &str) -> Option<&'a str> {
services
.iter()
.find(|(m, _)| m == method)
.map(|(_, s)| s.as_str())
}
impl Views {
/// The bundled views, checked: one with a problem, or drawing what
/// another draws, is a bug in the build.
pub fn built_in() -> Views {
let docs: Vec<Value> = VIEWS
.iter()
.filter_map(|(_, text)| serde_json::from_str(text).ok())
.collect();
let services = services_of(&docs);
let views: Vec<Bundled> = VIEWS
.iter()
.map(|&(id, text)| load(format!("views/{id}.json"), id, text, &services))
.map(|loaded| loaded.map(|(b, _)| b))
.collect::<Result<_, _>>()
.expect("a bundled view is broken");
let wrong = conflicts(&views);
assert!(wrong.is_empty(), "{}", wrong.join("; "));
Views::of(views)
}
/// `views` as the trusted views: in their ids' order, with the
/// services their method views name, and no app's push calls.
fn of(mut views: Vec<Bundled>) -> Views {
views.sort_by(|a, b| a.id.cmp(&b.id));
let services = services_of(views.iter().map(|b| &b.view.doc));
Views {
views,
services,
pushes: Vec::new(),
refreshes: Vec::new(),
pages: Vec::new(),
sign_ins: Vec::new(),
sets: Vec::new(),
lexicons: Vec::new(),
}
}
/// No views: what an instance serving the operator's apps alone adds
/// them to (`operator::load`).
pub fn none() -> Views {
Views::of(Vec::new())
}
/// These views with `added`: each replacing the view of its id, and any
/// drawing what it draws.
pub fn with(&self, added: Vec<Bundled>) -> Views {
let mut views: Vec<Bundled> = self
.views
.iter()
.filter(|b| {
!added
.iter()
.any(|a| a.id == b.id || a.view.drawn() == b.view.drawn())
})
.cloned()
.collect();
views.extend(added);
Views {
pushes: self.pushes.clone(),
refreshes: self.refreshes.clone(),
pages: self.pages.clone(),
sign_ins: self.sign_ins.clone(),
sets: self.sets.clone(),
lexicons: self.lexicons.clone(),
..Views::of(views)
}
}
/// These views with `pushes`, the procedures the operator's app files
/// call to register and unregister a device for push.
pub fn with_pushes(self, pushes: Vec<Call>) -> Views {
Views { pushes, ..self }
}
/// The procedures the operator's app files call for push.
pub fn pushes(&self) -> &[Call] {
&self.pushes
}
/// These views with `refreshes`, what the operator's app files call
/// after a write.
pub fn with_refreshes(self, refreshes: Vec<Refresh>) -> Views {
Views { refreshes, ..self }
}
/// What the operator's app files call after a write.
pub fn refreshes(&self) -> &[Refresh] {
&self.refreshes
}
/// These views with `pages`, the app files' own pages.
pub fn with_pages(self, pages: Vec<Page>) -> Views {
Views { pages, ..self }
}
/// The page of the app of `domain` at `path`, if its app file has one.
pub fn page(&self, domain: &str, path: &str) -> Option<&Page> {
self.pages
.iter()
.find(|p| p.domain == domain && p.path == path)
}
/// These views with `sign_ins`, the domains of the apps whose files
/// draw their own sign-in screen.
pub fn with_sign_ins(self, sign_ins: Vec<String>) -> Views {
Views { sign_ins, ..self }
}
/// The domains of the apps whose files draw their own sign-in screen
/// (`signIn`): their web clients, at those domains, HUD sends straight
/// on to the account's server (`oauth::issuer`).
pub fn sign_ins(&self) -> &[String] {
&self.sign_ins
}
/// These views with `sets`, the permission sets the operator's app
/// files name.
pub fn with_sets(self, sets: Vec<crate::scope::Include>) -> Views {
Views { sets, ..self }
}
/// The permission sets the operator's app files name: what sign-in
/// asks for first (`scope::including`).
pub fn sets(&self) -> &[crate::scope::Include] {
&self.sets
}
/// These views with `lexicons`, those the operator's apps ship.
pub fn with_lexicons(self, lexicons: Vec<Arc<Value>>) -> Views {
Views { lexicons, ..self }
}
/// The lexicon of `nsid` an operator's app ships, if one does: what
/// HUD reads for it before its bundled one (`Hud::lexicon_doc`).
pub fn lexicon(&self, nsid: &str) -> Option<Arc<Value>> {
self.lexicons.iter().find(|d| d["id"] == nsid).cloned()
}
/// Every lexicon the views are checked against: those the operator's
/// apps ship, and the bundled ones they don't replace.
pub fn lexicon_docs(&self) -> Vec<Arc<Value>> {
let bundled = crate::lexicon::all_bundled()
.filter(|d| !self.lexicons.iter().any(|a| a["id"] == d["id"]))
.cloned();
self.lexicons.iter().cloned().chain(bundled).collect()
}
/// Every view, in their ids' order.
pub fn all(&self) -> &[Bundled] {
&self.views
}
/// The service each method view names, by its method.
pub(crate) fn services(&self) -> &[(String, String)] {
&self.services
}
/// The service the view of the query `method` names, if any.
pub fn service(&self, method: &str) -> Option<&str> {
service_in(&self.services, method)
}
/// Whether a view, or an app file's push, calls the procedure `method`
/// of `service`.
pub fn calls(&self, method: &str, service: &str) -> bool {
self.views
.iter()
.flat_map(|b| &b.view.calls)
.chain(&self.pushes)
.any(|c| !c.deletes && c.method == method && c.service == service)
}
/// Whether a view deletes what the query `method` of `service` plans.
pub fn deletes(&self, method: &str, service: &str) -> bool {
self.views
.iter()
.flat_map(|b| &b.view.calls)
.any(|c| c.deletes && c.method == method && c.service == service)
}
/// What a view's `deletes` of the query `method` of `service` says
/// beyond it, if a view deletes so: read as `call_procedure` deletes.
pub fn plan(&self, method: &str, service: &str) -> Option<&Plan> {
self.views
.iter()
.flat_map(|b| &b.view.plans)
.find(|p| p.method == method && p.service == service)
}
/// Every collection the views' plans name (`Plan::collections`): what
/// HUD asks to delete, where it asks to write none of it.
pub fn plan_collections(&self) -> BTreeSet<String> {
let plans = self.views.iter().flat_map(|b| &b.view.plans);
plans.flat_map(|p| p.collections.iter().cloned()).collect()
}
}
/// The trusted views the server uses, set once: with the operator's, as
/// the server adds them at startup (`install`), else the bundled ones, on
/// first use.
static IN_USE: OnceLock<Views> = OnceLock::new();
/// The trusted views in use: those the server serves.
pub fn views() -> &'static Views {
IN_USE.get_or_init(unset)
}
/// The trusted views where the server installs none: the bundled ones.
#[cfg(not(test))]
fn unset() -> Views {
Views::built_in()
}
/// An operator's apps the tests serve: Grain's, as its repository has
/// them, an app file and its views.
#[cfg(test)]
pub(crate) const GRAIN_APPS: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/src/testdata/grain/apps");
/// The trusted views where a test installs none: the bundled ones with an
/// operator's, Grain's (`GRAIN_APPS`), so the tests hold an operator's
/// views to all HUD does with them.
#[cfg(test)]
fn unset() -> Views {
crate::operator::load(std::path::Path::new(GRAIN_APPS), true)
.expect("Grain's apps, as an operator's")
.views
}
/// Use `views` as the trusted views, before anything has read them: the
/// server does, with its operator's (`operator::load`), as it starts.
pub fn install(views: Views) -> Result<(), String> {
IN_USE
.set(views)
.map_err(|_| "the trusted views were read before the operator's were added".to_string())
}
/// What the views do as the account, read from their documents: what HUD
/// asks an account's server for, as `scope::asked` builds it from the
/// views an instance serves.
impl Views {
/// Every service they name, as `did:…#fragment`: their queries',
/// joins', opens' and procedures', and the services the operator's app
/// files register devices for push with and refresh writes at.
pub fn called(&self) -> BTreeSet<String> {
let pushed = self.pushes.iter().map(|c| c.service.clone());
let refreshed = self.refreshes.iter().map(|r| r.service.clone());
let mut out: BTreeSet<String> = pushed.chain(refreshed).collect();
self.each_object(&mut |o| {
if let Some(s) = o.get("service").and_then(Value::as_str)
&& crate::xrpc::Service::parse(s).is_ok()
{
out.insert(s.to_string());
}
});
out
}
/// Every method they call at `service`: each of their objects naming
/// both (a method view, a query join, a procedure's call), and the
/// operator's app files' push and refresh calls there. What a
/// permission set must list for the views to call it as the account
/// (`scope::ungranted`).
pub fn methods_of(&self, service: &str) -> BTreeSet<String> {
let pushed = self.pushes.iter().map(|c| (&c.method, &c.service));
let refreshed = self.refreshes.iter().map(|r| (&r.method, &r.service));
let mut out: BTreeSet<String> = pushed
.chain(refreshed)
.filter(|(_, s)| *s == service)
.map(|(m, _)| m.clone())
.collect();
self.each_object(&mut |o| {
if o.get("service").and_then(Value::as_str) == Some(service)
&& let Some(m) = o.get("method").and_then(Value::as_str)
{
out.insert(m.to_string());
}
});
out
}
/// Every collection they write: an `Action`'s `create`, a `Compose`'s
/// `writes`.
pub fn written(&self) -> BTreeSet<String> {
self.written_by(&|_| true)
}
/// Every collection the views `of` keeps write, as `written` reads them.
pub fn written_by(&self, of: &dyn Fn(&Bundled) -> bool) -> BTreeSet<String> {
let mut out = BTreeSet::new();
let views = self.views.iter().filter(|b| of(b));
views.for_each(|b| {
walk(&b.view.doc, &mut |o| {
let props = o.get("props").unwrap_or(&Value::Null);
let written: Vec<&Value> = match o.get("component").and_then(Value::as_str) {
Some("Action") => vec![&props["create"]["collection"]],
Some("Compose") => props["writes"]
.as_array()
.into_iter()
.flatten()
.map(|w| &w["collection"])
.collect(),
_ => vec![],
};
out.extend(
written
.into_iter()
.filter_map(Value::as_str)
.map(str::to_string),
);
})
});
out
}
/// Whether a composer of theirs uploads pictures: a `Compose` with a
/// `photos` field, or a `card` one, whose link's picture it uploads.
pub fn uploads(&self) -> bool {
let mut out = false;
self.each_object(&mut |o| {
let fields = o.get("props").and_then(|p| p.get("fields"));
out |= o.get("component").and_then(Value::as_str) == Some("Compose")
&& fields
.and_then(Value::as_array)
.into_iter()
.flatten()
.any(|f| matches!(f["kind"].as_str(), Some("photos" | "card")));
});
out
}
/// Whether one draws a query that takes feeds by the names a person
/// gives them (`feeds::names_feeds`), read from their preferences.
pub fn names_feeds(&self) -> bool {
self.views.iter().any(|b| {
b.view
.method
.as_deref()
.is_some_and(|m| crate::feeds::NAMING.contains(&m))
})
}
/// Whether one reports feed interactions (`View::interactions`).
pub fn sends_interactions(&self) -> bool {
self.views.iter().any(|b| b.view.interactions.is_some())
}
/// Call `f` on every object of every view's document.
fn each_object(&self, f: &mut impl FnMut(&Map<String, Value>)) {
self.views.iter().for_each(|b| walk(&b.view.doc, f));
}
}
/// Call `f` on every object within `v`, `v` too.
fn walk(v: &Value, f: &mut impl FnMut(&Map<String, Value>)) {
match v {
Value::Object(o) => {
f(o);
o.values().for_each(|x| walk(x, f));
}
Value::Array(a) => a.iter().for_each(|x| walk(x, f)),
_ => {}
}
}
/// Whether a trusted view, or an operator's app file registering a device
/// for push, calls the procedure `method` of `service`: the only
/// procedures `call_procedure` sends.
pub fn bundled_call(method: &str, service: &str) -> bool {
views().calls(method, service)
}
/// Whether a trusted view deletes what the query `method` of `service`
/// plans (`deletes`): the only plans `call_procedure` deletes.
pub fn bundled_deletes(method: &str, service: &str) -> bool {
views().deletes(method, service)
}
/// What is wrong with a call against its procedure's lexicon (`docs`, its
/// own among them): a method that is no procedure, or takes no JSON, and
/// top-level input fields it does not take or requires and the template
/// leaves out. What the template fills in is checked when it is sent. A
/// deletion plan's query (`deletes`), as `deletes_problems` checks it.
pub fn call_problems(call: &Call, docs: &[std::sync::Arc<Value>]) -> Vec<String> {
let method = call.method.as_str();
let Some(doc) = docs.iter().find(|d| d["id"] == method) else {
return vec![format!("{method}: no lexicon")];
};
if call.deletes {
return deletes_problems(call, doc);
}
let def = match crate::procedures::procedure_def(method, doc) {
Ok(def) => def,
Err(why) => return vec![why],
};
let schema = &def["input"]["schema"];
let schema = match schema["type"].as_str() {
Some("ref") => schema["ref"]
.as_str()
.map(|r| crate::lexicon::full_ref(method, r))
.and_then(|full| {
let (nsid, name) = full.split_once('#')?;
docs.iter()
.find(|d| d["id"] == nsid)
.map(|d| d["defs"][name].clone())
})
.unwrap_or(Value::Null),
_ => schema.clone(),
};
template_problems(method, &call.input, &schema, ("input", "an input"))
}
/// What is wrong with a deletion plan's query (`deletes`) against its
/// lexicon `doc`: a method that is no query, one answering no `writes`
/// array (the deletes of one `com.atproto.repo.applyWrites`), and params
/// the template gives that it does not take or leaves out that it
/// requires.
fn deletes_problems(call: &Call, doc: &Value) -> Vec<String> {
let method = call.method.as_str();
let def = match crate::xrpc::query_def(method, doc) {
Ok(def) => def,
Err(why) => return vec![why],
};
let params = &def["parameters"];
let mut out = template_problems(method, &call.input, params, ("params", "a param"));
if def["output"]["schema"]["properties"]["writes"]["type"] != "array" {
out.push(format!(
"{method}: answers no writes, the deletes of one com.atproto.repo.applyWrites"
));
}
out
}
/// The top-level fields of a template `given` that `schema` (an object's
/// or params') does not take, and those it requires that `given` leaves
/// out, each named as `what`'s: its name and one of it.
fn template_problems(
method: &str,
given: &Value,
schema: &Value,
(what, one): (&str, &str),
) -> Vec<String> {
let given = given.as_object();
let taken = schema["properties"].as_object();
let mut out: Vec<String> = given
.into_iter()
.flatten()
.filter(|(k, _)| *k != "$type" && taken.is_none_or(|t| !t.contains_key(*k)))
.map(|(k, _)| format!("{method}: {what}.{k} is not {one} of it"))
.collect();
for k in schema["required"]
.as_array()
.into_iter()
.flatten()
.filter_map(Value::as_str)
{
if !given.is_some_and(|g| g.contains_key(k)) {
out.push(format!("{method}: {what}.{k} is required"));
}
}
out
}
/// A trusted view from its file's `text`, its query joins calling by
/// default the services `services` names, and a warning for each of its
/// optional keys left out; or every problem with it, each naming its
/// `file`. A key written `?key` is optional: read as `key`, and left out
/// where HUD finds a problem in it (a prop or a value this HUD doesn't
/// know), so a view written for a newer HUD still loads on an older one.
pub(crate) fn load(
file: String,
id: &str,
text: &str,
services: &[(String, String)],
) -> Result<(Bundled, Vec<String>), Vec<String>> {
let doc: Value = serde_json::from_str(text).map_err(|e| vec![format!("{file}: {e}")])?;
let mut left_out = BTreeSet::new();
let mut warnings = Vec::new();
loop {
let (mut optional, mut problems) = (Vec::new(), Vec::new());
let unmarked = unmark(&doc, "", &left_out, &mut optional, &mut problems);
let problems = match problems.is_empty() {
true => match parse_in(&unmarked, true, services) {
Ok(view) => {
let id = id.to_string();
return Ok((Bundled { id, file, view }, warnings));
}
Err(problems) => problems,
},
false => problems,
};
let before = left_out.len();
for problem in &problems {
if let Some(key) = optional.iter().find(|k| k.holds(problem))
&& left_out.insert(key.at.clone())
{
warnings.push(format!(
"{file}: {problem} (?{} is optional, so it's left out)",
key.key
));
}
}
if left_out.len() == before {
return Err(problems.iter().map(|p| format!("{file}: {p}")).collect());
}
}
}
/// An optional key of a view (`?key`): its path and its object's, as the
/// view's problems name them less the leading `view.`, and its name.
struct Optional {
at: String,
parent: String,
key: String,
}
impl Optional {
/// Whether `problem` lies in this key: at it or within it, or naming it
/// as its object's unknown key.
fn holds(&self, problem: &str) -> bool {
let (at, what) = problem.split_once(": ").unwrap_or((problem, ""));
let at = match at {
"view" => "",
_ => at.strip_prefix("view.").unwrap_or(at),
};
let within = at
.strip_prefix(self.at.as_str())
.is_some_and(|rest| rest.is_empty() || rest.starts_with(['.', '[']));
within || (at == self.parent && what == format!("unknown key \"{}\"", self.key))
}
}
/// `v`, at `at`, with each key written `?key` read as `key`, those whose
/// path is in `left_out` left out; each such key added to `optional`, and
/// to `problems` one given both ways.
fn unmark(
v: &Value,
at: &str,
left_out: &BTreeSet<String>,
optional: &mut Vec<Optional>,
problems: &mut Vec<String>,
) -> Value {
match v {
Value::Object(o) => {
let mut out = Map::new();
for (k, x) in o {
let key = k.strip_prefix('?').unwrap_or(k);
let kat = match at {
"" => key.to_string(),
_ => format!("{at}.{key}"),
};
if key != k {
if o.contains_key(key) {
let parent = if at.is_empty() { "view" } else { at };
problems.push(format!("{parent}: \"{k}\" and \"{key}\" both given"));
}
optional.push(Optional {
at: kat.clone(),
parent: at.to_string(),
key: key.to_string(),
});
if left_out.contains(&kat) {
continue;
}
}
out.insert(
key.to_string(),
unmark(x, &kat, left_out, optional, problems),
);
}
Value::Object(out)
}
Value::Array(a) => Value::Array(
a.iter()
.enumerate()
.map(|(i, x)| unmark(x, &format!("{at}[{i}]"), left_out, optional, problems))
.collect(),
),
_ => v.clone(),
}
}
/// What is wrong among trusted views, each named by its file: one drawing
/// what another draws, a collection a method view draws as its query
/// (`records`) that another names too or a collection view draws, and a
/// plan of a query that another plan of it says otherwise.
pub fn conflicts(views: &[Bundled]) -> Vec<String> {
let mut out = Vec::new();
for (i, b) in views.iter().enumerate() {
let drawn = b.view.drawn();
if let Some(o) = views[..i].iter().find(|o| o.view.drawn() == drawn) {
out.push(format!("{}: {} draws {drawn} too", b.file, o.file));
}
for c in b.view.records.iter().map(|r| r.collection.as_str()) {
let routes = |o: &&Bundled| o.view.records.iter().any(|r| r.collection == c);
if let Some(o) = views[..i].iter().find(routes) {
out.push(format!("{}: {} draws {c} as its query too", b.file, o.file));
}
if let Some(o) = views
.iter()
.find(|o| o.view.collection.as_deref() == Some(c))
{
out.push(format!("{}: {} draws {c} as records", b.file, o.file));
}
}
for (k, plan) in b.view.plans.iter().enumerate() {
let same = |p: &&Plan| p.method == plan.method && p.service == plan.service;
let before = views[..i].iter().flat_map(|o| &o.view.plans);
if let Some(o) = before.chain(&b.view.plans[..k]).find(same)
&& o != plan
{
let method = &plan.method;
out.push(format!(
"{}: deletes {method} otherwise than before",
b.file
));
}
}
}
out
}
/// What is wrong with a trusted view beyond its document, against the
/// lexicons `docs` and the other trusted `views`: a collection view that
/// does not draw both a page of records and one; and its calls, its query
/// joins (an app page's page after too) and their services, and a method
/// view's profile section. Every bundled view passes (the tests hold
/// them), and an operator's must to be used (`operator`).
pub fn trusted_problems(v: &View, docs: &[Arc<Value>], views: &Views) -> Vec<String> {
let mut out = Vec::new();
if v.collection.is_some() && (v.list.is_none() || v.record.is_none()) {
out.push(
"view: a trusted collection view draws a page of records (list) and one (record)"
.into(),
);
}
for c in &v.calls {
out.extend(call_problems(c, docs));
}
let more = v.page.as_ref().and_then(|p| p.more("c"));
for j in v.query_joins().chain(more.as_ref()) {
out.extend(query_join_problems(j, docs));
if j.service_among(v.service.as_deref(), views).is_none() {
out.push(format!(
"{}.service: no view of {} names its service",
j.at, j.method
));
}
}
if let (Some(s), Some(method)) = (&v.profile, &v.method) {
out.extend(section_problems(s, method, docs));
}
out
}
/// What is wrong with a method view's profile section: its params, as an
/// account's, against the lexicon of the view's `method` among `docs`.
fn section_problems(s: &Section, method: &str, docs: &[Arc<Value>]) -> Vec<String> {
let Some(doc) = docs.iter().find(|d| d["id"] == method) else {
return vec![format!("view.profile: no lexicon for {method}")];
};
let def = match crate::xrpc::query_def(method, doc) {
Ok(def) => def,
Err(why) => return vec![format!("view.profile: {why}")],
};
let lexicons = crate::xrpc::lexicons_for(method, docs);
let params = s.params_for("did:plc:abcdefghijklmnopqrstuvwx");
crate::xrpc::params_problems(&lexicons, method, def, ¶ms)
.into_iter()
.map(|p| format!("view.profile: {p}"))
.collect()
}
impl View {
/// What the view draws: its collection, its method, or its app's
/// domain.
pub fn drawn(&self) -> &str {
self.collection
.as_deref()
.or(self.method.as_deref())
.or(self.domain.as_deref())
.unwrap_or_default()
}
/// Every query join of its modes.
pub fn query_joins(&self) -> impl Iterator<Item = &QueryJoin> {
let modes = [&self.list, &self.record].into_iter().flatten();
modes
.flat_map(|m| &m.queries)
.chain(self.query.iter().flat_map(|q| &q.queries))
.chain(self.page.iter().flat_map(|p| &p.queries))
}
}
/// The trusted views, in their ids' order: the bundled ones, as the
/// operator's replace and add to them.
pub fn bundled() -> &'static [Bundled] {
views().all()
}
/// The bundled view of `collection`, if any.
pub fn for_collection(collection: &str) -> Option<&'static View> {
bundled()
.iter()
.map(|b| &b.view)
.find(|v| v.collection.as_deref() == Some(collection))
}
/// The bundled method view that draws a record of `collection` as its
/// query, and its `records` entry for it, if any.
pub fn route(collection: &str) -> Option<(&'static View, &'static Routed)> {
bundled().iter().find_map(|b| {
let r = b.view.records.iter().find(|r| r.collection == collection)?;
Some((&b.view, r))
})
}
/// The `query` tool's arguments a record at `uri` opens as, where a bundled
/// view draws its collection and its params need only the at-uri and its
/// DID (a post's thread, a gallery): the call to make in place of
/// `get_record`, so a record opened from anywhere is the same tile as its
/// query opened from a list. None where the params read the record itself.
pub fn routed_call(uri: &str) -> Option<Value> {
let mut parts = uri.strip_prefix("at://")?.split('/');
let (authority, collection) = (parts.next()?, parts.next()?);
let (v, routed) = route(collection)?;
if routed.reads_record() {
return None;
}
let rec = serde_json::json!({ "uri": uri, "did": authority });
routed.args_for(v.method.as_deref()?, &rec)
}
/// What making a record of `collection` is, by the bundled view naming it:
/// a collection view's `activity` verb and its list's summary, or a method
/// view's `records` entry's activity.
pub fn activity(collection: &str) -> Option<(&'static str, &'static Summary)> {
match for_collection(collection) {
Some(v) => Some((v.activity.as_deref()?, v.list.as_ref()?.summary.as_ref()?)),
None => {
let a = route(collection)?.1.activity.as_ref()?;
Some((&a.verb, &a.summary))
}
}
}
/// The bundled view of the query `method`, if any.
pub fn for_method(method: &str) -> Option<&'static View> {
bundled()
.iter()
.map(|b| &b.view)
.find(|v| v.method.as_deref() == Some(method))
}
/// The title a trusted view's launcher gives the call of `method` with
/// `params` (Bluesky's "Discover"), if one does: the same
/// params, a launcher's `$me` standing for any account (a title says what,
/// the header whose: "Galleries" for anyone's).
pub fn launch_title(method: &str, params: &Value) -> Option<String> {
let empty = Map::new();
let params = params.as_object().unwrap_or(&empty);
for_method(method)?
.launch
.iter()
.find(|l| {
l.params.len() == params.len()
&& l.params.iter().all(|(k, v)| match params.get(k) {
Some(given) if me(v).is_some() => given.is_string(),
Some(given) => given == v,
None => false,
})
})
.map(|l| l.title.clone())
}
/// The bundled app page view of the app at `domain`, if any.
pub fn for_domain(domain: &str) -> Option<&'static View> {
bundled()
.iter()
.map(|b| &b.view)
.find(|v| v.page.is_some() && v.domain.as_deref() == Some(domain))
}
/// The origins the view loads media from, for its CSP's `resourceDomains`:
/// the server's own (its blob proxy) and every bundled view's, sorted, each
/// once. A `Map`'s tiles are fetched, so its origin is a `connectDomains`'
/// (`catalog::MAP_TILES`).
pub fn csp_origins(public_origin: &str) -> Vec<String> {
origins_of(public_origin, bundled().iter().map(|b| &b.view))
}
fn origins_of<'a>(public_origin: &str, views: impl Iterator<Item = &'a View>) -> Vec<String> {
let mut all: Vec<String> = std::iter::once(public_origin.to_string())
.chain(views.flat_map(|v| v.origins.iter().cloned()))
.collect();
all.sort();
all.dedup();
all
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
fn problems(doc: &Value, trusted: bool) -> Vec<String> {
parse(doc, trusted).err().unwrap_or_default()
}
/// The problems of an inline view, by where they are.
fn wheres(doc: &Value) -> Vec<String> {
problems(doc, false)
.iter()
.map(|p| p.split_once(": ").unwrap().0.to_string())
.collect()
}
fn posts(layout: Value) -> Value {
json!({ "collection": "app.bsky.feed.post", "description": "Posts",
"list": { "layout": layout } })
}
/// A trusted view's inline copy says nothing at its top that only a
/// trusted view may: what is left is in its layout, procedures called,
/// plans committed, interactions sent and what the host is asked to do.
#[test]
fn bundled_views_copied_to_draw_inline() {
for b in bundled().iter().filter(|b| b.view.page.is_none()) {
let copy = inline_copy(&b.view.doc);
for p in problems(©, false) {
assert!(
p.ends_with("only a bundled view calls procedures")
|| p.ends_with("only a bundled view deletes what a query plans")
|| p.ends_with("only a bundled view sends interactions")
|| p.ends_with("only a bundled view asks the host"),
"{}: {p}",
b.id
);
}
}
assert_eq!(inline_copy(&json!(1)), json!(1));
}
/// Every trusted view the tests use, the bundled ones and Grain's as an
/// operator's, parses, draws one thing, and passes what an operator's
/// view is held to as HUD starts (`trusted_problems`).
#[test]
fn every_bundled_view_validates() {
assert_eq!(Views::built_in().all().len(), VIEWS.len());
let docs = lexicon_docs();
for b in bundled() {
let v = &b.view;
let file = if VIEWS.iter().any(|(id, _)| *id == b.id) {
format!("views/{}.json", b.id)
} else {
format!("{GRAIN_APPS}/views/{}.json", b.id)
};
assert_eq!(b.file, file);
assert_eq!(
trusted_problems(v, &docs, views()),
Vec::<String>::new(),
"{}",
b.id
);
// Each draws one thing.
match (&v.collection, &v.method, &v.domain) {
(Some(c), None, None) => {
assert_eq!(for_collection(c), Some(v), "{}", b.id);
}
(None, Some(m), None) => {
assert_eq!(for_method(m), Some(v), "{}", b.id);
assert!(v.query.is_some() && v.service.is_some(), "{}", b.id);
}
(c, m, d) => {
assert_eq!((c, m), (&None, &None), "{}", b.id);
assert_eq!(for_domain(d.as_deref().unwrap()), Some(v), "{}", b.id);
assert!(v.page.is_some() && v.service.is_some(), "{}", b.id);
}
}
}
// The feeds, from the AppView, their images from its CDN and their
// video posters from its video host.
for m in [
"app.bsky.feed.getFeed",
"app.bsky.feed.getAuthorFeed",
"app.bsky.feed.getTimeline",
] {
let v = for_method(m).expect("a view of each feed");
assert_eq!(
v.service.as_deref(),
Some("did:web:api.bsky.app#bsky_appview")
);
// Video posters redirect from video.bsky.app to its CDN, and a
// CSP holds the redirect's target too.
assert_eq!(
v.origins,
[
"https://cdn.bsky.app",
"https://video.bsky.app",
"https://video.cdn.bsky.app"
]
);
assert_eq!(v.query.as_ref().unwrap().items, Path::parse("feed"));
// Each card says first why it is in the feed and what a reply
// replies to (FeedContext, above it and under its author), then
// the post beside its author's face (a Row of an Image and a
// Stack), drawing its embed, whatever it is, as Bluesky does.
let card = &v.doc["query"]["layout"]["children"];
fn nodes(n: &Value, out: &mut Vec<Value>) {
out.push(n.clone());
for c in n["children"].as_array().into_iter().flatten() {
nodes(c, out);
}
}
let post = &card[1];
let mut all = Vec::new();
nodes(post, &mut all);
assert_eq!(card[0]["component"], "FeedContext", "{m}");
assert_eq!(card[0]["props"]["item"], json!({ "$": "." }), "{m}");
assert_eq!(post["children"][0]["props"]["size"], "face", "{m}");
assert!(
all.iter()
.any(|n| n["component"] == "FeedContext" && n["props"]["part"] == "replyTo"),
"{m}"
);
let embed = all.iter().find(|n| n["component"] == "Embed").unwrap();
assert_eq!(
embed["props"],
json!({ "value": { "$": "post.embed" }, "did": { "$": "post.author.did" },
"uri": { "$": "post.uri" } }),
"{m}"
);
assert!(!card.to_string().contains("\"Gallery\""), "{m}");
}
assert!(for_collection("fm.plyr.list").is_some());
assert!(for_collection("fm.plyr.like").is_some());
// A collection a method view draws as its query is named by one
// view alone, and drawn by no collection view.
let mut routed: Vec<&str> = Vec::new();
for b in bundled() {
for r in &b.view.records {
let c = r.collection.as_str();
assert!(!routed.contains(&c), "{}: {c} is routed twice", b.id);
assert!(for_collection(c).is_none(), "{}: {c} has a view", b.id);
routed.push(c);
}
}
routed.sort_unstable();
assert_eq!(
routed,
[
"app.bsky.feed.post",
"app.bsky.feed.repost",
"dev.knotless.check",
"dev.knotless.comment",
"dev.knotless.issue",
"dev.knotless.profile",
"dev.knotless.pull",
"dev.knotless.repo",
"dev.knotless.star",
"social.grain.gallery",
"social.grain.story",
]
);
let (thread, post) = route("app.bsky.feed.post").expect("posts open as threads");
assert_eq!(
thread.method.as_deref(),
Some("app.bsky.feed.getPostThread")
);
assert!(!post.reads_record());
assert!(route("app.bsky.feed.repost").unwrap().1.reads_record());
assert!(route("dev.knotless.release").is_none());
// standard.site's posts and blogs, the post's body drawn by Document.
let doc = for_collection("site.standard.document").expect("the document view");
// Its Leaflet blocks embed Bluesky posts, their images and video
// posters from the AppView's hosts.
assert_eq!(
doc.origins,
[
"https://cdn.bsky.app",
"https://video.bsky.app",
"https://video.cdn.bsky.app"
]
);
let body = &doc.doc["record"]["layout"]["children"][2];
assert_eq!(body["component"], "Document");
let blog = for_collection("site.standard.publication").expect("the publication view");
assert!(matches!(
&blog.record.as_ref().unwrap().join[0].source,
Source::Backlinks { collection, .. } if collection == "site.standard.document"
));
}
#[test]
fn actions_checked() {
let like = json!({ "component": "Action", "props": {
"label": "Like", "icon": "heart", "done": "Liked",
"create": { "collection": "app.bsky.feed.like", "record": {
"subject": { "$strongRef": "." }, "createdAt": { "$now": true },
"via": { "$": "uri" }, "tags": ["a", { "$": "value.text" }],
"nested": { "$type": "app.bsky.embed.record", "record": { "$strongRef": "post" } } } } } });
assert_eq!(problems(&posts(like.clone()), false), Vec::<String>::new());
let unlike = json!({ "component": "Action", "props": {
"label": "Unlike", "icon": "trash", "delete": { "uri": { "$": "uri" } } } });
assert_eq!(problems(&posts(unlike), false), Vec::<String>::new());
let action = |props: Value| posts(json!({ "component": "Action", "props": props }));
let create = |record: Value| {
action(json!({ "label": "Go",
"create": { "collection": "app.bsky.feed.like", "record": record } }))
};
let at = "list.layout.props.create.record";
for (doc, want) in [
// Exactly one of create and delete.
(action(json!({ "label": "Go" })), vec!["list.layout.props"]),
(
action(json!({ "label": "Go", "delete": { "uri": { "$": "uri" } },
"create": { "collection": "app.bsky.feed.like", "record": {} } })),
vec!["list.layout.props"],
),
// The label, the collection and delete's uri as they must be.
(
action(json!({ "label": { "$": "uri" }, "delete": { "uri": { "$": "uri" } } })),
vec!["list.layout.props.label"],
),
(
action(json!({ "label": "Go", "delete": { "uri": "at://did:plc:x/a.b.c/1" } })),
vec!["list.layout.props.delete.uri"],
),
(
action(
json!({ "label": "Go", "icon": "bomb", "delete": { "uri": { "$": "uri" } } }),
),
vec!["list.layout.props.icon"],
),
(
action(json!({ "label": "Go",
"create": { "collection": { "$": "c" }, "record": {} } })),
vec!["list.layout.props.create.collection"],
),
(
action(json!({ "label": "Go",
"create": { "collection": "app.bsky.feed.like", "record": { "$": "value" } } })),
vec![at],
),
// The record's special values, each alone and well formed.
(
create(json!({ "t": { "$now": false } })),
vec!["list.layout.props.create.record.t"],
),
(
create(json!({ "s": { "$strongRef": "a b" } })),
vec!["list.layout.props.create.record.s.$strongRef"],
),
(
create(json!({ "s": { "$strongRef": ".", "x": 1 } })),
vec!["list.layout.props.create.record.s"],
),
(
create(json!({ "s": { "$rkey": "a b" } })),
vec!["list.layout.props.create.record.s.$rkey"],
),
(
create(json!({ "s": { "$rkey": "uri", "x": 1 } })),
vec!["list.layout.props.create.record.s"],
),
(
create(json!({ "$link": "x" })),
vec!["list.layout.props.create.record.$link"],
),
(
create(json!({ "a": [{ "b": { "$": "no spaces" } }] })),
vec!["list.layout.props.create.record.a[0].b.$"],
),
(
create(json!({ "big": "x".repeat(5000) })),
vec!["list.layout.props.create.record"],
),
] {
assert_eq!(wheres(&doc), want, "{doc}");
}
// The bundled thread and feeds like and repost each card.
for (v, mode, strong) in [
(
for_method("app.bsky.feed.getPostThread").unwrap(),
"query",
"post",
),
(
for_method("app.bsky.feed.getFeed").unwrap(),
"query",
"post",
),
(
for_method("app.bsky.feed.getAuthorFeed").unwrap(),
"query",
"post",
),
] {
let text = v.doc[mode].to_string();
for c in ["app.bsky.feed.like", "app.bsky.feed.repost"] {
assert!(
text.contains(&format!("\"collection\":\"{c}\"")),
"{mode} {c}"
);
}
assert!(
text.contains(&format!("{{\"$strongRef\":\"{strong}\"}}")),
"{mode}"
);
}
}
#[test]
fn document_props() {
let doc = |props: Value| {
json!({ "collection": "site.standard.document", "description": "Posts",
"record": { "layout": { "component": "Document", "props": props } } })
};
assert!(parse(&doc(json!({ "value": { "$": "value.content" } })), false).is_ok());
assert!(
parse(
&doc(json!({ "value": { "$": "value.content" }, "fallback": { "$": "value.textContent" } })),
false
)
.is_ok()
);
let found = |props: Value| problems(&doc(props), false);
assert_eq!(
found(json!({ "fallback": { "$": "value.textContent" } })),
["record.layout.props.value: Document requires it"]
);
assert_eq!(
found(json!({ "value": { "$type": "pub.leaflet.content", "pages": [] } })),
["record.layout.props.value: must be a binding {\"$\": path}"]
);
assert_eq!(
found(json!({ "value": { "$": "value.content" }, "fallback": "no text" })),
["record.layout.props.fallback: must be a binding {\"$\": path}"]
);
assert_eq!(
found(json!({ "value": { "$": "value.content" }, "markdown": true })),
["record.layout.props.markdown: Document has no prop \"markdown\""]
);
let mut with_children = doc(json!({ "value": { "$": "value.content" } }));
with_children["record"]["layout"]["children"] = json!([]);
assert_eq!(
problems(&with_children, false),
["record.layout.children: Document takes no children"]
);
}
#[test]
fn an_inline_view() {
let doc = posts(
json!({ "component": "List", "props": { "items": { "$": "records" }, "style": "cards" },
"children": [
{ "component": "Text", "props": { "value": { "$": "value.text" } } },
{ "component": "Time", "props": { "value": { "$": ["value.createdAt", "value.indexedAt"] } } },
] }),
);
let v = parse(&doc, false).unwrap();
assert_eq!(v.collection.as_deref(), Some("app.bsky.feed.post"));
assert!(v.record.is_none() && v.origins.is_empty());
}
#[test]
fn components_and_props() {
let doc = posts(
json!({ "component": "Stack", "props": { "gap": { "$": "value.gap" } }, "children": [
{ "component": "Marquee", "props": {} },
{ "component": "Text", "props": { "value": "hi", "color": "red" } },
{ "component": "Text", "props": {} },
{ "component": "Text", "props": { "value": { "$": "value..text" } } },
{ "component": "Text", "props": { "value": { "$": "value.text", "x": 1 } } },
{ "component": "Text", "props": { "value": "a", "style": "loud" } },
{ "component": "Image", "props": { "src": { "$": "a-b" } } },
{ "component": "Badge", "props": { "value": "a" }, "children": [] },
{ "component": "List", "props": { "items": [1, 2] } },
{ "component": "Header", "props": { "meta": ["a", { "$": "handle" }, 3] } },
{ "component": "Covers", "props": { "items": { "$": "records" }, "src": { "$": "value.a" }, "countNoun": { "$": "x" } } },
] }),
);
assert_eq!(
wheres(&doc),
[
"list.layout.props.gap",
"list.layout.children[0].component",
"list.layout.children[1].props.color",
"list.layout.children[2].props.value",
"list.layout.children[3].props.value.$",
"list.layout.children[4].props.value",
"list.layout.children[5].props.style",
"list.layout.children[6].props.src.$",
"list.layout.children[7].children",
"list.layout.children[8].props.items",
"list.layout.children[9].props.meta[2]",
"list.layout.children[10].props.countNoun",
]
);
let text = error_text(&problems(&doc, false));
assert!(text.starts_with("Invalid view: 12 problems: list.layout.props.gap: must be a literal value, not a binding; "), "{text}");
// Past 20 problems, how many more.
let many: Vec<String> = (0..25)
.map(|i| format!("view: unknown key \"k{i}\""))
.collect();
let text = error_text(&many);
assert!(
text.starts_with("Invalid view: 25 problems: view: unknown key \"k0\"; "),
"{text}"
);
assert!(
text.ends_with("view: unknown key \"k19\"; and 5 more"),
"{text}"
);
let text = error_text(&problems(&doc, false));
assert!(
text.contains(
"list.layout.children[3].props.value.$: unknown path syntax \"value..text\""
),
"{text}"
);
assert!(text.contains("unknown component \"Marquee\""), "{text}");
}
/// A Stack's, Pane's or Bar's when and unless is a path or a gate on
/// the kit, `{"$kit": semver requirement}`; any node's fallback is a
/// node, checked as one.
#[test]
fn gates_on_the_kit_and_fallbacks_are_checked() {
let text = json!({ "component": "Text", "props": { "value": "x" } });
let gated = |key: &str, gate: Value| json!({ "component": "Stack", "props": { key: gate }, "children": [text.clone()] });
let good = posts(json!({ "component": "Stack", "children": [
gated("when", json!({ "$kit": ">=0.3.0" })),
gated("unless", json!({ "$kit": ">=0.3.0, <1" })),
gated("when", json!("record.value.text")),
{ "component": "Pane", "props": { "label": "A", "when": { "$kit": "^0.3" } }, "children": [text.clone()] },
{ "component": "Text", "props": { "value": "x" }, "fallback": text.clone() },
] }));
assert_eq!(problems(&good, false), Vec::<String>::new());
let bad = posts(json!({ "component": "Stack", "children": [
gated("when", json!({ "$kit": "soon" })),
gated("unless", json!({ "$kit": ">=0.3.0", "or": 1 })),
gated("when", json!("a..b")),
{ "component": "Text", "props": { "value": "x" }, "fallback": { "component": "Marquee" } },
{ "component": "Text", "props": { "value": "x" }, "fallback": { "component": "Text", "props": { "value": "x" }, "extra": 1 } },
] }));
assert_eq!(
wheres(&bad),
[
"list.layout.children[0].props.when",
"list.layout.children[1].props.unless",
"list.layout.children[2].props.when",
"list.layout.children[3].fallback.component",
"list.layout.children[4].fallback",
]
);
assert!(
problems(&bad, false)[0].ends_with("must be a path, keys joined by dots, or {\"$kit\": a semver requirement, as \">=0.3.0\"}"),
"{:?}",
problems(&bad, false)
);
}
#[test]
fn tabs_icons_and_literal_items() {
let issues = |state: &str| json!({ "query": "com.example.listIssues", "params": { "state": state, "repo": { "$root": "did" } } });
let good = posts(json!({ "component": "Stack", "children": [
{ "component": "Tabs", "props": { "items": [
{ "label": "Open", "open": issues("open") },
{ "label": "Closed", "open": issues("closed") },
] } },
{ "component": "List", "props": { "items": [
{ "label": "Issues", "icon": "issue", "tint": "green", "count": { "$root": "records" },
"more": { "$root": "cursor" }, "deeper": [{ "x": { "$root": "did" } }], "open": issues("open") },
{ "label": "Stars", "icon": "star", "tint": "yellow", "$type": "a.b.c" },
] }, "children": [{ "component": "Row", "children": [
{ "component": "Icon", "props": { "name": { "$": "icon" }, "tint": { "$": "tint" } } },
{ "component": "Icon", "props": { "name": "pull", "tint": "purple" } },
{ "component": "Text", "props": { "value": { "$": "label" } } },
{ "component": "Stat", "props": { "value": { "$": "count" }, "more": { "$": "more" } } },
] }] },
] }));
assert_eq!(problems(&good, false), Vec::<String>::new());
let many: Vec<Value> = (0..21).map(|i| json!({ "n": i })).collect();
let bad = posts(json!({ "component": "Stack", "children": [
{ "component": "Tabs", "props": { "items": [{ "label": "One", "open": issues("open") }] } },
{ "component": "Tabs", "props": { "items": [
{ "label": "No open" },
{ "label": "", "open": issues("closed") },
{ "label": "Bad", "open": { "query": "no" }, "extra": 1 },
{ "label": "Nothing", "open": false },
] } },
{ "component": "Tabs", "props": { "items": { "$": "tabs" } } },
{ "component": "List", "props": { "items": many } },
{ "component": "List", "props": { "items": [
{ "a": { "$": "x" } },
{ "b": [{ "c": { "$root": "a b" } }] },
{ "open": { "query": "no" } },
"row",
] } },
{ "component": "Icon", "props": { "name": "rocket", "tint": "teal" } },
{ "component": "Stat", "props": { "value": 1, "more": "yes" } },
] }));
assert_eq!(
wheres(&bad),
[
"list.layout.children[0].props.items",
"list.layout.children[1].props.items[0].open",
"list.layout.children[1].props.items[1].label",
"list.layout.children[1].props.items[2]",
"list.layout.children[1].props.items[2].open.query",
"list.layout.children[1].props.items[3].open",
"list.layout.children[2].props.items",
"list.layout.children[3].props.items",
"list.layout.children[4].props.items",
"list.layout.children[5].props.name",
"list.layout.children[5].props.tint",
"list.layout.children[6].props.more",
]
);
let rows = posts(json!({ "component": "List", "props": { "items": [
{ "a": { "$": "x" } },
{ "b": [{ "c": { "$root": "a b" } }] },
{ "open": { "query": "no" } },
] } }));
assert_eq!(
wheres(&rows),
[
"list.layout.props.items[0].a",
"list.layout.props.items[1].b[0].c.$root",
"list.layout.props.items[2].open.query",
]
);
}
#[test]
fn documents() {
// Unknown keys, a missing collection and modes, a bad type, an
// origin no bundled view names.
let doc = json!({ "$type": "x.y.z", "description": "d", "extra": 1, "origins": ["https://a.example"] });
assert_eq!(
wheres(&doc),
["view", "view.$type", "view", "view.origins[0]", "view"]
);
// Trusted, origins are checked and kept.
let mut trusted = posts(json!({ "component": "Badge", "props": { "value": "x" } }));
trusted["origins"] = json!(["https://a.example", "https://b.example:8443/"]);
assert_eq!(
parse(&trusted, true).unwrap().origins,
["https://a.example", "https://b.example:8443"]
);
for bad in [
"http://a.example",
"https://a.example/path",
"https://u@a.example",
"https://A.example",
] {
trusted["origins"] = json!([bad]);
assert_eq!(problems(&trusted, true).len(), 1, "{bad}");
}
// Inline, only the origins a bundled view names: those load where
// any view is drawn already.
trusted["origins"] = json!(["https://a.example"]);
let refused = problems(&trusted, false);
assert_eq!(refused.len(), 1);
assert!(
refused[0].starts_with(
"view.origins[0]: a view given inline names only origins a bundled view names: "
) && refused[0].contains("https://cdn.bsky.app"),
"{refused:?}"
);
// Thumbnails: a trusted view's, on its origins.
trusted["thumbnails"] =
json!([{ "from": "https://a.example/big/", "to": "https://a.example/small/" }]);
assert!(problems(&trusted, true).is_empty());
for bad in [
json!([{ "from": "https://b.example/big/", "to": "https://a.example/small/" }]),
json!([{ "from": "https://a.example/big", "to": "https://a.example/small/" }]),
json!([{ "from": "https://a.example/big/" }]),
json!([]),
] {
trusted["thumbnails"] = bad.clone();
assert_eq!(problems(&trusted, true).len(), 1, "{bad}");
}
// Inline, thumbnails on origins a bundled view names are kept.
let mut inline = trusted.clone();
inline["origins"] = json!(["https://cdn.bsky.app"]);
inline["thumbnails"] = json!([{ "from": "https://cdn.bsky.app/img/avatar/plain/",
"to": "https://cdn.bsky.app/img/avatar_thumbnail/plain/" }]);
assert_eq!(
parse(&inline, false).unwrap().origins,
["https://cdn.bsky.app"]
);
// A mode needs its layout.
let doc = json!({ "collection": "a.b.c", "description": "d", "record": {} });
assert_eq!(problems(&doc, false), ["record: layout required"]);
}
#[test]
fn limits() {
let mut deep = json!({ "component": "Badge", "props": { "value": "x" } });
for _ in 0..12 {
deep = json!({ "component": "Stack", "children": [deep] });
}
assert!(
problems(&posts(deep), false)
.iter()
.any(|p| p.contains("nest at most 12"))
);
let many: Vec<Value> = (0..200)
.map(|_| json!({ "component": "Badge", "props": { "value": "x" } }))
.collect();
let wide = posts(json!({ "component": "Stack", "children": many }));
assert!(
problems(&wide, false)
.iter()
.any(|p| p.contains("201 nodes"))
);
let big = posts(json!({ "component": "Text", "props": { "value": "x".repeat(70_000) } }));
assert!(problems(&big, false)[0].contains("more than the 65536"));
let mut path = String::from("value");
for _ in 0..10 {
path.push_str(".k");
}
let long = posts(json!({ "component": "Text", "props": { "value": { "$": path } } }));
assert_eq!(problems(&long, false).len(), 1);
// Joins: depth 3 at most, 8 to a level.
let mut joins = json!([{ "as": "a", "ref": "value.x" }]);
for _ in 0..3 {
joins = json!([{ "as": "a", "ref": "value.x", "join": joins }]);
}
let mut doc = posts(json!({ "component": "Badge", "props": { "value": "x" } }));
doc["list"]["join"] = joins;
assert_eq!(wheres(&doc), ["list.join[0].join[0].join[0].join"]);
doc["list"]["join"] = Value::Array(
(0..9)
.map(|i| json!({ "as": format!("j{i}"), "ref": "value.x" }))
.collect(),
);
assert_eq!(wheres(&doc), ["list.join"]);
}
#[test]
fn joins_checked() {
let mut doc = posts(json!({ "component": "Badge", "props": { "value": "x" } }));
doc["list"]["join"] = json!([
{ "as": "a" },
{ "as": "b", "each": "value.items" },
{ "as": "c", "backlinks": { "collection": "a.b.c" } },
{ "as": "d", "ref": "value.x", "limit": 3, "orderBy": ["value.y"] },
{ "as": "e", "backlinks": { "collection": "a.b.c", "path": "value.p" }, "ref": "value.x", "collection": "a.b.c" },
{ "as": "f", "ref": "value x" },
{ "as": "a.b", "ref": "value.x" },
{ "as": "g", "each": "value.items", "ref": "subject", "limit": 501 },
{ "as": "h", "ref": "value.x", "collection": "nope" },
{ "as": "d", "ref": "value.x" },
]);
let found = problems(&doc, false);
assert_eq!(
found
.iter()
.map(|p| p.split_once(": ").unwrap().0)
.collect::<Vec<_>>(),
[
"list.join",
"list.join[0]",
"list.join[1]",
"list.join[2].backlinks.path",
"list.join[3].orderBy",
"list.join[3].limit",
"list.join[4]",
"list.join[4].collection",
"list.join[5].ref",
"list.join[6].as",
"list.join[7].limit",
"list.join[8].collection",
"list.join[9].as",
]
);
assert_eq!(found[0], "list.join: 10 joins, more than 8");
assert_eq!(
found[1],
"list.join[0]: \"ref\", \"backlinks\" or \"counts\" required"
);
let good = json!([{ "as": "items", "backlinks": { "collection": "social.grain.gallery.item", "path": "value.gallery" },
"orderBy": ["value.position", "value.createdAt"], "limit": 1,
"join": [{ "as": "photo", "ref": "value.item", "collection": "social.grain.photo" }] }]);
doc["list"]["join"] = good;
let v = parse(&doc, false).unwrap();
let j = &v.list.unwrap().join[0];
assert_eq!((j.limit, j.order_by.len(), j.join.len()), (1, 2, 1));
}
#[test]
fn counts_checked() {
let mut doc = posts(
json!({ "component": "Stat", "props": { "value": { "$": "joins.c.likes" }, "icon": "heart", "label": "likes" } }),
);
doc["list"]["join"] = json!([{ "as": "c", "counts": {
"likes": { "collection": "app.bsky.feed.like", "path": ".subject.uri" },
"quotes": { "collection": "app.bsky.feed.post", "path": ".embed[app.bsky.embed.record].record.uri" } } }]);
let v = parse(&doc, false).unwrap();
assert_eq!(
v.list.unwrap().join[0].source,
Source::Counts(vec![
(
"likes".into(),
"app.bsky.feed.like".into(),
".subject.uri".into()
),
(
"quotes".into(),
"app.bsky.feed.post".into(),
".embed[app.bsky.embed.record].record.uri".into()
),
])
);
let nine: Map<String, Value> = (0..9)
.map(|i| {
(
format!("n{i}"),
json!({ "collection": "a.b.c", "path": ".x" }),
)
})
.collect();
doc["list"]["join"] = json!([
{ "as": "a", "counts": {} },
{ "as": "b", "counts": nine },
{ "as": "c", "counts": { "bad-name": { "collection": "a.b.c", "path": ".x" } } },
{ "as": "d", "counts": { "n": { "collection": "nope", "path": "subject" } } },
{ "as": "e", "counts": { "n": { "collection": "a.b.c", "path": ".x", "extra": 1 } } },
{ "as": "f", "counts": { "n": { "collection": "a.b.c", "path": ".x" } }, "limit": 3, "join": [] },
{ "as": "g", "counts": [] },
]);
assert_eq!(
wheres(&doc),
[
"list.join[0].counts",
"list.join[1].counts",
"list.join[2].counts.bad-name",
"list.join[3].counts.n.collection",
"list.join[3].counts.n.path",
"list.join[4].counts.n",
"list.join[5].limit",
"list.join[5].join",
"list.join[6].counts",
]
);
// Stat's icon and label are literals, its value a number or binding.
let stat = |props: Value| {
problems(
&posts(json!({ "component": "Stat", "props": props })),
false,
)
};
assert_eq!(
stat(json!({ "value": 3, "icon": "heart" })),
Vec::<String>::new()
);
assert_eq!(
stat(json!({ "value": "many", "icon": "fire", "label": { "$": "x" } })).len(),
3
);
}
#[test]
fn summaries_checked() {
let mut doc = posts(json!({ "component": "Badge", "props": { "value": "x" } }));
doc["list"]["summary"] = json!({ "label": 3, "detail": { "noun": ["a"] } });
assert_eq!(
wheres(&doc),
[
"list.summary.noun",
"list.summary.label",
"list.summary.detail.count",
"list.summary.detail.noun"
]
);
}
/// A mode's head: its known keys, a type of Open Graph's, templates as
/// an action's record's, structured data an object, its `$each` an
/// array and a template, nested at most so deep.
#[test]
fn heads_checked() {
let mut doc = posts(json!({ "component": "Badge", "props": { "value": "x" } }));
let fine = json!({ "title": { "$join": [{ "$": "handle" }, " on Grain"] }, "type": "profile",
"noindex": true, "canonical": "/x",
"jsonLd": { "@type": "ItemList", "itemListElement": [
{ "$each": [{ "$": "records" }, { "url": { "$": "uri" }, "n": [1] }] }] } });
doc["list"]["head"] = fine;
assert_eq!(problems(&doc, false), Vec::<String>::new());
let mut odd = doc.clone();
odd["list"]["head"] = json!("Coast");
assert_eq!(wheres(&odd), ["list.head"]);
let mut deep = json!(1);
for _ in 0..MAX_DEPTH {
deep = json!([deep]);
}
doc["list"]["head"] = json!({ "type": "page", "jsonLd": [], "title": { "$first": [1] },
"image": { "$": "a..b" }, "x": { "$": "a" } });
doc["record"] = json!({ "head": { "jsonLd": { "a": { "$each": [1] }, "b": { "$join": ["a"] }, "c": deep } },
"layout": { "component": "Badge", "props": { "value": "x" } } });
assert_eq!(
wheres(&doc),
[
"list.head",
"list.head.type",
"list.head.jsonLd",
"list.head.title",
"list.head.image.$",
"record.head.jsonLd.a",
"record.head.jsonLd.b",
"record.head.jsonLd.c[0][0][0][0][0][0][0][0][0][0][0]",
]
);
}
#[test]
fn paths() {
let v = json!({ "records": [{ "value": { "t": "x" } }], "a": { "b$_1": 2 } });
assert_eq!(
Path::parse("records.0.value.t").unwrap().get(&v),
Some(&json!("x"))
);
assert_eq!(Path::parse("a.b$_1").unwrap().get(&v), Some(&json!(2)));
assert_eq!(Path::parse("records.1.value").unwrap().get(&v), None);
assert_eq!(Path::parse("records.x").unwrap().get(&v), None);
// `.` is the scope itself, as for an array of strings' items.
assert_eq!(
Path::parse(".").unwrap().get(&json!("tag")),
Some(&json!("tag"))
);
for bad in [
"",
"..",
"a.",
".a",
"a..b",
"a-b",
"a b",
"a.b.c.d.e.f.g.h.i.j.k",
] {
assert_eq!(Path::parse(bad), None, "{bad}");
}
let b = Binding(vec![
Path::parse("a.missing").unwrap(),
Path::parse("a.b$_1").unwrap(),
]);
assert_eq!(b.get(&v), Some(&json!(2)));
}
#[test]
fn csp() {
let view = |origins: &[&str]| {
let mut doc = posts(json!({ "component": "Badge", "props": { "value": "x" } }));
doc["origins"] = json!(origins);
parse(&doc, true).unwrap()
};
let views = [
view(&["https://images.plyr.fm", "https://audio.plyr.fm"]),
view(&["https://cdn.example", "https://audio.plyr.fm"]),
];
assert_eq!(
origins_of("http://localhost:8787", views.iter()),
[
"http://localhost:8787",
"https://audio.plyr.fm",
"https://cdn.example",
"https://images.plyr.fm",
]
);
let bundled = csp_origins("https://hud.example");
assert!(!bundled.iter().any(|b| b == catalog::MAP_TILES));
for o in [
"https://hud.example",
"https://audio.plyr.fm",
"https://images.plyr.fm",
"https://cdn.bsky.app",
] {
assert!(bundled.iter().any(|b| b == o), "{o} in {bundled:?}");
}
assert!(bundled.windows(2).all(|w| w[0] < w[1]), "{bundled:?}");
}
/// A feed's view, as a model might write one.
fn feed_view() -> Value {
json!({ "method": "app.bsky.feed.getFeed", "service": "did:web:api.bsky.app#bsky_appview",
"description": "A feed",
"query": { "items": "feed", "cursor": "cursor",
"summary": { "noun": ["post", "posts"], "label": { "$": "post.record.text" } },
"layout": { "component": "List", "props": { "items": { "$": "items" }, "open": { "$": "post.uri" } },
"children": [{ "component": "Text", "props": { "value": { "$": "post.record.text" } } },
{ "component": "Image", "props": { "src": { "$": "post.author.avatar" }, "size": "avatar" } }] } } })
}
#[test]
fn method_views() {
let v = parse(&feed_view(), false).unwrap();
assert_eq!(
(
v.method.as_deref(),
v.service.as_deref(),
v.collection.as_deref()
),
(
Some("app.bsky.feed.getFeed"),
Some("did:web:api.bsky.app#bsky_appview"),
None
)
);
let q = v.query.unwrap();
assert_eq!(
(q.items, q.cursor),
(Path::parse("feed"), Path::parse("cursor"))
);
// Both a collection and a method: refused.
let mut both = feed_view();
both["collection"] = json!("app.bsky.feed.post");
assert_eq!(
problems(&both, false),
["view: a view draws a collection or a method, not both"]
);
// A method view: a service, the query mode alone.
let mut v = feed_view();
v["service"] = json!("did:web:api.bsky.app");
v["list"] = json!({ "layout": { "component": "Badge", "props": { "value": "x" } } });
v["pageSize"] = json!(10);
v["query"]["nope"] = json!([]);
// Without items, a cursor pages nothing.
v["query"].as_object_mut().unwrap().remove("items");
assert_eq!(
wheres(&v),
[
"view.service",
"view.pageSize",
"view.list",
"query",
"query.cursor"
]
);
let mut no_query = feed_view();
no_query.as_object_mut().unwrap().remove("query");
no_query.as_object_mut().unwrap().remove("service");
assert_eq!(wheres(&no_query), ["view.service", "view"]);
// A collection view takes no service or query.
let mut c = posts(json!({ "component": "Badge", "props": { "value": "x" } }));
c["service"] = json!("did:web:api.bsky.app#bsky_appview");
c["query"] = feed_view()["query"].clone();
assert_eq!(wheres(&c), ["view.service", "view.query"]);
// Image's size is a literal.
let mut sized = feed_view();
sized["query"]["layout"]["children"][1]["props"]["size"] = json!("huge");
assert_eq!(wheres(&sized), ["query.layout.children[1].props.size"]);
// Text's prefix: a literal of 40 characters at most.
let text = |prefix: Value| {
problems(
&posts(
json!({ "component": "Text", "props": { "value": { "$": "value.text" }, "prefix": prefix } }),
),
false,
)
};
assert!(text(json!("Reposted by ")).is_empty());
assert_eq!(text(json!("x".repeat(41))).len(), 1);
assert_eq!(text(json!("two\nlines")).len(), 1);
assert_eq!(text(json!({ "$": "value.by" })).len(), 1);
}
#[test]
fn opens_checked() {
let list = |open: Value| {
posts(json!({ "component": "List",
"props": { "items": { "$": "records" }, "open": open },
"children": [{ "component": "Badge", "props": { "value": "x" } }] }))
};
let at = "list.layout.props.open";
for ok in [
json!({ "$": "uri" }),
json!({ "query": "app.bsky.feed.getPostThread", "params": { "uri": { "$": "uri" } } }),
json!({ "query": "app.bsky.feed.getPostThread" }),
json!({ "query": "app.bsky.feed.getAuthorFeed", "service": "did:web:api.bsky.app#bsky_appview",
"params": { "actor": { "$": ["did", "handle"] }, "limit": 5, "filter": ["a"], "x": { "k": 1 } } }),
// The view's own scope, an at-uri built of parts, an array of params.
json!({ "query": "a.b.c", "params": {
"repo": { "$root": "params.repo" },
"made": { "$atUri": [{ "$": "repo.did" }, "a.b.repo", { "$root": "params.name" }] },
"paths": [{ "$": "old" }, { "$": "new" }, "README.md"] } }),
// What it shows first, and its screen over what is open.
json!({ "query": "a.b.c", "at": { "$": "uri" }, "sheet": true }),
// Its screen opened at a form: its first, or one by label.
json!({ "query": "a.b.c", "compose": true }),
json!({ "query": "a.b.c", "compose": "New gallery" }),
// At its form only while nothing is at a path (one's own stories).
json!({ "query": "a.b.c", "compose": true, "unless": "stories" }),
json!(false),
] {
assert_eq!(
problems(&list(ok.clone()), false),
Vec::<String>::new(),
"{ok}"
);
}
let nine: serde_json::Map<String, Value> =
(0..9).map(|i| (format!("p{i}"), json!(i))).collect();
for (open, want) in [
(json!("at://did:plc:x/a.b.c/1"), at.to_string()),
(json!({ "params": {} }), format!("{at}.query")),
(json!({ "query": "not an nsid" }), format!("{at}.query")),
(
json!({ "query": "a.b.c", "params": [] }),
format!("{at}.params"),
),
(
json!({ "query": "a.b.c", "params": nine }),
format!("{at}.params"),
),
(
json!({ "query": "a.b.c", "params": { "a-b": 1 } }),
format!("{at}.params.a-b"),
),
(
json!({ "query": "a.b.c", "params": { "uri": { "$": "no spaces" } } }),
format!("{at}.params.uri.$"),
),
(
json!({ "query": "a.b.c", "service": "did:web:x" }),
format!("{at}.service"),
),
(json!({ "query": "a.b.c", "method": "x" }), at.to_string()),
(
json!({ "query": "a.b.c", "params": { "repo": { "$root": "no spaces" } } }),
format!("{at}.params.repo.$root"),
),
(
json!({ "query": "a.b.c", "params": { "repo": { "$root": "a", "x": 1 } } }),
format!("{at}.params.repo"),
),
(
json!({ "query": "a.b.c", "params": { "repo": { "$atUri": ["a", "b"] } } }),
format!("{at}.params.repo.$atUri"),
),
(
json!({ "query": "a.b.c", "params": { "repo": { "$atUri": ["a", 1, "c"] } } }),
format!("{at}.params.repo.$atUri[1]"),
),
(
json!({ "query": "a.b.c", "params": { "repo": { "$now": true } } }),
format!("{at}.params.repo"),
),
(
json!({ "query": "a.b.c", "params": { "paths": [["a"]] } }),
format!("{at}.params.paths[0]"),
),
(
json!({ "query": "a.b.c", "sheet": "yes" }),
format!("{at}.sheet"),
),
(
json!({ "query": "a.b.c", "compose": "" }),
format!("{at}.compose"),
),
(
json!({ "query": "a.b.c", "compose": 1 }),
format!("{at}.compose"),
),
(
json!({ "query": "a.b.c", "compose": true, "unless": "no spaces" }),
format!("{at}.unless"),
),
(
json!({ "query": "a.b.c", "unless": "stories" }),
format!("{at}.unless"),
),
(
json!({ "query": "a.b.c", "at": { "$": "no spaces" } }),
format!("{at}.at.$"),
),
(json!(true), at.to_string()),
] {
assert_eq!(wheres(&list(open.clone())), [want], "{open}");
}
// Covers takes either form too.
let covers = posts(json!({ "component": "Covers", "props": {
"items": { "$": "records" }, "src": { "$": "value.a" },
"open": { "query": "app.bsky.feed.getPostThread", "params": { "uri": { "$": "uri" } } } } }));
assert_eq!(problems(&covers, false), Vec::<String>::new());
}
/// The host's accounts are drawn where a bundled view places them, never
/// an inline one.
#[test]
fn accounts_are_a_bundled_views_alone() {
let accounts = posts(json!({ "component": "Accounts", "children": [
{ "component": "Badge", "props": { "value": "x" } }] }));
assert_eq!(problems(&accounts, true), Vec::<String>::new());
assert_eq!(wheres(&accounts), ["list.layout.component"]);
}
/// An open may be an https page, or, in a bundled view alone, what the
/// host does itself; never both, and never a tab's.
#[test]
fn opens_a_page_or_the_hosts_own() {
let list = |open: Value| {
posts(json!({ "component": "List",
"props": { "items": { "$": "records" }, "open": open },
"children": [{ "component": "Badge", "props": { "value": "x" } }] }))
};
let at = "list.layout.props.open";
let page = json!({ "url": "https://grain.social/settings/import" });
let host = json!({ "host": "signOut" });
assert_eq!(problems(&list(page.clone()), false), Vec::<String>::new());
assert_eq!(problems(&list(host.clone()), true), Vec::<String>::new());
for (open, trusted, want) in [
(host, false, at.to_string()),
(
json!({ "host": "deleteAccount" }),
true,
format!("{at}.host"),
),
(json!({ "host": 1 }), true, format!("{at}.host")),
(
json!({ "url": "http://grain.social" }),
false,
format!("{at}.url"),
),
(json!({ "url": "grain.social" }), false, format!("{at}.url")),
(json!({ "url": 5 }), false, format!("{at}.url")),
(
json!({ "url": "https://a.example", "host": "signOut" }),
true,
at.to_string(),
),
] {
let found: Vec<String> = problems(&list(open.clone()), trusted)
.iter()
.map(|p| p.split_once(": ").unwrap().0.to_string())
.collect();
assert_eq!(found, [want], "{open}");
}
// A tab draws a query.
let tabs = posts(json!({ "component": "Tabs", "props": { "items": [
{ "label": "A", "open": { "query": "a.b.c" } },
{ "label": "B", "open": page } ] } }));
assert_eq!(wheres(&tabs), ["list.layout.props.items[1].open"]);
// So does a List's more chip, which opens something.
let more = |more: Value| {
posts(
json!({ "component": "List", "props": { "items": { "$": "records" },
"style": "chips", "more": more }, "children": [] }),
)
};
assert!(
wheres(&more(
json!({ "label": "See all", "open": { "query": "a.b.c" } })
))
.is_empty()
);
assert_eq!(
wheres(&more(json!({ "label": "See all", "open": page }))),
["list.layout.props.more.open"]
);
assert_eq!(
wheres(&more(json!({ "label": "See all" }))),
["list.layout.props.more.open"]
);
assert_eq!(wheres(&more(json!("See all"))), ["list.layout.props.more"]);
}
#[test]
fn states_labels_diffs_and_links() {
let layout = |node: Value| {
posts(json!({ "component": "List",
"props": { "items": { "$": "records" } }, "children": [node] }))
};
let node =
|component: &str, props: Value| json!({ "component": component, "props": props });
for ok in [
node(
"State",
json!({ "value": { "$": "value.state" }, "of": { "$": "value.kind" },
"roles": { "pull/open": "open-pull", "merged": "merged" },
"words": { "open": "Open" }, "style": "pill" }),
),
node(
"Label",
json!({ "name": { "$": "value.name" }, "color": "#d73a4a" }),
),
node(
"Diff",
json!({ "path": { "$": "value.new" }, "rows": { "$": "value.rows" },
"kinds": { "added": "a", "removed": "d" } }),
),
node("Diff", json!({ "path": "README.md", "added": 3 })),
node(
"Link",
json!({ "label": "Repo", "open": { "query": "a.b.c", "params": { "repo": { "$": "uri" } } } }),
),
node(
"Text",
json!({ "value": { "$": "value.sha" }, "chars": 7, "style": "strong",
"words": { "a": "b" } }),
),
json!({ "component": "List", "props": { "items": { "$root": "records" }, "where": { "commit": "value.sha" },
"title": "Checks", "empty": "No checks" },
"children": [node("Badge", json!({ "value": "x" }))] }),
] {
assert_eq!(
problems(&layout(ok.clone()), false),
Vec::<String>::new(),
"{ok}"
);
}
let at = "list.layout.children[0]";
for (bad, want) in [
// A state's roles are literal, and only roles there are.
(
node("State", json!({ "value": "x" })),
format!("{at}.props.roles"),
),
(
node(
"State",
json!({ "value": "x", "roles": { "open": "green" } }),
),
format!("{at}.props.roles"),
),
(
node(
"State",
json!({ "value": "x", "roles": { "$": "value.roles" } }),
),
format!("{at}.props.roles"),
),
(
node("Text", json!({ "value": "x", "words": {} })),
format!("{at}.props.words"),
),
// A diff's kinds are those four alone.
(
node("Diff", json!({ "path": "a", "kinds": { "context": " " } })),
format!("{at}.props.kinds"),
),
(
node("Diff", json!({ "path": "a", "rows": [] })),
format!("{at}.props.rows"),
),
// A link takes href or open, one of them.
(node("Link", json!({ "label": "x" })), format!("{at}.props")),
(
node(
"Link",
json!({ "href": "https://x.example", "open": { "query": "a.b.c" } }),
),
format!("{at}.props"),
),
// Only a list's items read the view's own scope, by a path.
(
node(
"Gallery",
json!({ "items": { "$root": "records" }, "src": { "$": "a" } }),
),
format!("{at}.props.items"),
),
(
json!({ "component": "List", "props": { "items": { "$root": "no spaces" } } }),
format!("{at}.props.items.$root"),
),
(
json!({ "component": "List", "props": { "items": { "$": "records" }, "where": { "a b": "c" } } }),
format!("{at}.props.where.a b"),
),
] {
assert_eq!(wheres(&layout(bad.clone())), [want], "{bad}");
}
}
/// `app`, `profile` and `activity` are a bundled view's alone, checked
/// as the rest: a method view's section its query's params, `$actor`
/// the account's DID; a collection view's how many records, 3 by
/// default; activity a short verb, of a collection view whose list has
/// a summary to name its records by.
#[test]
fn apps_and_profile_sections() {
let method = |trusted: bool, extra: Value| {
let mut doc = json!({ "method": "a.b.c", "service": "did:web:x.example#svc", "description": "d",
"query": { "layout": { "component": "Badge", "props": { "value": "x" } } } });
doc.as_object_mut()
.unwrap()
.extend(extra.as_object().unwrap().clone());
parse(&doc, trusted)
};
let records = |trusted: bool, extra: Value| {
let mut doc = posts(json!({ "component": "Badge", "props": { "value": "x" } }));
doc.as_object_mut()
.unwrap()
.extend(extra.as_object().unwrap().clone());
parse(&doc, trusted)
};
let v = method(
true,
json!({ "app": "Example", "profile": { "title": "Example",
"params": { "actor": { "$actor": "did" }, "limit": 3, "on": true } } }),
)
.unwrap();
assert_eq!(v.app.as_deref(), Some("Example"));
let s = v.profile.unwrap();
assert_eq!(
Value::Object(s.params_for("did:plc:a")),
json!({ "actor": "did:plc:a", "limit": 3, "on": true })
);
let s = records(true, json!({ "profile": { "title": "Posts" } }))
.unwrap()
.profile
.unwrap();
assert_eq!((s.title.as_str(), s.limit), ("Posts", 3));
let summed = json!({ "layout": { "component": "Badge", "props": { "value": "x" } },
"summary": { "noun": ["post", "posts"], "label": { "$": "value.text" } } });
let v = records(true, json!({ "list": summed, "activity": "Posted" })).unwrap();
assert_eq!(v.activity.as_deref(), Some("Posted"));
for (bad, want) in [
(
method(true, json!({ "profile": { "title": "x", "limit": 3 } })),
"view.profile: unknown key \"limit\"",
),
(
records(true, json!({ "profile": { "title": "x", "params": {} } })),
"view.profile: unknown key \"params\"",
),
(
records(true, json!({ "profile": { "title": "x", "limit": 11 } })),
"view.profile.limit: must be an integer from 1 to 10",
),
(
method(
true,
json!({ "profile": { "title": "x", "params": { "a": { "$actor": "handle" } } } }),
),
"view.profile.params.a: must be a string, number, boolean or {\"$actor\": \"did\"}, or an array of those",
),
(
records(true, json!({ "profile": {} })),
"view.profile.title: must be one line of text, 40 characters at most",
),
(
records(true, json!({ "app": "two\nlines" })),
"view.app: must be one line of text, 40 characters at most",
),
(
records(false, json!({ "app": "Example" })),
"view.app: only a bundled view names its app",
),
(
records(false, json!({ "profile": { "title": "x" } })),
"view.profile: only a bundled view adds a section to profiles",
),
(
records(false, json!({ "list": summed, "activity": "Posted" })),
"view.activity: only a bundled view names its activity",
),
(
method(true, json!({ "activity": "Posted" })),
"view.activity: only a collection view's records are activity",
),
(
records(true, json!({ "activity": "Posted" })),
"view.activity: activity names its records by the list's summary, which it needs",
),
(
records(
true,
json!({ "list": summed, "activity": "Posted and then posted again" }),
),
"view.activity: must be one line of text, 20 characters at most",
),
] {
assert_eq!(bad.unwrap_err(), [want]);
}
// A method view's records: each collection's params read from the
// record, and what making one is.
let routes = json!([
{ "collection": "a.b.post", "params": { "uri": { "$": "uri" }, "depth": 2 },
"activity": { "verb": "Posted", "noun": ["post", "posts"], "label": { "$": "value.text" } } },
{ "collection": "a.b.repost", "params": { "uri": { "$": ["value.subject.uri", "uri"] } } }
]);
let v = method(true, json!({ "records": routes })).unwrap();
assert_eq!(v.records.len(), 2);
let (post, repost) = (&v.records[0], &v.records[1]);
assert!(!post.reads_record() && repost.reads_record());
let rec = json!({ "uri": "at://did:plc:a/a.b.repost/1", "did": "did:plc:a",
"value": { "subject": { "uri": "at://did:plc:b/a.b.post/2" } } });
assert_eq!(
Value::Object(post.params_for(&rec).unwrap()),
json!({ "uri": "at://did:plc:a/a.b.repost/1", "depth": 2 })
);
assert_eq!(
repost.params_for(&rec).unwrap()["uri"],
"at://did:plc:b/a.b.post/2"
);
// A binding that finds nothing, or no scalar, gives no params.
let bare = json!({ "uri": "", "did": "did:plc:a", "value": { "subject": {} } });
assert!(post.params_for(&bare).is_none());
assert!(post.params_for(&json!({ "uri": { "x": 1 } })).is_none());
let a = post.activity.as_ref().unwrap();
assert_eq!(
(a.verb.as_str(), &a.summary.noun),
("Posted", &["post".to_string(), "posts".to_string()])
);
// What the answer shows first, read from the record too: a value of
// the record's read makes it read; one finding no string, none.
let at = json!([{ "collection": "a.b.story", "params": { "actor": { "$": "did" } }, "at": { "$": "value.first" } }]);
let story = &method(true, json!({ "records": at })).unwrap().records[0];
assert!(story.reads_record());
assert_eq!(
story.args_for(
"a.b.getArchive",
&json!({ "did": "did:plc:a", "value": { "first": "s1" } })
),
Some(
json!({ "method": "a.b.getArchive", "params": { "actor": "did:plc:a" }, "at": "s1" })
)
);
assert_eq!(
story.args_for(
"a.b.getArchive",
&json!({ "did": "did:plc:a", "value": { "first": 2 } })
),
Some(json!({ "method": "a.b.getArchive", "params": { "actor": "did:plc:a" } }))
);
assert_eq!(story.args_for("a.b.getArchive", &json!({})), None);
for (bad, want) in [
(
method(false, json!({ "records": routes })),
"view.records: only a bundled view names the records it draws",
),
(
records(true, json!({ "records": routes })),
"view.records: only a method view draws records, as its query",
),
(
method(true, json!({ "records": [] })),
"view.records: must be 1 to 8 collections",
),
(
method(
true,
json!({ "records": [{ "collection": "a.b.c", "params": { "x": { "$": "joins.y" } } }] }),
),
"view.records[0].params.x: reads the record: a path from uri, cid, did, value",
),
(
method(
true,
json!({ "records": [{ "collection": "a.b.c", "params": { "x": [1] } }] }),
),
"view.records[0].params.x: must be a binding {\"$\": path} into the record",
),
(
method(
true,
json!({ "records": [{ "collection": "a.b.c", "params": { "x": 1 }, "at": "uri" }] }),
),
"view.records[0].at: must be a binding {\"$\": path} into the record",
),
(
method(true, json!({ "records": [{ "collection": "a.b.c" }] })),
"view.records[0].params: must be an object of 1 to 8 params",
),
(
method(
true,
json!({ "records": [{ "collection": "a.b.c", "params": { "x": 1 } },
{ "collection": "a.b.c", "params": { "x": 1 } }] }),
),
"view.records[1].collection: a.b.c is named twice",
),
(
method(
true,
json!({ "records": [{ "collection": "a.b.c", "params": { "x": 1 },
"activity": { "verb": "Posted and then posted again", "noun": ["a", "b"] } }] }),
),
"view.records[0].activity.verb: must be one line of text, 20 characters at most",
),
] {
assert_eq!(bad.unwrap_err(), [want]);
}
}
/// Every bundled method view's profile section's params are its
/// method's, as its lexicon takes them (a bundled one, or knotless's
/// as it publishes them); Bluesky's posts are the author feed's.
#[test]
fn bundled_profile_sections_are_their_methods() {
let docs = lexicon_docs();
let mut seen = 0;
for b in bundled() {
let (Some(s), Some(method)) = (&b.view.profile, &b.view.method) else {
continue;
};
assert_eq!(
section_problems(s, method, &docs),
Vec::<String>::new(),
"{}",
b.id
);
seen += 1;
}
assert_eq!(seen, 4);
let message = for_method("chat.bsky.convo.getConvoAvailability").unwrap();
let head = message.profile.as_ref().unwrap();
assert!(head.head);
assert_eq!(
head.params_for("did:plc:a")["members"],
json!(["did:plc:a"])
);
assert_eq!(
for_method("dev.knotless.getActorRepos")
.and_then(|v| v.profile.as_ref())
.map(|s| s.title.as_str()),
Some("knotless")
);
let feed = for_method("app.bsky.feed.getAuthorFeed").unwrap();
assert_eq!(feed.profile.as_ref().unwrap().title, "Bluesky");
}
#[test]
fn sign_in_words_are_a_bundled_method_views() {
let view = |trusted: bool, extra: Value| {
let mut doc = json!({ "method": "a.b.c", "service": "did:web:x.example#svc", "description": "d",
"query": { "layout": { "component": "Badge", "props": { "value": "x" } } } });
doc.as_object_mut()
.unwrap()
.extend(extra.as_object().unwrap().clone());
parse(&doc, trusted)
};
let signed = view(true, json!({ "signIn": "Sign in to see your things" })).unwrap();
assert_eq!(
signed.sign_in.as_deref(),
Some("Sign in to see your things")
);
assert_eq!(
view(false, json!({ "signIn": "x" })).unwrap_err(),
["view.signIn: only a bundled view says what signing in shows"]
);
assert!(view(true, json!({ "signIn": "two\nlines" })).is_err());
assert_eq!(
for_method("dev.knotless.listNotifications").and_then(|v| v.sign_in.as_deref()),
Some("Sign in to see your notifications")
);
}
/// The paths a layout binds (`{"$": …}`), each binding's alternatives
/// together, but `$root`'s.
fn bound_paths(v: &Value, out: &mut Vec<Vec<String>>) {
match v {
// A binding's path, or its paths.
Value::Object(o) => match o.get("$") {
Some(p @ (Value::String(_) | Value::Array(_))) => out.push(
std::iter::once(p)
.chain(p.as_array().into_iter().flatten())
.filter_map(Value::as_str)
.map(str::to_string)
.collect(),
),
_ => o.values().for_each(|v| bound_paths(v, out)),
},
Value::Array(items) => items.iter().for_each(|v| bound_paths(v, out)),
_ => {}
}
}
/// knotless's notifications are an asker's alone, so no live call draws
/// them signed out: an answer as their lexicon says one is (as knotless
/// has it, in testdata/knotless), held to it as the query tool holds
/// the service's, summarized and drawn by the bundled view, every path
/// its rows bind there in one of them.
#[test]
fn the_knotless_notifications_view_draws_an_answer_its_lexicon_allows() {
let method = "dev.knotless.listNotifications";
let docs: Vec<std::sync::Arc<Value>> = [
include_str!("testdata/knotless/dev.knotless.listNotifications.json"),
include_str!("testdata/knotless/dev.knotless.defs.json"),
include_str!("testdata/knotless/dev.knotless.queue.json"),
]
.iter()
.map(|t| std::sync::Arc::new(serde_json::from_str(t).unwrap()))
.collect();
let answer: Value = serde_json::from_str(include_str!(
"testdata/knotless/listNotifications.answer.json"
))
.unwrap();
let lexicons = crate::xrpc::lexicons_for(method, &docs);
let def = crate::xrpc::query_def(method, &docs[0]).unwrap();
assert_eq!(
crate::xrpc::output_problem(&lexicons, method, def, &answer),
None
);
let mut wrong = answer.clone();
wrong["notifications"][0]["isRead"] = json!("no");
assert!(crate::xrpc::output_problem(&lexicons, method, def, &wrong).is_some());
let view = for_method(method).expect("the knotless notifications view");
assert_eq!(
view.service.as_deref(),
Some("did:web:knotless.dev#knotless_appview")
);
let q = view.query.as_ref().unwrap();
let items = q
.items
.as_ref()
.unwrap()
.get(&answer)
.and_then(Value::as_array)
.unwrap();
let cursor = q
.cursor
.as_ref()
.and_then(|c| c.get(&answer))
.and_then(Value::as_str);
assert_eq!(
crate::summary::query(
q.summary.as_ref().unwrap(),
method,
"knotless.dev",
items,
cursor
),
"3 notifications from dev.knotless.listNotifications on knotless.dev: Draw a pull's checks beside its files, A space's background sync leaves no line its tests may miss, star; more with cursor 2026-11-14T08:00:00.000Z"
);
let rows = &view.doc["query"]["layout"];
assert_eq!(rows["props"]["items"], json!({ "$": "items" }));
let mut paths = Vec::new();
bound_paths(&rows["children"], &mut paths);
assert!(paths.len() > 10);
for alternatives in paths {
let found = alternatives.iter().any(|p| {
let path = Path::parse(p).unwrap();
items.iter().any(|i| path.get(i).is_some())
});
assert!(found, "no notification has {alternatives:?}");
}
}
/// Every bundled launcher's params are its method's, as the lexicon
/// knotless publishes takes them (copies in testdata/knotless), and
/// Bluesky's bundled ones.
#[test]
fn launchers_are_their_methods() {
let mut docs: Vec<std::sync::Arc<Value>> = [
include_str!("testdata/knotless/dev.knotless.listNotifications.json"),
include_str!("testdata/knotless/dev.knotless.getActorRepos.json"),
include_str!("testdata/knotless/dev.knotless.getFeed.json"),
include_str!("testdata/knotless/dev.knotless.defs.json"),
include_str!("testdata/knotless/dev.knotless.queue.json"),
]
.iter()
.map(|t| std::sync::Arc::new(serde_json::from_str(t).unwrap()))
.chain(crate::lexicon::all_bundled().cloned())
.collect();
docs.extend(
[
"app.bsky.feed.getFeed",
"app.bsky.feed.getTimeline",
"app.bsky.feed.getAuthorFeed",
"app.bsky.feed.getFeedGenerators",
"social.grain.feed.getFeed",
]
.iter()
.map(|m| crate::lexicon::bundled(m).unwrap()),
);
let mut seen = 0;
for b in bundled().iter().filter(|b| !b.view.launch.is_empty()) {
let method = b.view.method.as_deref().unwrap();
let doc = docs.iter().find(|d| d["id"] == method);
let doc = doc.ok_or(format!("no lexicon for {method}")).unwrap();
let def = crate::xrpc::query_def(method, doc).unwrap();
let lexicons = crate::xrpc::lexicons_for(method, &docs);
for l in &b.view.launch {
assert_eq!(
launch_problems(l, &lexicons, method, def),
Vec::<String>::new(),
"{}",
b.id
);
seen += 1;
}
}
assert_eq!(seen, 20);
// Those naming the person need one signed in.
let names_me: Vec<bool> = for_method("dev.knotless.getFeed")
.unwrap()
.launch
.iter()
.map(Launch::names_me)
.collect();
assert_eq!(names_me, [true, false]);
// Chats are launched as any other app's are.
let chats = launchers("did:plc:me", None)
.into_iter()
.find(|l| l["method"] == "chat.bsky.convo.listConvos");
assert_eq!(
chats,
Some(
json!({ "app": "Bluesky Chat", "domain": "bsky.chat", "title": "Chats",
"method": "chat.bsky.convo.listConvos", "service": "did:web:api.bsky.chat#bsky_chat",
"params": {} })
)
);
// A param the method lacks, or a value it refuses, is found.
let feed = docs
.iter()
.find(|d| d["id"] == "dev.knotless.getFeed")
.unwrap();
let def = crate::xrpc::query_def("dev.knotless.getFeed", feed).unwrap();
let lexicons = crate::xrpc::lexicons_for("dev.knotless.getFeed", &docs);
let bad = Launch {
title: "x".into(),
params: json!({ "nope": 1, "actor": { "$me": "handle" } })
.as_object()
.unwrap()
.clone(),
};
assert_eq!(
launch_problems(&bad, &lexicons, "dev.knotless.getFeed", def).len(),
2
);
// $me is the person.
let mine = for_method("dev.knotless.getActorRepos").unwrap().launch[0]
.params_for("did:plc:me", None)
.unwrap();
assert_eq!(mine["actor"], "did:plc:me");
assert!(bad.params_for("did:plc:me", None).is_none());
// The shape, and bundled method views alone.
let view = |trusted: bool, launch: Value| {
parse(
&json!({ "method": "a.b.c", "service": "did:web:x.example#svc", "description": "d", "launch": launch,
"query": { "layout": { "component": "Badge", "props": { "value": "x" } } } }),
trusted,
)
};
assert!(
view(
true,
json!([{ "title": "Mine", "params": { "a": { "$me": "did" }, "b": 2 } }])
)
.is_ok()
);
for bad in [
json!([]),
json!([{ "params": {} }]),
json!([{ "title": "x", "params": { "a": { "$me": "email" } } }]),
json!([{ "title": "x", "params": { "a": [1] } }]),
json!([{ "title": "x", "y": 1 }]),
] {
assert!(view(true, bad.clone()).is_err(), "{bad}");
}
assert_eq!(
view(false, json!([{ "title": "x" }])).unwrap_err(),
["view.launch: only a bundled view offers launchers"]
);
}
/// A composer's writes read only its fields' and given values' names;
/// what is written is never an `Action`'s, whose record takes no
/// `$text` or `$facets`.
#[test]
fn compose_checked() {
let doc = |c: &str, props: Value| {
json!({ "method": "a.b.c", "service": "did:web:x.example#svc", "description": "d",
"query": { "layout": { "component": "Stack", "children": [{ "component": c, "props": props }] } } })
};
let reply = json!({ "label": "Reply", "icon": "reply",
"given": { "root": { "$first": [{ "$": "post.record.reply.root" }, { "$strongRef": "post" }] },
"parent": { "$strongRef": "post" } },
"fields": [{ "name": "text", "kind": "text", "max": 300, "facets": true, "required": true }],
"writes": [{ "collection": "app.bsky.feed.post", "record": {
"text": { "$value": "text" }, "facets": { "$facets": "text" }, "createdAt": { "$now": true },
"reply": { "root": { "$value": "root" }, "parent": { "$value": "parent" } } } }] });
assert!(parse(&doc("Compose", reply.clone()), true).is_ok());
let problems = |change: &dyn Fn(&mut Value)| {
let mut a = reply.clone();
change(&mut a);
parse(&doc("Compose", a), true).unwrap_err()
};
// A write reading a value no field or given names.
let unnamed = problems(&|a| a["writes"][0]["record"]["text"] = json!({ "$value": "body" }));
assert_eq!(unnamed.len(), 1);
assert!(unnamed[0].contains("writes[0].record.text"), "{unnamed:?}");
// A field of a kind there is none of.
let kind = problems(&|a| a["fields"][0]["kind"] = json!("poem"));
assert_eq!(kind.len(), 1);
assert!(kind[0].contains("fields[0]"), "{kind:?}");
// A given value's name is lowercase letters and digits.
let named = problems(&|a| a["given"]["Root"] = json!("x"));
assert_eq!(
named,
["query.layout.children[0].props.given.Root: a name, lowercase letters and digits"]
);
// A text's max only narrows its record's lexicon's, which it may leave to it.
assert_eq!(
problems(&|a| a["fields"][0]["max"] = json!(301)),
[
"query.layout.children[0].props: fields[0].max: at most its record's lexicon's 300 graphemes"
]
);
let mut unlimited = reply.clone();
unlimited["fields"][0]
.as_object_mut()
.unwrap()
.remove("max");
assert!(parse(&doc("Compose", unlimited), true).is_ok());
// A photo's review is of one photo, its first field.
let review = problems(&|a| a["form"] = json!("photo"));
assert_eq!(
review,
["query.layout.children[0].props.form: photo: its first field is photos of max 1"]
);
let mut story = reply.clone();
story["form"] = json!("photo");
story["fields"].as_array_mut().unwrap().insert(
0,
json!({ "name": "photo", "kind": "photos", "max": 1, "maxBytes": 900000, "maxSide": 1000, "camera": true }),
);
assert!(parse(&doc("Compose", story), true).is_ok());
// A Compose for another names one drawn in its scope, and takes its form.
let both = |prompt: Value| {
json!({ "method": "a.b.c", "service": "did:web:x.example#svc", "description": "d",
"query": { "layout": { "component": "Stack", "children": [
{ "component": "Compose", "props": reply.clone() },
{ "component": "Compose", "props": prompt }] } } })
};
let field = json!({ "for": "Reply", "label": "Add a reply…", "style": "field", "signIn": "Sign in to reply" });
assert!(parse(&both(field), true).is_ok());
assert_eq!(
parse(
&both(json!({ "for": "Quote", "label": "Quote it", "send": "Quote" })),
true
)
.unwrap_err(),
[
"query.layout.children[1].props.send: a Compose for another takes that one's",
"query.layout.children[1].props.for: no Compose labelled \"Quote\" is drawn in its scope"
]
);
assert_eq!(
parse(&doc("Compose", json!({ "label": "Write", "writes": [{ "collection": "a.b.c", "record": { "n": 1 } }] })), true).unwrap_err(),
["query.layout.children[0].props.fields: Compose requires it"]
);
// An Action writes no text a person wrote.
let texted = json!({ "label": "Reply", "create": { "collection": "app.bsky.feed.post",
"record": { "text": { "$text": true }, "createdAt": { "$now": true } } } });
let refused = parse(&doc("Action", texted), true).unwrap_err();
assert_eq!(refused.len(), 1);
assert!(
refused[0].contains("create.record.text.$text"),
"{refused:?}"
);
}
/// A conversation is a layout's top node; a procedure call, in it or an
/// `Action`, a bundled view's alone, its input a template.
#[test]
fn messages_and_calls_checked() {
let send = json!({ "method": "chat.bsky.convo.sendMessage", "service": "did:web:api.bsky.chat#bsky_chat",
"input": { "convoId": { "$root": "params.convoId" }, "message": { "text": { "$text": true } } } });
let messages = json!({ "component": "Messages",
"props": { "items": { "$": "items" }, "from": "sender.did", "sent": "sentAt",
"people": { "$root": "response.relatedProfiles" }, "order": "newest-first",
"send": send },
"children": [{ "component": "Text", "props": { "value": { "$": "text" } } }] });
let doc = |layout: Value| {
json!({ "method": "a.b.c", "service": "did:web:x.example#svc", "description": "d",
"query": { "items": "messages", "layout": layout } })
};
let v = parse(&doc(messages.clone()), true).unwrap();
assert_eq!(
v.calls,
[Call {
method: "chat.bsky.convo.sendMessage".into(),
service: "did:web:api.bsky.chat#bsky_chat".into(),
input: send["input"].clone(),
deletes: false,
}]
);
assert_eq!(
parse(&doc(messages.clone()), false).unwrap_err(),
["query.layout.props.send: only a bundled view calls procedures"]
);
let mut read_only = messages.clone();
read_only["props"].as_object_mut().unwrap().remove("send");
assert!(parse(&doc(read_only.clone()), false).is_ok());
assert_eq!(
parse(
&doc(json!({ "component": "Stack", "children": [read_only] })),
false
)
.unwrap_err(),
["query.layout.children[0].component: Messages is a layout's top node alone"]
);
let mut bad = messages;
bad["props"]["send"] =
json!({ "method": "a.b.c", "input": { "text": "fixed", "x": { "$nope": 1 } } });
bad["props"]["from"] = json!({ "$": "sender.did" });
assert_eq!(
parse(&doc(bad), true).unwrap_err(),
[
"query.layout.props.from: must be a literal value, not a binding",
"query.layout.props.send.service: required: a DID with its service's #fragment, as did:web:api.bsky.chat#bsky_chat",
"query.layout.props.send.input.x.$nope: a key starting with $ is $type, or a binding's, $root's, $now's, $strongRef's, $rkey's, $first's, $join's, $with's, $without's, $move's or $text's alone",
"query.layout.props.send.input: holds no {\"$text\": true}, where what the person writes goes"
]
);
// An Action's call takes no text, and is one of its four.
let action = |props: Value| doc(json!({ "component": "Action", "props": props }));
let call = json!({ "method": "chat.bsky.convo.updateRead", "service": "did:web:api.bsky.chat#bsky_chat",
"input": { "convoId": { "$": "id" } } });
assert!(parse(&action(json!({ "label": "Read", "call": call })), true).is_ok());
let mut texted = call.clone();
texted["input"]["convoId"] = json!({ "$text": true });
assert_eq!(
parse(&action(json!({ "label": "Read", "call": texted })), true).unwrap_err(),
[
"query.layout.props.call.input.convoId.$text: a key starting with $ is $type, or a binding's, $root's, $now's, $strongRef's, $rkey's, $first's, $join's, $with's, $without's or $move's alone"
]
);
assert_eq!(
parse(
&action(
json!({ "label": "Read", "call": call, "delete": { "uri": { "$": "uri" } } })
),
true
)
.unwrap_err(),
[
"query.layout.props: Action takes exactly one of create, delete, interaction, call, deletes"
]
);
}
/// An Action's `deletes`: a bundled view's alone, its query and params
/// held as a call's, kept with the view's calls, and what it says beyond
/// its query (repeat, collections, then) kept as its plan.
#[test]
fn deletes_checked() {
let doc = |deletes: Value| {
json!({ "method": "a.b.c", "service": "did:web:x.example#svc", "description": "d",
"query": { "layout": { "component": "Action",
"props": { "label": "Delete", "deletes": deletes } } } })
};
let then = json!({ "method": "a.b.forget", "service": "did:web:x.example#svc",
"input": { "did": { "$did": true }, "n": [1, { "$type": "t" }] } });
let full = json!({ "method": "a.b.getPlan", "service": "did:web:x.example#svc",
"params": { "of": { "$": "uri" } }, "repeat": true,
"collections": ["a.b.thing"], "then": then });
let v = parse(&doc(full.clone()), true).unwrap();
assert_eq!(
v.calls,
[Call {
method: "a.b.getPlan".into(),
service: "did:web:x.example#svc".into(),
input: json!({ "of": { "$": "uri" } }),
deletes: true,
}]
);
assert_eq!(
v.plans,
[Plan {
method: "a.b.getPlan".into(),
service: "did:web:x.example#svc".into(),
repeat: true,
collections: vec!["a.b.thing".into()],
then: Some(Call {
method: "a.b.forget".into(),
service: "did:web:x.example#svc".into(),
input: then["input"].clone(),
deletes: false,
}),
}]
);
// A then with no input takes an empty one.
let mut bare = full.clone();
bare["then"] = json!({ "method": "a.b.forget", "service": "did:web:x.example#svc" });
let v = parse(&doc(bare), true).unwrap();
assert_eq!(v.plans[0].then.as_ref().unwrap().input, json!({}));
// Of a gallery: no more than its query.
let once = json!({ "method": "a.b.getPlan", "service": "did:web:x.example#svc" });
let v = parse(&doc(once.clone()), true).unwrap();
assert_eq!(
(
v.plans[0].repeat,
v.plans[0].collections.len(),
&v.plans[0].then
),
(false, 0, &None)
);
let at = "query.layout.props.deletes";
assert_eq!(
parse(&doc(once), false).unwrap_err(),
[format!(
"{at}: only a bundled view deletes what a query plans"
)]
);
let bad = json!({ "method": "a.b.getPlan", "service": "nope", "params": [],
"repeat": 1, "collections": "a.b.c", "input": {},
"then": { "method": "a.b.forget", "service": "did:web:x.example#svc",
"input": { "did": { "$": "did" } } } });
assert_eq!(
parse(&doc(bad), true).unwrap_err(),
[
format!("{at}: unknown key \"input\""),
format!(
"{at}.service: required: a DID with its service's #fragment, as did:web:api.bsky.chat#bsky_chat"
),
format!("{at}.params: must be an object, the query's params"),
format!("{at}.repeat: must be true or false"),
format!("{at}.collections: must be a list of at most 32 collections' NSIDs"),
format!(
"{at}.then.input.did: is literal JSON but {{\"$did\": true}}, the account's DID"
),
]
);
let mut odd = full;
odd["collections"] = json!(["not an nsid"]);
odd["then"] = json!({ "method": "a.b.forget", "input": [] });
let errs = parse(&doc(odd.clone()), true).unwrap_err();
assert!(
errs.iter()
.any(|e| e.starts_with(&format!("{at}.collections[0]"))),
"{errs:?}"
);
assert!(
errs.contains(&format!(
"{at}.then.input: must be an object, the procedure's input"
)),
"{errs:?}"
);
odd["then"] = json!({ "method": "a.b.forget", "service": "did:web:x.example#svc",
"input": { "a": { "$did": true, "b": 1 } } });
odd["collections"] = json!([]);
assert_eq!(
parse(&doc(odd), true).unwrap_err(),
[format!(
"{at}.then.input.a: is literal JSON but {{\"$did\": true}}, the account's DID"
)]
);
}
/// A Choice's options are 2 to 6 `{ label, value }`, their values
/// different strings; its default one of them; its call holds `$on`.
#[test]
fn a_choices_options_and_default_are_checked() {
let doc = |options: Value, default: Value| {
json!({ "method": "a.b.c", "service": "did:web:x.example#svc", "description": "d",
"query": { "layout": { "component": "Choice", "props": { "label": "Theme",
"options": options, "default": default, "on": { "$": "response.prefs.@themePref.theme" },
"call": { "method": "a.b.setPreference", "service": "did:web:x.example#svc",
"input": { "preference": { "$type": "a.b.defs#themePref", "theme": { "$on": true } } } } } } } })
};
let two =
json!([{ "label": "Light", "value": "light" }, { "label": "Dark", "value": "dark" }]);
assert!(parse(&doc(two.clone(), json!("light")), true).is_ok());
let options = "query.layout.props.options: must be an array of 2 to 6 options, each { label, value }, label short text, the values different strings";
for bad in [
json!([{ "label": "Light", "value": "light" }]),
json!([{ "label": "Light", "value": "light" }, { "label": "Also", "value": "light" }]),
json!([{ "label": "Light", "value": "light" }, { "label": "Dark", "value": 2 }]),
json!([{ "label": "Light", "value": "light", "x": 1 }, { "label": "Dark", "value": "dark" }]),
] {
assert_eq!(
parse(&doc(bad, json!("light")), true).unwrap_err(),
[options]
);
}
assert_eq!(
parse(&doc(two, json!("sepia")), true).unwrap_err(),
["query.layout.props.default: must be one of its options' values"]
);
}
/// A Map's pins are at a cell, or at lat and lng; one giving neither,
/// or lat alone, is the view's error.
#[test]
fn a_map_says_where_its_pins_are() {
let doc = |place: Value| {
let mut props =
json!({ "items": { "$": "response.locations" }, "height": "tall", "zoom": 3 });
props
.as_object_mut()
.unwrap()
.extend(place.as_object().unwrap().clone());
json!({ "method": "a.b.c", "service": "did:web:x.example#svc", "description": "d",
"query": { "layout": { "component": "Map", "props": props } } })
};
for place in [
json!({ "cell": { "$": "h3Index" } }),
json!({ "lat": { "$": "lat" }, "lng": { "$": "lng" } }),
] {
assert!(parse(&doc(place), true).is_ok());
}
for place in [json!({}), json!({ "lat": { "$": "lat" } })] {
assert_eq!(
parse(&doc(place), true).unwrap_err(),
["query.layout.props: Map takes cell, or lat and lng"]
);
}
}
/// A Toggle's call carries `{"$on": true}` where the new state goes, and
/// takes no `$text`; one without it is the view's error.
#[test]
fn a_toggles_call_holds_where_its_state_goes() {
let doc = |input: Value| {
json!({ "method": "a.b.c", "service": "did:web:x.example#svc", "description": "d",
"query": { "layout": { "component": "Toggle", "props": { "label": "Photos keep EXIF",
"on": { "$": "response.prefs.@photoPref.exif" }, "default": true,
"call": { "method": "a.b.setPreference", "service": "did:web:x.example#svc", "input": input } } } } })
};
let set =
json!({ "preference": { "$type": "a.b.defs#photoPref", "exif": { "$on": true } } });
assert!(parse(&doc(set), true).is_ok());
assert_eq!(
parse(
&doc(json!({ "preference": { "exif": { "$text": true } } })),
true
)
.unwrap_err(),
[
"query.layout.props.call.input.preference.exif.$text: a key starting with $ is $type, or a binding's, $root's, $now's, $strongRef's, $rkey's, $first's, $join's, $with's, $without's, $move's or $on's alone",
"query.layout.props.call.input: holds no {\"$on\": true}, where what the person chooses goes"
]
);
assert_eq!(
parse(&doc(json!({ "x": { "$on": true, "y": 1 } })), true).unwrap_err(),
["query.layout.props.call.input.x: {\"$on\": true} has the key $on alone, true"]
);
}
/// A template's edits of an array and its strings joined, a param's
/// `$after` and a Tabs' opens by case, each malformed one named where it
/// is.
#[test]
fn template_edits_after_and_cases_checked() {
let list = |layout: Value| listing(layout, json!({}));
let creating = |record: Value| {
list(json!({ "component": "Action", "props": { "label": "Go",
"create": { "collection": "a.b.pref", "record": record } } }))
};
let opening = |param: Value| {
list(
json!({ "component": "Link", "props": { "open": { "query": "a.b.getThing", "params": { "x": param } } } }),
)
};
let tabs = |opens: Value| {
let tab = |label: &str| json!({ "label": label, "open": { "query": "a.b.getFeed" } });
list(
json!({ "component": "Tabs", "props": { "items": [tab("A"), tab("B")], "label": "label",
"from": { "$": "records" }, "opens": opens } }),
)
};
let items = json!({ "$": "items" });
let good = creating(json!({
"added": { "$with": [items, "id", { "id": { "$join": ["camera:", { "$": "camera" }] } }] },
"taken": { "$without": [{ "$root": "records" }, "id", "a"] },
"moved": { "$move": [{ "$first": [items, []] }, "id", { "$": "id" }, -1] } }));
assert_eq!(problems(&good, false), Vec::<String>::new());
let after = opening(json!({ "$after": [{ "$": "id" }, "camera:"] }));
assert_eq!(problems(&after, false), Vec::<String>::new());
let open = json!({ "query": "a.b.getFeed", "params": { "camera": { "$after": [{ "$": "id" }, "camera:"] } } });
let cased = tabs(
json!([{ "where": { "type": { "$is": "camera" } }, "open": open }, { "open": open }]),
);
assert_eq!(problems(&cased, false), Vec::<String>::new());
let r = "list.layout.props.create.record.x";
let o = "list.layout.props.open.params.x";
let c = "list.layout.props.opens";
for (doc, want) in [
(
creating(json!({ "x": { "$join": ["a"] } })),
format!(
"{r}: {{\"$join\": [values]}} has the key $join alone, 2 to 8 values, each a string once read"
),
),
(
creating(json!({ "x": { "$with": [items, "id"] } })),
format!("{r}: {{\"$with\": [array, key, value]}} has the key $with alone"),
),
(
creating(json!({ "x": { "$move": [items, "id", "a", 0] } })),
format!("{r}.$move[3]: must be a whole number but 0, the places it moves"),
),
(
creating(json!({ "x": { "$without": [items, 5, "a"] } })),
format!("{r}.$without[1]: must be a path, keys joined by dots"),
),
(
creating(json!({ "x": { "$without": [items, "id", { "$nope": 1 }] } })),
format!(
"{r}.$without[2].$nope: a key starting with $ is $type, or a binding's, $root's, $now's, $strongRef's, $rkey's, $first's, $join's, $with's, $without's or $move's alone"
),
),
(
opening(json!({ "$after": [{ "$": "id" }, ""] })),
format!(
"{o}: {{\"$after\": [value, prefix]}} has the key $after alone, the prefix a string"
),
),
(
opening(json!({ "$nope": 1 })),
format!(
"{o}: an object with a key starting with $ is {{\"$\": path}}, {{\"$root\": path}}, {{\"$atUri\": [authority, collection, rkey]}} or {{\"$after\": [value, prefix]}}"
),
),
(
tabs(json!({ "open": open })),
format!("{c}: must be an array of 1 to 4 cases, each {{ where?, open }}"),
),
(
tabs(json!([{ "where": { "type": 5 }, "open": open }])),
format!(
"{c}[0].where: must be an object of 1 to 4 paths within each element to paths in the scope or {{\"$is\": a string, number or boolean}}, either in {{\"$not\": …}}"
),
),
(
tabs(json!([{ "where": { "type": "kind" } }])),
format!("{c}[0].open: required: what the element opens"),
),
] {
assert_eq!(problems(&doc, false), [want], "{doc}");
}
}
/// A path takes a union array's element by its type's name.
#[test]
fn a_path_takes_an_element_by_its_type() {
let prefs = json!({ "prefs": [
{ "$type": "a.b.defs#themePref", "theme": "dark" },
{ "$type": "a.b.defs#photoPref", "exif": false },
{ "$type": "plain", "x": 1 },
] });
let at = |s: &str| Path::parse(s).unwrap().get(&prefs).cloned();
assert_eq!(at("prefs.@photoPref.exif"), Some(json!(false)));
assert_eq!(at("prefs.@plain.x"), Some(json!(1)));
assert_eq!(at("prefs.@feedPref"), None);
assert_eq!(at("prefs.0.theme"), Some(json!("dark")));
assert!(Path::parse("prefs.@").is_none());
}
/// A `where` pairs an element's path with a scope path or a literal,
/// either in `{"$not": …}`, whose path is checked as one outside it.
#[test]
fn a_where_compares_with_a_path_or_a_literal() {
let doc = |w: Value| {
json!({ "collection": "a.b.c", "description": "d",
"list": { "layout": { "component": "List", "props": { "items": { "$": "records" }, "where": w } } } })
};
assert!(
parse(
&doc(json!({ "type": { "$is": "feed" }, "did": "did",
"uri": { "$not": "params.uri" }, "kind": { "$not": { "$is": 3 } } })),
false
)
.is_ok()
);
let off = "list.layout.props.where: must be an object of 1 to 4 paths within each element to paths in the scope or {\"$is\": a string, number or boolean}, either in {\"$not\": …}";
for w in [
json!({ "type": { "$is": ["feed"] } }),
json!({ "type": { "$not": ["feed"] } }),
json!({ "type": { "$not": { "$not": "did" } } }),
] {
assert_eq!(parse(&doc(w.clone()), false).unwrap_err(), [off], "{w}");
}
assert_eq!(
parse(&doc(json!({ "uri": { "$not": "a b" } })), false).unwrap_err(),
["list.layout.props.where.uri: unknown path syntax \"a b\""]
);
}
/// Covers' select: its words, its `mine` a path, and its call a bundled
/// view's procedure, as an Action's.
#[test]
fn covers_select_checked() {
let call = json!({ "method": "social.grain.unspecced.deleteGallery", "service": "did:web:grain.social#grain_appview",
"input": { "rkey": { "$rkey": "uri" } } });
let doc = |select: Value| {
json!({ "method": "a.b.c", "service": "did:web:x.example#svc", "description": "d",
"query": { "items": "items", "layout": { "component": "Covers",
"props": { "items": { "$": "items" }, "src": { "$": "thumb" }, "select": select } } } })
};
let good = json!({ "mine": "params.actor", "action": "Delete", "noun": ["gallery", "galleries"],
"confirm": "Gone for good.", "tone": "danger", "call": call });
let v = parse(&doc(good.clone()), true).unwrap();
assert_eq!(v.calls[0].method, "social.grain.unspecced.deleteGallery");
// Without mine, offered to anyone signed in.
let mut anyone = good.clone();
anyone.as_object_mut().unwrap().remove("mine");
assert!(parse(&doc(anyone), true).is_ok());
assert_eq!(
parse(&doc(good), false).unwrap_err(),
["query.layout.props.select.call: only a bundled view calls procedures"]
);
let at = "query.layout.props.select";
assert_eq!(
parse(&doc(json!({ "label": "", "noun": ["gallery"], "tone": "loud", "mine": "a..b", "extra": 1 })), true)
.unwrap_err(),
[
format!("{at}: unknown key \"extra\""),
format!("{at}.label: text of at most 40 characters"),
format!("{at}.action: text of at most 40 characters"),
format!("{at}.noun: must be [singular, plural]"),
format!("{at}.tone: must be danger"),
format!("{at}.mine: unknown path syntax \"a..b\""),
format!("{at}: takes one of call ({{ method, service, input? }}) and deletes ({{ method, service, params? }})"),
]
);
assert_eq!(
parse(&doc(json!(1)), true).unwrap_err(),
[format!(
"{at}: must be {{ label?, mine?, action, noun, confirm?, tone?, call or deletes }}"
)]
);
// Or what a query plans deleted, its params read from each item;
// not both, and a bundled view's alone.
let deletes = json!({ "method": "social.grain.gallery.getDeletionPlan",
"service": "did:web:grain.social#grain_appview", "params": { "gallery": { "$": "uri" } } });
let planned =
json!({ "action": "Delete", "noun": ["gallery", "galleries"], "deletes": deletes });
let v = parse(&doc(planned.clone()), true).unwrap();
assert_eq!(
(
v.calls[0].method.as_str(),
v.calls[0].deletes,
&v.calls[0].input
),
(
"social.grain.gallery.getDeletionPlan",
true,
&json!({ "gallery": { "$": "uri" } })
)
);
assert_eq!(
parse(&doc(planned.clone()), false).unwrap_err(),
[format!(
"{at}.deletes: only a bundled view deletes what a query plans"
)]
);
let mut both = planned.clone();
both["call"] = call;
assert_eq!(
parse(&doc(both), true).unwrap_err(),
[format!(
"{at}: takes one of call ({{ method, service, input? }}) and deletes ({{ method, service, params? }})"
)]
);
let mut odd = planned;
odd["deletes"]["params"] = json!([]);
odd["deletes"]["input"] = json!({});
assert_eq!(
parse(&doc(odd), true).unwrap_err(),
[
format!("{at}.deletes: unknown key \"input\""),
format!("{at}.deletes.params: must be an object, the query's params"),
]
);
}
/// Every procedure a bundled view calls is one, and its template's
/// fields are the input's, as the bundled lexicons have them; and the
/// server sends those alone.
#[test]
fn bundled_calls_are_their_procedures() {
let docs = lexicon_docs();
let mut seen = Vec::new();
for b in Views::built_in().all() {
for c in &b.view.calls {
assert_eq!(call_problems(c, &docs), Vec::<String>::new(), "{}", b.id);
assert!(bundled_call(&c.method, &c.service));
seen.push(format!("{} {}", b.id, c.method));
}
}
// A view's switches each call the same procedure: once is enough here.
seen.dedup();
assert_eq!(
seen,
[
"bsky-chat chat.bsky.convo.sendMessage",
"bsky-chat-with chat.bsky.convo.sendMessage",
"bsky-chats chat.bsky.convo.updateRead",
]
);
assert!(!bundled_call(
"chat.bsky.convo.sendMessage",
"did:web:api.bsky.app#bsky_appview"
));
// A template the lexicon would refuse is found.
let bad = Call {
method: "chat.bsky.convo.sendMessage".into(),
service: "did:web:api.bsky.chat#bsky_chat".into(),
input: json!({ "message": { "text": "x" }, "nope": 1 }),
deletes: false,
};
assert_eq!(
call_problems(&bad, &docs),
[
"chat.bsky.convo.sendMessage: input.nope is not an input of it",
"chat.bsky.convo.sendMessage: input.convoId is required"
]
);
}
#[test]
fn trees_and_chains() {
let card =
json!([{ "component": "Text", "props": { "value": { "$": "post.record.text" } } }]);
let node = |component: &str, props: Value| {
posts(json!({ "component": component, "props": props, "children": card }))
};
let ok = [
node(
"Tree",
json!({ "items": { "$": "records" }, "children": "replies" }),
),
node(
"Tree",
json!({ "items": { "$": "records" }, "children": "value.replies", "depth": 8,
"open": { "query": "app.bsky.feed.getPostThread", "params": { "uri": { "$": "post.uri" } } } }),
),
node(
"Chain",
json!({ "from": { "$": "value.parent" }, "next": "parent" }),
),
node(
"Chain",
json!({ "from": { "$": "." }, "next": "parent", "depth": 20, "open": { "$": "uri" } }),
),
];
for doc in ok {
assert_eq!(problems(&doc, false), Vec::<String>::new(), "{doc}");
}
let at = "list.layout.props";
for (doc, want) in [
(
node("Tree", json!({ "children": "replies" })),
vec![format!("{at}.items")],
),
(
node("Tree", json!({ "items": [] , "children": "replies" })),
vec![format!("{at}.items")],
),
(
node("Tree", json!({ "items": { "$": "records" } })),
vec![format!("{at}.children")],
),
(
node(
"Tree",
json!({ "items": { "$": "records" }, "children": { "$": "replies" } }),
),
vec![format!("{at}.children")],
),
(
node(
"Tree",
json!({ "items": { "$": "records" }, "children": "two words" }),
),
vec![format!("{at}.children")],
),
(
node(
"Tree",
json!({ "items": { "$": "records" }, "children": "replies", "depth": 9 }),
),
vec![format!("{at}.depth")],
),
(
node("Chain", json!({ "from": "x", "next": "parent" })),
vec![format!("{at}.from")],
),
(
node("Chain", json!({ "from": { "$": "value" } })),
vec![format!("{at}.next")],
),
(
node(
"Chain",
json!({ "from": { "$": "value" }, "next": "parent", "depth": 21 }),
),
vec![format!("{at}.depth")],
),
(
node(
"Chain",
json!({ "from": { "$": "value" }, "next": "parent", "items": { "$": "x" } }),
),
vec![format!("{at}.items")],
),
] {
assert_eq!(wheres(&doc), want, "{doc}");
}
}
#[test]
fn query_mode_without_items() {
let mut v = feed_view();
let q = v["query"].as_object_mut().unwrap();
q.remove("items");
q.remove("cursor");
q["summary"] = json!({ "noun": ["thread", "threads"], "label": { "$": "response.thread.post.record.text" },
"by": { "$": "response.thread.post.author.handle" },
"detail": { "count": { "$": "response.thread.replies" }, "noun": ["reply", "replies"], "children": "replies" } });
let parsed = parse(&v, false).unwrap();
let q = parsed.query.unwrap();
assert_eq!((q.items, q.cursor), (None, None));
let s = q.summary.unwrap();
let scope = json!({ "method": "m", "response": { "thread": {
"post": { "record": { "text": "hello\nworld" }, "author": { "handle": "alice.test" } },
"replies": [
{ "post": {}, "replies": [{ "post": {} }, { "post": {}, "replies": [{ "post": {} }] }] },
{ "$type": "app.bsky.feed.defs#notFoundPost" },
] } } });
assert_eq!(
crate::summary::query_one(&s, "app.bsky.feed.getPostThread", "api.bsky.app", &scope),
"Thread: \"hello world\" by alice.test: 5 replies."
);
// With nothing that resolves: the noun, the method and the host.
assert_eq!(
crate::summary::query_one(
&s,
"app.bsky.feed.getPostThread",
"api.bsky.app",
&json!({})
),
"Thread from app.bsky.feed.getPostThread on api.bsky.app."
);
// by and children are a query mode's alone, children a path.
let mut bad = posts(json!({ "component": "Badge", "props": { "value": "x" } }));
bad["list"]["summary"] = json!({ "noun": ["a", "b"], "by": { "$": "handle" },
"detail": { "count": { "$": "x" }, "noun": ["c", "d"], "children": "no spaces" } });
assert_eq!(
wheres(&bad),
["list.summary.by", "list.summary.detail.children"]
);
}
#[test]
fn the_thread_view() {
let v = for_method("app.bsky.feed.getPostThread").expect("the thread view");
assert_eq!(
v.service.as_deref(),
Some("did:web:api.bsky.app#bsky_appview")
);
assert_eq!(
v.origins,
[
"https://cdn.bsky.app",
"https://video.bsky.app",
"https://video.cdn.bsky.app"
]
);
assert_eq!(v.doc.to_string().matches("\"Embed\"").count(), 3);
let q = v.query.as_ref().unwrap();
assert!(q.items.is_none() && q.cursor.is_none());
let s = q.summary.as_ref().unwrap();
assert!(s.by.is_some() && s.detail.as_ref().is_some_and(|d| d.2.is_some()));
let layout = &v.doc["query"]["layout"]["children"];
let components: Vec<&str> = layout
.as_array()
.unwrap()
.iter()
.filter_map(|n| n["component"].as_str())
.collect();
assert_eq!(components, ["Chain", "Stack", "Tree"]);
assert_eq!(layout[0]["props"]["next"], "parent");
assert_eq!(layout[2]["props"]["children"], "replies");
assert_eq!(layout[2]["props"]["depth"], 6);
// Every Bluesky card opens its post's thread.
let thread = json!({ "query": "app.bsky.feed.getPostThread", "params": { "uri": { "$": "post.uri" } } });
assert_eq!(layout[0]["props"]["open"], thread);
assert_eq!(layout[2]["props"]["open"], thread);
for m in [
"app.bsky.feed.getFeed",
"app.bsky.feed.getAuthorFeed",
"app.bsky.feed.getTimeline",
] {
let feed = for_method(m).unwrap();
assert_eq!(feed.doc["query"]["layout"]["props"]["open"], thread, "{m}");
}
// A post opened by its at-uri is its thread.
let (view, post) = route("app.bsky.feed.post").unwrap();
assert_eq!(view.method.as_deref(), Some("app.bsky.feed.getPostThread"));
assert_eq!(
Value::Object(
post.params_for(&json!({ "uri": "at://did:plc:a/app.bsky.feed.post/1" }))
.unwrap()
),
json!({ "uri": "at://did:plc:a/app.bsky.feed.post/1" })
);
}
#[test]
fn interactions_are_trusted_views_alone() {
let reporting = || {
let mut v = feed_view();
v["interactions"] = json!({ "feed": { "$": "params.feed" }, "item": "post.uri",
"feedContext": "feedContext", "reqId": "reqId" });
v["query"]["layout"]["children"][0] = json!({ "component": "Action", "props": {
"label": "More like this", "icon": "plus",
"interaction": { "event": "app.bsky.feed.defs#requestMore" } } });
v
};
// Bundled: taken, the paths checked.
let v = parse(&reporting(), true).unwrap();
let i = v.interactions.unwrap();
assert_eq!(
(i.item, i.feed_context, i.req_id),
(
Path::parse("post.uri").unwrap(),
Path::parse("feedContext"),
Path::parse("reqId")
)
);
// Inline: both refused.
assert_eq!(
wheres(&reporting()),
[
"query.layout.children[0].props.interaction",
"view.interactions"
]
);
// Even bundled, an interaction needs the view's interactions, an
// event of the two asked for, and no create beside it.
let mut lone = reporting();
lone.as_object_mut().unwrap().remove("interactions");
assert_eq!(problems(&lone, true).len(), 1);
assert!(problems(&lone, true)[0].starts_with("view: an Action with interaction"));
let mut seen = reporting();
seen["query"]["layout"]["children"][0]["props"]["interaction"]["event"] =
json!("app.bsky.feed.defs#interactionSeen");
let trusted = |v: &Value| -> Vec<String> {
problems(v, true)
.iter()
.map(|p| p.split_once(": ").unwrap().0.to_string())
.collect()
};
assert_eq!(
trusted(&seen),
["query.layout.children[0].props.interaction.event"]
);
let mut both = reporting();
both["query"]["layout"]["children"][0]["props"]["delete"] =
json!({ "uri": { "$": "post.uri" } });
assert_eq!(trusted(&both), ["query.layout.children[0].props"]);
// The interactions' own shape: feed a binding, item a path; for a
// method view with items.
let mut bad = reporting();
bad["interactions"] = json!({ "feed": "at://x", "item": "a b", "other": 1 });
assert_eq!(
trusted(&bad),
[
"view.interactions",
"view.interactions.feed",
"view.interactions.item"
]
);
let mut thread = reporting();
thread["query"].as_object_mut().unwrap().remove("items");
thread["query"].as_object_mut().unwrap().remove("cursor");
assert_eq!(trusted(&thread), ["view.interactions"]);
// The bundled feed reports, and asks for more and less.
let feed = for_method("app.bsky.feed.getFeed").unwrap();
assert!(feed.interactions.is_some());
let text = feed.doc.to_string();
for e in ["requestMore", "requestLess"] {
assert!(text.contains(&format!("app.bsky.feed.defs#{e}")), "{e}");
}
}
#[test]
fn the_feed_generators_view() {
let v = for_method("app.bsky.feed.getFeedGenerators").expect("the feed generators view");
assert_eq!(
v.service.as_deref(),
Some("did:web:api.bsky.app#bsky_appview")
);
assert_eq!(v.origins, ["https://cdn.bsky.app"]);
assert_eq!(v.query.as_ref().unwrap().items, Path::parse("feeds"));
// A feed opens as its posts.
assert_eq!(
v.doc["query"]["layout"]["props"]["open"],
json!({ "query": "app.bsky.feed.getFeed", "params": { "feed": { "$": "uri" } } })
);
}
#[test]
fn embeds_checked() {
let embed = |props: Value| posts(json!({ "component": "Embed", "props": props }));
for ok in [
json!({ "value": { "$": "value.embed" } }),
json!({ "value": { "$": "value.embed" }, "did": { "$": "did" }, "uri": { "$": "uri" }, "depth": 0 }),
json!({ "value": { "$": "value.embed" }, "depth": 1 }),
] {
assert_eq!(
problems(&embed(ok.clone()), false),
Vec::<String>::new(),
"{ok}"
);
}
let at = "list.layout";
for (props, want) in [
(json!({}), format!("{at}.props.value")),
(
json!({ "value": { "$type": "app.bsky.embed.images" } }),
format!("{at}.props.value"),
),
(
json!({ "value": { "$": "x" }, "depth": 2 }),
format!("{at}.props.depth"),
),
(
json!({ "value": { "$": "x" }, "depth": { "$": "d" } }),
format!("{at}.props.depth"),
),
(
json!({ "value": { "$": "x" }, "did": "did:plc:x" }),
format!("{at}.props.did"),
),
(
json!({ "value": { "$": "x" }, "uri": "at://did:plc:x/a.b.c/1" }),
format!("{at}.props.uri"),
),
] {
assert_eq!(wheres(&embed(props.clone())), [want], "{props}");
}
let mut kids = posts(
json!({ "component": "Embed", "props": { "value": { "$": "x" } },
"children": [{ "component": "Badge", "props": { "value": "x" } }] }),
);
assert_eq!(wheres(&kids), [format!("{at}.children")]);
kids["list"]["layout"]
.as_object_mut()
.unwrap()
.remove("children");
assert!(problems(&kids, false).is_empty());
}
/// A query view of `a.b.getThing` joining `join`.
fn joining(join: Value) -> Value {
json!({ "method": "a.b.getThing", "service": "did:web:x.example#svc", "description": "d",
"query": { "join": join, "layout": { "component": "Badge", "props": { "value": "x" } } } })
}
fn query_join(n: usize) -> Value {
json!({ "as": format!("q{n}"), "query": "a.b.getOther", "params": { "actor": { "$": "response.did" } } })
}
#[test]
fn query_joins_parsed() {
let doc = joining(json!([
{ "as": "posts", "query": "app.bsky.feed.getAuthorFeed",
"params": { "actor": { "$": ["response.did", "params.actor"] }, "filter": "posts_no_replies",
"limit": 5, "tags": ["a", "b"], "me": { "$root": "params.actor" } },
"say": { "noun": ["recent post", "recent posts"], "count": "feed" } },
{ "as": "feeds", "query": "app.bsky.feed.getActorFeeds", "service": "did:web:other.example#svc" }
]));
let v = parse(&doc, false).unwrap();
let q = &v.query.as_ref().unwrap().queries;
assert_eq!(q.len(), 2);
assert_eq!(
(q[0].name.as_str(), q[0].at.as_str(), q[0].params.len()),
("posts", "query.join[0]", 5)
);
assert_eq!(q[0].params[1].1, Param::Literal(json!("posts_no_replies")));
assert_eq!(q[0].say.as_ref().unwrap().count, Path::parse("feed"));
// A query view's joins call its own service, unless they name one.
assert_eq!(
q[0].service_or(v.service.as_deref()).as_deref(),
Some("did:web:x.example#svc")
);
assert_eq!(
q[1].service_or(v.service.as_deref()).as_deref(),
Some("did:web:other.example#svc")
);
assert_eq!(v.query_joins().count(), 2);
}
/// At most six a mode, and record joins' limit across both; untrusted
/// views alike.
#[test]
fn query_joins_capped() {
let six: Vec<Value> = (0..6).map(query_join).collect();
for trusted in [false, true] {
assert!(parse(&joining(json!(six)), trusted).is_ok());
let seven: Vec<Value> = (0..7).map(query_join).collect();
assert_eq!(
problems(&joining(json!(seven)), trusted),
["query.join: 7 query joins, more than 6"]
);
}
// In a records mode, beside record joins: eight joins of both.
let mut doc = posts(json!({ "component": "Badge", "props": { "value": "x" } }));
let mut join: Vec<Value> = (0..4)
.map(|n| json!({ "as": format!("q{n}"), "query": "app.bsky.feed.getPostThread", "params": { "uri": { "$": "records.0.uri" } } }))
.collect();
join.extend((0..5).map(|n| json!({ "as": format!("r{n}"), "ref": "value.x" })));
doc["list"]["join"] = json!(join);
assert_eq!(problems(&doc, false), ["list.join: 9 joins, more than 8"]);
}
/// Depth 1: a query join sits at a mode's top level, never in a record
/// join, and joins nothing further; a query view joins queries alone.
#[test]
fn query_joins_never_nest() {
let mut doc = posts(json!({ "component": "Badge", "props": { "value": "x" } }));
doc["list"]["join"] = json!([{ "as": "a", "ref": "value.x",
"join": [{ "as": "q", "query": "app.bsky.feed.getPostThread", "params": { "uri": { "$": "uri" } } }] }]);
assert_eq!(
wheres(&doc),
["list.join[0].join[0]"],
"{:?}",
problems(&doc, false)
);
let mut deeper = query_join(0);
deeper["join"] = json!([query_join(1)]);
assert_eq!(
problems(&joining(json!([deeper])), false),
["query.join[0]: unknown key \"join\""]
);
assert_eq!(
wheres(&joining(json!([{ "as": "r", "ref": "response.uri" }]))),
["query.join[0]"]
);
}
/// A query view and each of its query joins may say `fresh`: asked
/// each time, never an answer HUD keeps. Kept, unless they say so.
#[test]
fn query_views_and_joins_say_fresh() {
let mut doc = joining(json!([
{ "as": "a", "query": "a.b.getOther", "fresh": true },
{ "as": "b", "query": "a.b.getOther" }
]));
let q = parse(&doc, false).unwrap().query.unwrap();
assert_eq!(
(q.fresh, q.queries[0].fresh, q.queries[1].fresh),
(false, true, false)
);
doc["query"]["fresh"] = json!(true);
assert!(parse(&doc, false).unwrap().query.unwrap().fresh);
doc["query"]["fresh"] = json!("yes");
doc["query"]["join"][1]["fresh"] = json!(1);
assert_eq!(
problems(&doc, false),
[
"query.join[1].fresh: must be true or false",
"query.fresh: must be true or false"
]
);
}
/// A query join's `when` is a path in the main scope, `at` too.
#[test]
fn query_joins_when_reads_the_main_scope() {
let ok = joining(
json!([{ "as": "a", "query": "a.b.getOther", "when": "response.mine", "unless": "me" },
{ "as": "b", "query": "a.b.getOther", "params": { "x": { "$": "at" } }, "when": "at" }]),
);
assert!(parse(&ok, false).is_ok(), "{:?}", problems(&ok, false));
let bad = joining(
json!([{ "as": "a", "query": "a.b.getOther", "when": "items.0", "unless": "items.1" }]),
);
assert_eq!(
problems(&bad, false),
[
"query.join[0].when: a path in the main scope: from method, service, params, response, me, at",
"query.join[0].unless: a path in the main scope: from method, service, params, response, me, at"
]
);
}
/// A query join's params read the main scope, never another join's
/// result; the names are its own beside the record joins'.
#[test]
fn query_joins_read_the_main_scope() {
let bad = joining(json!([
{ "as": "a", "query": "a.b.getOther", "params": { "x": { "$": "joins.readme.text" } } },
{ "as": "b", "query": "a.b.getOther", "params": { "x": { "$root": "joins.a.uri" } } },
{ "as": "c", "query": "a.b.getOther", "params": { "x": { "$": "items.0.uri" } } },
{ "as": "d", "query": "a.b.getOther", "params": { "x": { "$": ["response.uri", "joins.a"] } } },
{ "as": "e", "query": "a.b.getOther", "params": { "x": { "y": 1 }, "z": [[1]], "w": { "$atUri": ["a", "b", "c"] } } },
{ "as": "e", "query": "nope", "service": "nope", "say": { "noun": ["x", "xs"] } }
]));
let found = problems(&bad, false);
assert_eq!(
found
.iter()
.map(|p| p.split_once(": ").unwrap().0)
.collect::<Vec<_>>(),
[
"query.join[0].params.x",
"query.join[1].params.x",
"query.join[2].params.x",
"query.join[3].params.x",
"query.join[4].params.x",
"query.join[4].params.z",
"query.join[4].params.w",
"query.join[5].query",
"query.join[5].service",
"query.join[5].say",
],
"{found:?}"
);
assert!(found[0].ends_with("never a join's result"), "{}", found[0]);
assert!(found[1].ends_with("never a join's result"), "{}", found[1]);
assert!(found[2].ends_with("a path from method, service, params, response, me, at"));
assert!(found[3].ends_with("never a join's result"), "{}", found[3]);
// A list reads its page, a record its record too; never a record
// join's result.
let mut doc = posts(json!({ "component": "Badge", "props": { "value": "x" } }));
doc["record"] = doc["list"].clone();
let thread = |at: &str| {
json!([{ "as": "pub", "ref": "value.reply.root" },
{ "as": "t", "query": "app.bsky.feed.getPostThread", "params": { "uri": { "$": at } } }])
};
doc["list"]["join"] = thread("records.0.uri");
doc["record"]["join"] = thread("value.reply.root.uri");
assert!(parse(&doc, false).is_ok(), "{:?}", problems(&doc, false));
doc["list"]["join"] = thread("value.reply.root.uri");
doc["record"]["join"] = thread("records.0.joins.pub.uri");
assert_eq!(
wheres(&doc),
["list.join[1].params.uri", "record.join[1].params.uri"]
);
doc["record"]["join"] = json!([{ "as": "t", "ref": "value.x" },
{ "as": "t", "query": "app.bsky.feed.getPostThread", "params": { "uri": { "$": "uri" } } }]);
doc["list"]["join"] = json!([]);
assert_eq!(
problems(&doc, false),
["record.join[1].as: \"t\" is used twice"]
);
}
/// In a records mode, a query join's service is its own, or its
/// method's bundled view's.
#[test]
fn query_joins_in_records_modes_name_a_service() {
let mut doc = posts(json!({ "component": "Badge", "props": { "value": "x" } }));
doc["list"]["join"] = json!([
{ "as": "a", "query": "app.bsky.feed.getPostThread", "params": { "uri": { "$": "records.0.uri" } } },
{ "as": "b", "query": "a.b.getOther", "service": "did:web:x.example#svc" },
{ "as": "c", "query": "a.b.getOther" }
]);
assert_eq!(
problems(&doc, false),
["list.join[2].service: required: no bundled view of a.b.getOther names its service"]
);
doc["list"]["join"].as_array_mut().unwrap().pop();
let v = parse(&doc, false).unwrap();
let q = &v.list.as_ref().unwrap().queries;
assert_eq!(
q[0].service_or(None).as_deref(),
Some("did:web:api.bsky.app#bsky_appview")
);
}
#[test]
fn says_checked() {
for (say, ok) in [
(json!({ "noun": ["post", "posts"], "count": "feed" }), true),
(
json!({ "noun": ["README", "READMEs"], "label": "text" }),
true,
),
(json!({ "noun": ["post", "posts"] }), false),
(
json!({ "noun": ["post", "posts"], "count": "feed", "label": "text" }),
false,
),
(json!({ "noun": ["post"], "count": "feed" }), false),
(json!({ "noun": ["post", "posts"], "count": "a b" }), false),
(json!("5 posts"), false),
] {
let mut j = query_join(0);
j["say"] = say.clone();
assert_eq!(parse(&joining(json!([j])), false).is_ok(), ok, "{say}");
}
}
/// The lexicon documents tests check query joins and routed records
/// against: the bundled ones, and knotless's as it publishes them
/// (testdata/knotless), its queries and records.
fn lexicon_docs() -> Vec<std::sync::Arc<Value>> {
let knotless = [
include_str!("testdata/knotless/dev.knotless.getFile.json"),
include_str!("testdata/knotless/dev.knotless.listReleases.json"),
include_str!("testdata/knotless/dev.knotless.defs.json"),
include_str!("testdata/knotless/dev.knotless.listActorItems.json"),
include_str!("testdata/knotless/dev.knotless.getActorStars.json"),
include_str!("testdata/knotless/dev.knotless.getActorRepos.json"),
include_str!("testdata/knotless/dev.knotless.getFeed.json"),
include_str!("testdata/knotless/dev.knotless.getRepo.json"),
include_str!("testdata/knotless/dev.knotless.getThread.json"),
include_str!("testdata/knotless/dev.knotless.getProfile.json"),
include_str!("testdata/knotless/dev.knotless.repo.json"),
include_str!("testdata/knotless/dev.knotless.check.json"),
include_str!("testdata/knotless/dev.knotless.issue.json"),
include_str!("testdata/knotless/dev.knotless.pull.json"),
include_str!("testdata/knotless/dev.knotless.comment.json"),
include_str!("testdata/knotless/dev.knotless.star.json"),
include_str!("testdata/knotless/dev.knotless.profile.json"),
include_str!("testdata/knotless/dev.knotless.release.json"),
];
crate::lexicon::all_bundled()
.cloned()
.chain(
knotless
.iter()
.map(|t| std::sync::Arc::new(serde_json::from_str(t).unwrap())),
)
.collect()
}
/// A query join's literal params are checked against its method's
/// lexicon as the view loads: names it does not take, required ones
/// left out, values it refuses; a bound one only when it runs.
#[test]
fn query_join_params_are_their_methods() {
let docs = lexicon_docs();
let check = |j: Value| {
let v = parse(&joining(json!([j])), false).unwrap();
query_join_problems(&v.query.unwrap().queries[0], &docs)
};
let feed = |params: Value| json!({ "as": "a", "query": "app.bsky.feed.getAuthorFeed", "params": params });
assert_eq!(
check(feed(
json!({ "actor": { "$": "response.did" }, "limit": 5 })
)),
Vec::<String>::new()
);
assert_eq!(
check(feed(
json!({ "actor": { "$": "response.did" }, "nope": 1, "limit": 500 })
)),
[
"query.join[0].params.nope: not a parameter of app.bsky.feed.getAuthorFeed",
"query.join[0].params.limit can not be greater than 100"
]
);
assert_eq!(
check(feed(json!({ "limit": 5 }))),
["query.join[0].params.actor: app.bsky.feed.getAuthorFeed requires it"]
);
assert_eq!(
check(json!({ "as": "a", "query": "app.bsky.feed.post" })),
["query.join[0].query: app.bsky.feed.post is a record, not a query: HUD only reads"]
);
assert_eq!(
check(json!({ "as": "a", "query": "com.example.unknown" })),
["query.join[0].query: no lexicon for com.example.unknown"]
);
}
/// Every bundled query join's params are its method's.
#[test]
fn bundled_query_joins_are_their_methods() {
let docs = lexicon_docs();
let mut seen = Vec::new();
for b in Views::built_in().all() {
for j in b.view.query_joins() {
assert_eq!(
query_join_problems(j, &docs),
Vec::<String>::new(),
"{}",
b.id
);
assert!(
j.service_or(b.view.service.as_deref()).is_some(),
"{}",
b.id
);
seen.push(format!("{} {}", b.id, j.name));
}
}
assert_eq!(
seen,
[
"bsky-app profile",
"bsky-app posts",
"bsky-app feeds",
"bsky-chat-with messages",
"bsky-notifications subjects",
"bsky-profile posts",
"bsky-profile feeds",
"knotless-app issues",
"knotless-app pulls",
"knotless-app stars",
"knotless-app recent",
"knotless-repo readme",
"knotless-repo release",
"standard-document replies",
]
);
}
/// The format of the string a routed record's binding reads, by the
/// record's lexicon (`docs`): its `uri` an at-uri, its `did` a DID, its
/// `cid` a CID, a path in its `value` the string's own format, through
/// refs; none for what is no string with a format.
fn read_format(
docs: &[std::sync::Arc<Value>],
collection: &str,
path: &Path,
) -> Option<String> {
let (first, rest) = path.split_first()?;
let known = [("uri", "at-uri"), ("did", "did"), ("cid", "cid")];
if let Some((_, format)) = known.iter().find(|(k, _)| *k == first) {
return Some(format.to_string());
}
let doc = |id: &str| docs.iter().find(|d| d["id"] == id).cloned();
let (mut at, mut def) = (
collection.to_string(),
doc(collection)?["defs"]["main"]["record"].clone(),
);
for key in rest {
def = def["properties"][key].clone();
while def["type"] == "ref" {
let r = def["ref"].as_str()?;
let full = crate::lexicon::full_ref(&at, r);
let (id, name) = full.split_once('#').unwrap_or((full.as_str(), "main"));
def = doc(id)?["defs"][name].clone();
at = id.to_string();
}
}
(def["type"] == "string").then(|| def["format"].as_str().map(str::to_string))?
}
/// Every bundled routed record's params are its method's, as its
/// lexicon takes them, the record's lexicon read for what each binding
/// gives (an at-uri where the method takes one, a DID for an account),
/// as launchers' are checked.
#[test]
fn routed_records_are_their_methods() {
let docs = lexicon_docs();
let mut seen = 0;
for b in bundled() {
let Some(method) = b.view.method.as_deref() else {
continue;
};
for r in &b.view.records {
let at = format!("{} {}", b.id, r.collection);
let doc = docs.iter().find(|d| d["id"] == method);
let doc = doc.ok_or(format!("no lexicon for {method}")).unwrap();
let def = crate::xrpc::query_def(method, doc).unwrap();
assert_eq!(
docs.iter()
.find(|d| d["id"] == r.collection.as_str())
.map(|d| d["defs"]["main"]["type"].clone()),
Some(json!("record")),
"{at}: no record lexicon"
);
// A record whose every binding finds a string of the
// format it reads, which the method takes.
let mut record = json!({});
for (k, p) in &r.params {
let Prop::Bound(binding) = p else { continue };
let path = &binding.0[0];
let read = read_format(&docs, &r.collection, path);
let read = read.ok_or(format!("{at}: {k} reads no string")).unwrap();
let takes = def["parameters"]["properties"][k]["format"]
.as_str()
.unwrap_or_default();
let fits = read == takes || (read == "did" && takes == "at-identifier");
assert!(fits, "{at}: {k} reads {read}, the method takes {takes}");
let given = match read.as_str() {
"did" => json!("did:plc:abcdefghijklmnopqrstuvwx"),
_ => json!(format!(
"at://did:plc:abcdefghijklmnopqrstuvwx/{}/3abc",
r.collection
)),
};
let slot = path
.0
.iter()
.fold(&mut record, |v, key| &mut v[key.as_str()]);
*slot = given;
}
let params = r.params_for(&record).unwrap();
let lexicons = crate::xrpc::lexicons_for(method, &docs);
assert_eq!(
crate::xrpc::params_problems(&lexicons, method, def, ¶ms),
Vec::<String>::new(),
"{at}"
);
seen += 1;
}
}
assert_eq!(seen, 11);
// A release's repo is a TID, no at-uri: nothing routes one.
let repo = Path::parse("value.repo").unwrap();
assert_eq!(
read_format(&docs, "dev.knotless.release", &repo).as_deref(),
Some("tid")
);
assert!(route("dev.knotless.release").is_none());
}
fn app_page(join: Value) -> Value {
json!({ "domain": "knotless.dev", "app": "knotless", "description": "Home",
"service": "did:web:knotless.dev#knotless_appview",
"page": { "join": join,
"layout": { "component": "Text", "props": { "value": { "$": "name" } } } } })
}
/// An app page view draws its domain's page, its joins reading the
/// page's main scope alone; only a bundled view is one.
#[test]
fn app_pages_are_bundled_alone() {
let feed = json!([{ "as": "recent", "query": "dev.knotless.getFeed",
"params": { "actor": { "$": "actor.did" }, "limit": 5 } }]);
let v = parse(&app_page(feed.clone()), true).unwrap();
assert_eq!(v.domain.as_deref(), Some("knotless.dev"));
assert_eq!(v.drawn(), "knotless.dev");
assert_eq!(v.query_joins().count(), 1);
assert!(v.collection.is_none() && v.method.is_none() && v.query.is_none());
// Inline, refused.
let mut inline = app_page(feed);
inline.as_object_mut().unwrap().remove("app");
assert_eq!(
parse(&inline, false).unwrap_err(),
["view.page: only a bundled view is an app's page"]
);
// A join reads the page's scope, never another's.
let response = json!([{ "as": "a", "query": "dev.knotless.getFeed",
"params": { "actor": { "$": "response.did" } } }]);
assert!(parse(&app_page(response), true).is_err());
// A domain in place of a collection or method, never beside one.
let mut both = app_page(json!([]));
both["method"] = json!("dev.knotless.getFeed");
assert_eq!(
parse(&both, true).unwrap_err(),
["view: an app page draws its domain, not a collection or a method"]
);
let mut upper = app_page(json!([]));
upper["domain"] = json!("Knotless.dev");
assert!(parse(&upper, true).is_err());
// The bundled ones: knotless's, Bluesky's; none for Bluesky Chat.
assert_eq!(
for_domain("knotless.dev").map(View::drawn),
Some("knotless.dev")
);
assert_eq!(for_domain("bsky.app").map(View::drawn), Some("bsky.app"));
assert!(for_domain("bsky.chat").is_none());
}
fn badge() -> Value {
json!({ "component": "Badge", "props": { "value": "x" } })
}
/// A collection view drawing its list with `layout`, and `extra` keys.
fn listing(layout: Value, extra: Value) -> Value {
let mut doc =
json!({ "collection": "a.b.c", "description": "d", "list": { "layout": layout } });
doc.as_object_mut()
.unwrap()
.extend(extra.as_object().unwrap().clone());
doc
}
/// A method view drawing its query with `query`, and `extra` keys.
fn querying(query: Value, extra: Value) -> Value {
let mut doc = json!({ "method": "a.b.c", "service": "did:web:x.example#svc",
"description": "d", "query": query });
doc.as_object_mut()
.unwrap()
.extend(extra.as_object().unwrap().clone());
doc
}
/// What a bundled view alone names, each where only some views may.
#[test]
fn trusted_keys_belong_to_their_views() {
let mut no_service = app_page(json!([]));
no_service.as_object_mut().unwrap().remove("service");
let mut no_domain = app_page(json!([]));
no_domain.as_object_mut().unwrap().remove("domain");
let mut no_page = app_page(json!([]));
no_page.as_object_mut().unwrap().remove("page");
let mut profiled = app_page(json!([]));
profiled["profile"] = json!({ "title": "Home" });
let mut tagged = app_page(json!([]));
tagged["page"]["tag"] = json!("x");
let mut paged = app_page(json!([]));
paged["page"]["pages"] = json!("recent");
let method = |extra: Value| querying(json!({ "layout": badge() }), extra);
let items = |extra: Value| querying(json!({ "items": "items", "layout": badge() }), extra);
for (doc, want) in [
(
listing(badge(), json!({ "signIn": "Sign in" })),
"view.signIn: only a method view's query asks for sign-in",
),
(
listing(badge(), json!({ "launch": [{ "title": "All" }] })),
"view.launch: only a method view's query is launched",
),
(
no_service,
"view.service: an app page names the service its joins call",
),
(
profiled,
"view.profile: an app page adds no section to profiles",
),
(no_domain, "view.domain: an app page names its app's domain"),
(
no_page,
"view.page: an app page needs its page: { join?, layout, tag?, pages? }",
),
(tagged, "page.tag: must be an object"),
(paged, "page.pages: the as of one of the page's joins"),
(
querying(json!({ "latest": "uri", "layout": badge() }), json!({})),
"query.latest: the path to each item's key: name query.items too, or no latest",
),
(
method(json!({ "profile": { "title": "Things", "head": "yes" } })),
"view.profile.head: must be true or false",
),
(
method(json!({ "profile": { "title": "Things", "params": { "a": null } } })),
"view.profile.params.a: must be a string, number, boolean or {\"$actor\": \"did\"}, or an array of those",
),
(
method(json!({ "profile": { "title": "Things", "params": [1] } })),
"view.profile.params: must be an object of at most 8 params",
),
(
method(json!({ "launch": [5] })),
"view.launch[0]: must be an object",
),
(
method(json!({ "launch": [{ "title": "Mine", "params": [1] }] })),
"view.launch[0].params: must be an object of params",
),
(
method(json!({ "records": [5] })),
"view.records[0]: must be an object",
),
(
method(
json!({ "records": [{ "collection": "nope", "params": { "uri": { "$": "uri" } } }] }),
),
"view.records[0].collection: must be an NSID",
),
(
items(json!({ "interactions": { "item": "uri" } })),
"view.interactions.feed: required",
),
(
items(json!({ "interactions": { "feed": { "$": "params.feed" } } })),
"view.interactions.item: required: the path to an item's uri",
),
(
listing(badge(), json!({ "origins": "https://cdn.example" })),
"view.origins: must be 1 to 8 origins, as https://host[:port]",
),
(
listing(
badge(),
json!({ "origins": ["https://cdn.example"], "thumbnails": [5] }),
),
"view.thumbnails[0]: must be an object",
),
] {
assert_eq!(problems(&doc, true), [want], "{doc}");
}
// A page whose joins are left out joins nothing.
let mut plain = app_page(json!([]));
plain["page"].as_object_mut().unwrap().remove("join");
assert_eq!(parse(&plain, true).unwrap().query_joins().count(), 0);
}
/// A view's measure is one of three widths, any of them allowed, and a
/// split is two sides.
#[test]
fn measure_and_split_checked() {
for m in MEASURES {
assert_eq!(
problems(&listing(badge(), json!({ "measure": m })), true),
Vec::<String>::new()
);
}
assert_eq!(
problems(&listing(badge(), json!({ "measure": "huge" })), false),
["view.measure: must be one of content, wide, full"]
);
let when = |cases: Value| listing(badge(), json!({ "measureWhen": cases }));
assert_eq!(
problems(
&when(json!([{ "when": "params.camera", "measure": "wide" }])),
true
),
Vec::<String>::new()
);
for bad in [
json!([]),
json!({}),
json!(vec![json!({ "when": "a", "measure": "wide" }); 9]),
] {
assert_eq!(
problems(&when(bad.clone()), true),
["view.measureWhen: must be 1 to 8 cases"],
"{bad}"
);
}
assert_eq!(
problems(
&when(json!([5, { "when": "a..b", "measure": "huge", "x": 1 }, {}])),
true
),
[
"view.measureWhen[0]: must be an object",
"view.measureWhen[1]: unknown key \"x\"",
"view.measureWhen[1].when: unknown path syntax \"a..b\"",
"view.measureWhen[1].measure: must be one of content, wide, full",
"view.measureWhen[2].when: must be a path, keys joined by dots",
"view.measureWhen[2].measure: must be one of content, wide, full",
]
);
let split = |k: Vec<Value>| json!({ "component": "Split", "props": { "side": "start", "aside": "sm" }, "children": k });
assert_eq!(
problems(&listing(split(vec![badge(), badge()]), json!({})), false),
Vec::<String>::new()
);
for k in [vec![badge()], vec![badge(), badge(), badge()]] {
assert_eq!(
problems(&listing(split(k), json!({})), false),
["list.layout.children: Split takes two children"]
);
}
assert_eq!(
problems(&listing(json!({ "component": "Split" }), json!({})), false),
["list.layout.children: Split takes two children"]
);
}
/// Each malformed join, query join, layout node, open and template
/// named where it is.
#[test]
fn malformed_parts_named() {
let list = |layout: Value| listing(layout, json!({}));
let joined = |join: Value| {
listing(
badge(),
json!({ "list": { "join": join, "layout": badge() } }),
)
};
let one_param = |params: Value| {
joining(json!([{ "as": "o", "query": "a.b.getOther", "params": params }]))
};
let backlinks = |order: Value| {
joined(json!([{ "as": "items", "orderBy": order,
"backlinks": { "collection": "a.b.item", "path": "value.of" } }]))
};
let opening = |params: Value| {
list(
json!({ "component": "Link", "props": { "open": { "query": "a.b.getThing", "params": params } } }),
)
};
let action = |props: Value| list(json!({ "component": "Action", "props": props }));
let creating = |record: Value| {
action(
json!({ "label": "Go", "create": { "collection": "a.b.like", "record": record } }),
)
};
let mut deep = json!(1);
for _ in 0..12 {
deep = json!({ "a": deep });
}
let nine: Map<String, Value> = (0..9).map(|i| (format!("p{i}"), json!(i))).collect();
for (doc, want) in [
(
joined(json!({})),
vec!["list.join: must be an array of joins"],
),
(
joining(json!([{ "as": "a.b", "query": "a.b.getOther" }])),
vec!["query.join[0].as: must be a key, [A-Za-z0-9_$]+"],
),
(
one_param(Value::Object(nine)),
vec!["query.join[0].params: 9 params, more than 8"],
),
(
one_param(json!({ "a-b": 1 })),
vec!["query.join[0].params.a-b: a param's name is [A-Za-z0-9_]+"],
),
(
one_param(json!([1])),
vec!["query.join[0].params: must be an object of params"],
),
(
one_param(json!({ "x": { "$each": "response.items" } })),
vec![
"query.join[0].params.x: $each is [array, path] alone: the path within each element of the array",
],
),
(
one_param(json!({ "x": { "$root": "response.did", "y": 1 } })),
vec!["query.join[0].params.x: a root binding has the key \"$root\" alone"],
),
(
backlinks(json!("value.at")),
vec!["list.join[0].orderBy: must be at most 4 paths"],
),
(
backlinks(json!([5])),
vec!["list.join[0].orderBy[0]: must be a path, keys joined by dots"],
),
(
joined(json!([{ "as": "n", "counts": { "likes": 5 } }])),
vec!["list.join[0].counts.likes: must be an object"],
),
(list(json!(5)), vec!["list.layout: must be an object"]),
(
list(json!({ "props": {} })),
vec!["list.layout.component: required: a component's name"],
),
(
list(json!({ "component": "Badge", "props": [1] })),
vec![
"list.layout.props: must be an object",
"list.layout.props.value: Badge requires it",
],
),
(
list(json!({ "component": "Stack", "children": {} })),
vec!["list.layout.children: must be an array of nodes"],
),
(
list(json!({ "component": "Badge", "props": { "value": { "$": [] } } })),
vec!["list.layout.props.value: a binding tries 1 to 4 paths"],
),
(
opening(json!({ "uri": { "$atUri": ["a", "b", "c"], "x": 1 } })),
vec![
"list.layout.props.open.params.uri: an at-uri to build has the key \"$atUri\" alone",
],
),
(
opening(json!({ "uris": vec!["x"; 51] })),
vec!["list.layout.props.open.params.uris: more than 50 elements"],
),
(
action(json!({ "label": "Go", "create": { "collection": "a.b.like" } })),
vec!["list.layout.props.create.record: required"],
),
(
action(json!({ "label": "Go", "delete": {} })),
vec!["list.layout.props.delete.uri: required"],
),
(
creating(deep),
vec![
"list.layout.props.create.record.a.a.a.a.a.a.a.a.a.a.a.a: a template nests at most 12 deep",
],
),
(
creating(json!({ "x": { "$first": [1] } })),
vec![
"list.layout.props.create.record.x: {\"$first\": [values]} has the key $first alone, 2 to 4 values",
],
),
] {
assert_eq!(problems(&doc, false), want, "{doc}");
}
}
/// A bundled view's procedure calls: an input left out is an empty
/// one; one too big or no object refused; a conversation's text may go
/// anywhere in its input, alone.
#[test]
fn call_inputs_checked() {
let action = |call: Value| {
querying(
json!({ "layout": { "component": "Action", "props": { "label": "Go", "call": call } } }),
json!({}),
)
};
let service = "did:web:x.example#svc";
let v = parse(
&action(json!({ "method": "a.b.doIt", "service": service })),
true,
)
.unwrap();
assert_eq!(
v.calls,
[Call {
method: "a.b.doIt".into(),
service: service.into(),
input: json!({}),
deletes: false,
}]
);
assert_eq!(
problems(
&action(json!({ "method": "a.b.doIt", "service": service,
"input": { "big": "x".repeat(5000) } })),
true
),
["query.layout.props.call.input: 5010 bytes, more than the 4096 an input may take"]
);
assert_eq!(
problems(
&action(json!({ "method": "a.b.doIt", "service": service, "input": { "$": "x" } })),
true
),
["query.layout.props.call.input: must be an object, the procedure's input"]
);
let messages = |input: Value| {
querying(
json!({ "items": "messages", "layout": { "component": "Messages", "props": {
"items": { "$": "items" }, "from": "sender.did",
"send": { "method": "a.b.send", "service": service, "input": input } } } }),
json!({}),
)
};
let parts = parse(&messages(json!({ "parts": [{ "$text": true }] })), true).unwrap();
assert_eq!(
parts.calls[0].input,
json!({ "parts": [{ "$text": true }] })
);
assert_eq!(
problems(&messages(json!({ "t": { "$text": true, "x": 1 } })), true),
["query.layout.props.send.input.t: {\"$text\": true} has the key $text alone, true"]
);
}
/// A literal refused by its prop's type says what the type takes.
#[test]
fn literals_checked_by_their_types() {
let node = |component: &str, props: Value| {
listing(json!({ "component": component, "props": props }), json!({}))
};
let at = |prop: &str, why: &str| format!("list.layout.props.{prop}: {why}");
for (doc, want) in [
(
node("Text", json!({ "value": "x", "clamp": 0 })),
at("clamp", "must be an integer from 1 to 100"),
),
(
node("Stack", json!({ "when": 5 })),
at(
"when",
"must be a path, keys joined by dots, or {\"$kit\": a semver requirement, as \">=0.3.0\"}",
),
),
(
node("Stack", json!({ "mine": 5 })),
at("mine", "must be a path, keys joined by dots"),
),
(
node(
"Covers",
json!({ "items": { "$": "records" }, "src": { "$": "value.src" }, "countNoun": ["a"] }),
),
at("countNoun", "must be [singular, plural]"),
),
(
node(
"Image",
json!({ "src": { "$": "value.src" }, "aspectRatio": { "width": 1, "height": 0 } }),
),
at("aspectRatio", "must be {width, height}, positive integers"),
),
(
node("ContentWarning", json!({ "labels": [1] })),
at("labels", "must be labels or a binding"),
),
(
node("Action", json!({ "label": "Go", "create": "x" })),
at("create", "must be { collection, record }"),
),
(
node("Action", json!({ "label": "Go", "delete": "x" })),
at("delete", "must be { uri: binding }"),
),
(
node("Action", json!({ "label": "Go", "interaction": "x" })),
at("interaction", "must be { event }"),
),
(
node("Action", json!({ "label": "Go", "call": "x" })),
at("call", "must be { method, service, input? }"),
),
(
node("Action", json!({ "label": "Go", "deletes": "x" })),
at(
"deletes",
"must be { method, service, params?, repeat?, collections?, then? }",
),
),
(
node("List", json!({ "items": { "$": "records" }, "where": 5 })),
at(
"where",
"must be an object of 1 to 4 paths within each element to paths in the scope or {\"$is\": a string, number or boolean}, either in {\"$not\": …}",
),
),
(
node(
"State",
json!({ "value": "x", "roles": { "open": "nope" } }),
),
at(
"roles",
&format!(
"must be an object of 1 to 32 values to one of {}, each at most 64 characters",
catalog::ROLES.join(", ")
),
),
),
(
node("Diff", json!({ "path": "x", "kinds": { "x": "y" } })),
at(
"kinds",
"must be an object of 1 to 32 of added, removed, hunk, note to words, each at most 64 characters",
),
),
] {
assert_eq!(problems(&doc, false), [want], "{doc}");
}
// A composer's parts each as their types take them.
let compose = problems(
&node(
"Compose",
json!({ "label": "Go", "fields": "x", "writes": "x", "given": [1] }),
),
false,
);
for want in [
at("fields", "must be an array of fields"),
at("writes", "must be an array of writes"),
at("given", "must be an object of at most 8 values"),
] {
assert!(compose.contains(&want), "{compose:?}");
}
// Any JSON is any.
assert!(
parse(
&node("RichText", json!({ "value": "x", "facets": [1] })),
false
)
.is_ok()
);
}
/// A trusted view that does not load names its file in each of its
/// problems, every one of them.
#[test]
fn a_broken_bundled_view_names_its_file() {
let load = |id: &str, text: &str| load(format!("views/{id}.json"), id, text, &[]);
let err = load("broken", "{").err().unwrap();
assert!(err[0].starts_with("views/broken.json: EOF"), "{err:?}");
let mut doc = listing(badge(), json!({}));
for i in 0..25 {
doc[format!("k{i}")] = json!(1);
}
let err = load("broken", &doc.to_string()).err().unwrap();
assert_eq!(err.len(), 25);
assert_eq!(err[0], "views/broken.json: view: unknown key \"k0\"");
assert_eq!(err[24], "views/broken.json: view: unknown key \"k24\"");
let fine = listing(badge(), json!({})).to_string();
let (fine, warnings) = load("fine", &fine).unwrap();
assert_eq!(fine.id, "fine");
assert!(warnings.is_empty());
}
/// A key written `?key` is optional: read as `key` where this HUD knows
/// it, and left out, with a warning naming the problem, where it finds
/// one in it (a prop, a value or a key it doesn't know), at any depth.
/// What dropping it leaves wrong, or a problem anywhere else, still
/// refuses the view, as does a key given both ways.
#[test]
fn an_optional_key_is_left_out_where_it_falls_short() {
let load = |doc: Value| load("views/v.json".into(), "v", &doc.to_string(), &[]);
let stack = |props: Value| {
json!({ "component": "Stack", "props": props,
"children": [{ "component": "Badge", "props": { "value": "x", "?shiny": true } }] })
};
// Known: read as its key, with no warning.
let (b, warnings) = load(listing(
stack(json!({ "?gap": "sm" })),
json!({ "?$type": TYPE }),
))
.unwrap();
assert_eq!(
b.view.doc["list"]["layout"]["props"],
json!({ "gap": "sm" })
);
assert_eq!(b.view.doc["$type"], TYPE);
assert_eq!(
warnings,
[
"views/v.json: list.layout.children[0].props.shiny: Badge has no prop \"shiny\" (?shiny is optional, so it's left out)"
]
);
assert_eq!(
b.view.doc["list"]["layout"]["children"][0]["props"],
json!({ "value": "x" })
);
// A value this HUD doesn't know, and a key at the top it doesn't.
let (b, warnings) = load(listing(
stack(json!({ "?gap": "huge" })),
json!({ "?newer": { "a": 1 } }),
))
.unwrap();
assert_eq!(b.view.doc["list"]["layout"]["props"], json!({}));
assert!(b.view.doc.get("newer").is_none());
assert_eq!(
warnings,
[
"views/v.json: view: unknown key \"newer\" (?newer is optional, so it's left out)",
"views/v.json: list.layout.props.gap: must be one of none, xs, sm, md, lg (?gap is optional, so it's left out)",
"views/v.json: list.layout.children[0].props.shiny: Badge has no prop \"shiny\" (?shiny is optional, so it's left out)",
]
);
// Left out, a required key is missing: refused.
let mut doc = listing(badge(), json!({ "?description": "a\nb" }));
doc.as_object_mut().unwrap().remove("description");
assert_eq!(
load(doc).unwrap_err(),
["views/v.json: view.description: must be one line of text, 200 characters at most"]
);
// A problem elsewhere refuses it, the optional one left out.
assert_eq!(
load(listing(stack(json!({ "nope": 1 })), json!({}))).unwrap_err(),
["views/v.json: list.layout.props.nope: Stack has no prop \"nope\""]
);
// Both ways at once.
assert_eq!(
load(listing(
stack(json!({ "gap": "sm", "?gap": "md" })),
json!({})
))
.unwrap_err(),
["views/v.json: list.layout.props: \"?gap\" and \"gap\" both given"]
);
assert_eq!(
load(listing(badge(), json!({ "?description": "e" }))).unwrap_err(),
["views/v.json: view: \"?description\" and \"description\" both given"]
);
}
/// The trusted views are read once: the operator's are added before.
#[test]
fn the_operators_views_come_before_any_are_read() {
assert!(!bundled().is_empty());
assert_eq!(
install(Views::built_in()).unwrap_err(),
"the trusted views were read before the operator's were added"
);
}
/// Two trusted views drawing one thing, or a collection as their
/// query, are named by their files.
#[test]
fn conflicts_name_their_files() {
let thread = for_method("app.bsky.feed.getPostThread").unwrap();
let as_file = |id: &str| Bundled {
id: id.into(),
file: format!("{id}.json"),
view: thread.clone(),
};
assert_eq!(conflicts(&[as_file("a")]), Vec::<String>::new());
assert_eq!(
conflicts(&[as_file("a"), as_file("b")]),
[
"b.json: a.json draws app.bsky.feed.getPostThread too",
"b.json: a.json draws app.bsky.feed.post as its query too",
"b.json: a.json draws app.bsky.feed.repost as its query too"
]
);
// Two views deleting by one query, saying otherwise beyond it.
let plan = Plan {
method: "a.b.getPlan".into(),
service: "did:web:x.example#svc".into(),
repeat: true,
collections: Vec::new(),
then: None,
};
let planning = |id: &str, repeat: bool| {
let mut b = as_file(id);
b.view.records.clear();
b.view.method = Some(format!("a.b.{id}"));
b.view.plans = vec![Plan {
repeat,
..plan.clone()
}];
b
};
let same = [planning("a", true), planning("b", true)];
assert_eq!(conflicts(&same), Vec::<String>::new());
assert_eq!(
conflicts(&[planning("a", true), planning("b", false)]),
["b.json: deletes a.b.getPlan otherwise than before"]
);
}
/// What a trusted view is held to beyond its document, as the bundled
/// ones are by the tests and the operator's as HUD starts.
#[test]
fn trusted_views_checked() {
let docs = lexicon_docs();
let section = |method: &str, params: Value| {
let doc = json!({ "method": method, "service": "did:web:x.example#svc", "description": "d",
"profile": { "title": "T", "params": params },
"query": { "layout": badge() } });
trusted_problems(&parse(&doc, true).unwrap(), &docs, views())
};
assert_eq!(
section("a.b.c", json!({})),
["view.profile: no lexicon for a.b.c"]
);
assert_eq!(
section("social.grain.graph.muteActor", json!({})),
[
"view.profile: social.grain.graph.muteActor is a procedure, not a query: HUD only reads"
]
);
assert_eq!(
section(
"app.bsky.feed.getAuthorFeed",
json!({ "actor": { "$actor": "did" }, "nope": 1 })
),
["view.profile: params.nope is not a parameter of app.bsky.feed.getAuthorFeed"]
);
// A records view's join names its service, or its method's view
// does: checked against the views as they are used.
let join = listing(
badge(),
json!({ "list": { "layout": badge(), "join": [
{ "as": "x", "query": "a.b.getX", "params": {} }] } }),
);
let services = [("a.b.getX".to_string(), "did:web:x.example#svc".to_string())];
let v = parse_in(&join, true, &services).unwrap();
assert_eq!(
trusted_problems(&v, &docs, views()),
[
"view: a trusted collection view draws a page of records (list) and one (record)",
"list.join[0].query: no lexicon for a.b.getX",
"list.join[0].service: no view of a.b.getX names its service"
]
);
}
/// A records view's query join that reads its page's records runs on
/// every page; one of literals alone, on the first.
#[test]
fn query_joins_reading_records_run_per_page() {
let doc = listing(
badge(),
json!({ "list": { "layout": badge(), "join": [
{ "as": "top", "query": "a.b.getTop", "service": "did:web:x.example#svc",
"params": { "limit": 5 } },
{ "as": "each", "query": "a.b.getMany", "service": "did:web:x.example#svc",
"params": { "uris": { "$each": ["records", "uri"] } } }] } }),
);
let v = parse(&doc, false).unwrap();
let per_page: Vec<bool> = v.query_joins().map(QueryJoin::per_page).collect();
assert_eq!(per_page, [false, true]);
}
/// A query join of a method taking no params at all, given none, is
/// fine.
#[test]
fn a_query_join_of_a_method_without_params() {
let doc = joining(json!([{ "as": "o", "query": "a.b.getOther" }]));
let v = parse(&doc, false).unwrap();
let docs = [std::sync::Arc::new(
json!({ "lexicon": 1, "id": "a.b.getOther",
"defs": { "main": { "type": "query",
"output": { "encoding": "application/json", "schema": { "type": "object", "properties": {} } } } } }),
)];
let j = v.query_joins().next().unwrap();
assert_eq!(query_join_problems(j, &docs), Vec::<String>::new());
}
/// A call's procedure must have a lexicon, be a procedure, and take
/// the template's fields, its input a ref to a def of its own.
#[test]
fn call_problems_read_the_procedure() {
let call = |method: &str, input: Value| Call {
method: method.into(),
service: "did:web:x.example#svc".into(),
input,
deletes: false,
};
let docs = [
std::sync::Arc::new(json!({ "lexicon": 1, "id": "a.b.getIt",
"defs": { "main": { "type": "query" } } })),
std::sync::Arc::new(json!({ "lexicon": 1, "id": "a.b.doIt",
"defs": { "main": { "type": "procedure", "input": { "encoding": "application/json",
"schema": { "type": "ref", "ref": "#input" } } },
"input": { "type": "object", "required": ["text"],
"properties": { "text": { "type": "string" } } } } })),
];
assert_eq!(
call_problems(&call("a.b.none", json!({})), &docs),
["a.b.none: no lexicon"]
);
assert_eq!(
call_problems(&call("a.b.getIt", json!({})), &docs),
["a.b.getIt is a query, not a procedure"]
);
assert_eq!(
call_problems(&call("a.b.doIt", json!({ "nope": 1 })), &docs),
[
"a.b.doIt: input.nope is not an input of it",
"a.b.doIt: input.text is required"
]
);
assert_eq!(
call_problems(&call("a.b.doIt", json!({ "text": "hi" })), &docs),
Vec::<String>::new()
);
}
/// A deletion plan's query must have a lexicon, be a query answering
/// `writes`, and take the template's params, as it requires them.
#[test]
fn deletes_problems_read_the_query() {
let deletes = |method: &str, input: Value| Call {
method: method.into(),
service: "did:web:x.example#svc".into(),
input,
deletes: true,
};
let writes = json!({ "encoding": "application/json", "schema": { "type": "object",
"properties": { "writes": { "type": "array", "items": { "type": "unknown" } } } } });
let docs = [
std::sync::Arc::new(json!({ "lexicon": 1, "id": "a.b.getPlan",
"defs": { "main": { "type": "query", "output": writes,
"parameters": { "type": "params", "required": ["of"],
"properties": { "of": { "type": "string" } } } } } })),
std::sync::Arc::new(json!({ "lexicon": 1, "id": "a.b.getOther",
"defs": { "main": { "type": "query" } } })),
std::sync::Arc::new(json!({ "lexicon": 1, "id": "a.b.doIt",
"defs": { "main": { "type": "procedure" } } })),
];
assert_eq!(
call_problems(&deletes("a.b.none", json!({})), &docs),
["a.b.none: no lexicon"]
);
assert_eq!(
call_problems(&deletes("a.b.doIt", json!({})), &docs),
["a.b.doIt is a procedure, not a query: HUD only reads"]
);
assert_eq!(
call_problems(&deletes("a.b.getOther", json!({})), &docs),
["a.b.getOther: answers no writes, the deletes of one com.atproto.repo.applyWrites"]
);
assert_eq!(
call_problems(&deletes("a.b.getPlan", json!({ "nope": 1 })), &docs),
[
"a.b.getPlan: params.nope is not a param of it",
"a.b.getPlan: params.of is required"
]
);
assert_eq!(
call_problems(
&deletes("a.b.getPlan", json!({ "of": { "$": "uri" } })),
&docs
),
Vec::<String>::new()
);
}
/// A record whose query's params read the record itself is not opened
/// as the query by its at-uri alone; a launcher's title is had only
/// for its own params.
#[test]
fn routed_calls_and_launch_titles() {
assert_eq!(routed_call("at://did:plc:a/app.bsky.feed.repost/r1"), None);
// A story opens as its account's archive, at itself.
let story = "at://did:plc:a/social.grain.story/3s";
assert_eq!(
routed_call(story),
Some(json!({ "method": "social.grain.story.getArchive",
"params": { "actor": "did:plc:a" }, "at": story }))
);
let repos = "dev.knotless.getActorRepos";
assert_eq!(
launch_title(repos, &json!({ "actor": "did:plc:a" })).as_deref(),
Some("Repositories")
);
assert_eq!(launch_title(repos, &json!({ "cursor": "x" })), None);
}
}