atproto Thingiverse but good
PM-45: client appview session
+1539
-75
+15
.zed/settings.json
+15
.zed/settings.json
···
1
+
// Folder-specific settings
2
+
//
3
+
// For a full list of overridable settings, and general information on folder-specific settings,
4
+
// see the documentation: https://zed.dev/docs/configuring-zed#settings-files
5
+
{
6
+
"lsp": {
7
+
"rust-analyzer": {
8
+
"initialization_options": {
9
+
"cargo": {
10
+
"allFeatures": true,
11
+
},
12
+
},
13
+
},
14
+
},
15
+
}
+2
Cargo.lock
+2
Cargo.lock
···
6189
6189
"dioxus",
6190
6190
"dotenvy",
6191
6191
"futures",
6192
+
"http",
6192
6193
"hydrant",
6193
6194
"jacquard",
6194
6195
"jacquard-axum",
···
6197
6198
"js-sys",
6198
6199
"libsqlite3-sys",
6199
6200
"polymodel-api",
6201
+
"reqwest",
6200
6202
"rustls",
6201
6203
"serde",
6202
6204
"serde_json",
+3
-1
Cargo.toml
+3
-1
Cargo.toml
···
91
91
"fmt",
92
92
"env-filter",
93
93
] }
94
+
http = "1.4"
95
+
reqwest = { version = "0.12", default-features = false, features = ["json", "charset"] }
94
96
95
97
96
98
[target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
···
99
101
tracing-wasm = "0.2"
100
102
wasm-bindgen = "=0.2.121"
101
103
wasm-bindgen-futures = "0.4"
102
-
web-sys = { version = "0.3", features = ["Window", "Document", "Element", "Event", "EventTarget", "HtmlCanvasElement", "WebGl2RenderingContext", "Performance", "MouseEvent", "WheelEvent", "PointerEvent", "DomRect", "console", "Response"] }
104
+
web-sys = { version = "0.3", features = ["Window", "Document", "Element", "Event", "EventTarget", "HtmlCanvasElement", "WebGl2RenderingContext", "Performance", "MouseEvent", "WheelEvent", "PointerEvent", "DomRect", "BroadcastChannel", "console", "Response"] }
103
105
104
106
[dev-dependencies]
105
107
tokio = { version = "1", features = ["rt", "macros"] }
+43
-4
assets/styling/browse.css
+43
-4
assets/styling/browse.css
···
62
62
font-weight: 600;
63
63
padding: 0.45rem 0;
64
64
}
65
-
65
+
.session-control {
66
+
display: inline-flex;
67
+
align-items: stretch;
68
+
gap: 0;
69
+
flex-wrap: nowrap;
70
+
}
71
+
.session-control input {
72
+
width: min(9.5rem, 42vw);
73
+
min-height: 2rem;
74
+
padding: 0.45rem 0.65rem;
75
+
border: 1px solid var(--color-border);
76
+
border-right: 0;
77
+
border-radius: var(--radius-sm) 0 0 var(--radius-sm);
78
+
background: var(--color-surface);
79
+
color: var(--color-text);
80
+
font-family: var(--font-ui);
81
+
font-size: 0.9rem;
82
+
}
83
+
.session-control input:focus {
84
+
outline: 2px solid color-mix(in srgb, var(--color-primary) 25%, transparent);
85
+
outline-offset: 1px;
86
+
border-color: var(--color-primary);
87
+
}
88
+
.session-control .button {
89
+
min-height: 2rem;
90
+
border-radius: 0 var(--radius-sm) var(--radius-sm) 0;
91
+
}
92
+
.session-control-authenticated {
93
+
justify-content: flex-end;
94
+
gap: 0.5rem;
95
+
}
66
96
.foundation-hero {
67
97
display: grid;
68
98
grid-template-columns: minmax(0, 1.05fr) minmax(18rem, 0.95fr);
···
109
139
color: var(--color-primary);
110
140
}
111
141
112
-
.blueprint-axis-x { right: 0.75rem; bottom: 0.75rem; }
113
-
.blueprint-axis-y { left: 0.75rem; top: 0.75rem; }
114
-
.blueprint-dimension { left: 0.75rem; bottom: 0.75rem; }
142
+
.blueprint-axis-x {
143
+
right: 0.75rem;
144
+
bottom: 0.75rem;
145
+
}
146
+
.blueprint-axis-y {
147
+
left: 0.75rem;
148
+
top: 0.75rem;
149
+
}
150
+
.blueprint-dimension {
151
+
left: 0.75rem;
152
+
bottom: 0.75rem;
153
+
}
115
154
116
155
.browse-controls {
117
156
display: grid;
+52
-22
crates/polymodel-api/lexicons/space_polymodel_actor_getSession.json
+52
-22
crates/polymodel-api/lexicons/space_polymodel_actor_getSession.json
···
4
4
"defs": {
5
5
"main": {
6
6
"type": "query",
7
-
"description": "Identity primitive (PM-9). Returns the authenticated viewer's identity plus profile for SSR-first session seeding, or an unauthenticated marker. The profile field reuses the getProfile union shape so the client renders identity + profile from a single first-paint value. PM-26 returns only the unauthenticated marker ({authenticated: false}); the authenticated fields (did/handle/profile) are populated once PM-27 wires OAuth session extraction, without changing this output contract. Takes no parameters: identity is derived from the request session, not an actor argument.",
7
+
"description": "Identity primitive (PM-9). Returns either a logged-out marker or the authenticated viewer's full identity/profile for client session seeding. Takes no parameters: identity is derived from the request session, not an actor argument.",
8
8
"output": {
9
9
"encoding": "application/json",
10
10
"schema": {
11
-
"type": "object",
12
-
"required": [
13
-
"authenticated"
14
-
],
15
-
"properties": {
16
-
"authenticated": {
17
-
"type": "boolean",
18
-
"description": "Always present. When false the response carries only this field (no identity/profile); when true, did/handle/profile are populated."
19
-
},
20
-
"did": {
21
-
"type": "string",
22
-
"format": "did"
23
-
},
24
-
"handle": {
25
-
"type": "string"
26
-
},
27
-
"profile": {
28
-
"type": "ref",
29
-
"ref": "space.polymodel.actor.defs#profileViewUnion"
30
-
}
31
-
}
11
+
"type": "ref",
12
+
"ref": "space.polymodel.actor.getSession#sessionView"
32
13
}
33
14
}
15
+
},
16
+
"sessionAuthenticated": {
17
+
"type": "object",
18
+
"description": "Authenticated viewer identity for client session seeding. If authenticated is true, did, handle, and profile are all present.",
19
+
"required": [
20
+
"authenticated",
21
+
"did",
22
+
"handle",
23
+
"profile"
24
+
],
25
+
"properties": {
26
+
"authenticated": {
27
+
"type": "boolean",
28
+
"const": true
29
+
},
30
+
"did": {
31
+
"type": "string",
32
+
"format": "did"
33
+
},
34
+
"handle": {
35
+
"type": "string",
36
+
"format": "handle"
37
+
},
38
+
"profile": {
39
+
"type": "ref",
40
+
"ref": "space.polymodel.actor.defs#profileView"
41
+
}
42
+
}
43
+
},
44
+
"sessionUnauthenticated": {
45
+
"type": "object",
46
+
"description": "Logged-out session marker. No identity fields are present when authenticated is false.",
47
+
"required": [
48
+
"authenticated"
49
+
],
50
+
"properties": {
51
+
"authenticated": {
52
+
"type": "boolean",
53
+
"const": false
54
+
}
55
+
}
56
+
},
57
+
"sessionView": {
58
+
"type": "union",
59
+
"refs": [
60
+
"space.polymodel.actor.getSession#sessionUnauthenticated",
61
+
"space.polymodel.actor.getSession#sessionAuthenticated"
62
+
],
63
+
"closed": true
34
64
}
35
65
}
36
66
}
+553
-10
crates/polymodel-api/src/space_polymodel/actor/get_session.rs
+553
-10
crates/polymodel-api/src/space_polymodel/actor/get_session.rs
···
10
10
11
11
#[allow(unused_imports)]
12
12
use core::marker::PhantomData;
13
-
use jacquard_common::{CowStr, BosStr, DefaultStr, FromStaticStr};
13
+
use jacquard_common::{BosStr, DefaultStr, FromStaticStr};
14
+
15
+
#[allow(unused_imports)]
16
+
use jacquard_common::deps::codegen::unicode_segmentation::UnicodeSegmentation;
14
17
use jacquard_common::deps::smol_str::SmolStr;
15
-
use jacquard_common::types::string::Did;
18
+
use jacquard_common::types::string::{Did, Handle};
16
19
use jacquard_common::types::value::Data;
17
20
use jacquard_derive::IntoStatic;
21
+
use jacquard_lexicon::lexicon::LexiconDoc;
22
+
use jacquard_lexicon::schema::LexiconSchema;
23
+
24
+
#[allow(unused_imports)]
25
+
use jacquard_lexicon::validation::{ConstraintError, ValidationPath};
18
26
use serde::{Serialize, Deserialize};
19
-
use crate::space_polymodel::actor::ProfileViewUnion;
27
+
use crate::space_polymodel::actor::ProfileView;
28
+
use crate::space_polymodel::actor::get_session;
20
29
21
30
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
22
31
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
23
32
pub struct GetSessionOutput<S: BosStr = DefaultStr> {
24
-
///Always present. When false the response carries only this field (no identity/profile); when true, did/handle/profile are populated.
33
+
#[serde(flatten)]
34
+
pub value: get_session::SessionView<S>,
35
+
#[serde(flatten, default, skip_serializing_if = "Option::is_none")]
36
+
pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
37
+
}
38
+
39
+
/// Authenticated viewer identity for client session seeding. If authenticated is true, did, handle, and profile are all present.
40
+
41
+
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
42
+
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
43
+
pub struct SessionAuthenticated<S: BosStr = DefaultStr> {
44
+
pub authenticated: bool,
45
+
pub did: Did<S>,
46
+
pub handle: Handle<S>,
47
+
pub profile: ProfileView<S>,
48
+
#[serde(flatten, default, skip_serializing_if = "Option::is_none")]
49
+
pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
50
+
}
51
+
52
+
/// Logged-out session marker. No identity fields are present when authenticated is false.
53
+
54
+
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
55
+
#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
56
+
pub struct SessionUnauthenticated<S: BosStr = DefaultStr> {
25
57
pub authenticated: bool,
26
-
#[serde(skip_serializing_if = "Option::is_none")]
27
-
pub did: Option<Did<S>>,
28
-
#[serde(skip_serializing_if = "Option::is_none")]
29
-
pub handle: Option<S>,
30
-
#[serde(skip_serializing_if = "Option::is_none")]
31
-
pub profile: Option<ProfileViewUnion<S>>,
32
58
#[serde(flatten, default, skip_serializing_if = "Option::is_none")]
33
59
pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,
60
+
}
61
+
62
+
63
+
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
64
+
#[serde(tag = "$type", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
65
+
pub enum SessionView<S: BosStr = DefaultStr> {
66
+
#[serde(rename = "space.polymodel.actor.getSession#sessionUnauthenticated")]
67
+
SessionUnauthenticated(Box<get_session::SessionUnauthenticated<S>>),
68
+
#[serde(rename = "space.polymodel.actor.getSession#sessionAuthenticated")]
69
+
SessionAuthenticated(Box<get_session::SessionAuthenticated<S>>),
34
70
}
35
71
36
72
/** Request marker for the `space.polymodel.actor.getSession` query.
···
65
101
const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
66
102
type Request<S: BosStr> = GetSession;
67
103
type Response = GetSessionResponse;
104
+
}
105
+
106
+
impl<S: BosStr> LexiconSchema for SessionAuthenticated<S> {
107
+
fn nsid() -> &'static str {
108
+
"space.polymodel.actor.getSession"
109
+
}
110
+
fn def_name() -> &'static str {
111
+
"sessionAuthenticated"
112
+
}
113
+
fn lexicon_doc() -> LexiconDoc<'static> {
114
+
lexicon_doc_space_polymodel_actor_getSession()
115
+
}
116
+
fn validate(&self) -> Result<(), ConstraintError> {
117
+
Ok(())
118
+
}
119
+
}
120
+
121
+
impl<S: BosStr> LexiconSchema for SessionUnauthenticated<S> {
122
+
fn nsid() -> &'static str {
123
+
"space.polymodel.actor.getSession"
124
+
}
125
+
fn def_name() -> &'static str {
126
+
"sessionUnauthenticated"
127
+
}
128
+
fn lexicon_doc() -> LexiconDoc<'static> {
129
+
lexicon_doc_space_polymodel_actor_getSession()
130
+
}
131
+
fn validate(&self) -> Result<(), ConstraintError> {
132
+
Ok(())
133
+
}
134
+
}
135
+
136
+
pub mod session_authenticated_state {
137
+
138
+
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
139
+
#[allow(unused)]
140
+
use ::core::marker::PhantomData;
141
+
mod sealed {
142
+
pub trait Sealed {}
143
+
}
144
+
/// State trait tracking which required fields have been set
145
+
pub trait State: sealed::Sealed {
146
+
type Authenticated;
147
+
type Did;
148
+
type Handle;
149
+
type Profile;
150
+
}
151
+
/// Empty state - all required fields are unset
152
+
pub struct Empty(());
153
+
impl sealed::Sealed for Empty {}
154
+
impl State for Empty {
155
+
type Authenticated = Unset;
156
+
type Did = Unset;
157
+
type Handle = Unset;
158
+
type Profile = Unset;
159
+
}
160
+
///State transition - sets the `authenticated` field to Set
161
+
pub struct SetAuthenticated<St: State = Empty>(PhantomData<fn() -> St>);
162
+
impl<St: State> sealed::Sealed for SetAuthenticated<St> {}
163
+
impl<St: State> State for SetAuthenticated<St> {
164
+
type Authenticated = Set<members::authenticated>;
165
+
type Did = St::Did;
166
+
type Handle = St::Handle;
167
+
type Profile = St::Profile;
168
+
}
169
+
///State transition - sets the `did` field to Set
170
+
pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
171
+
impl<St: State> sealed::Sealed for SetDid<St> {}
172
+
impl<St: State> State for SetDid<St> {
173
+
type Authenticated = St::Authenticated;
174
+
type Did = Set<members::did>;
175
+
type Handle = St::Handle;
176
+
type Profile = St::Profile;
177
+
}
178
+
///State transition - sets the `handle` field to Set
179
+
pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
180
+
impl<St: State> sealed::Sealed for SetHandle<St> {}
181
+
impl<St: State> State for SetHandle<St> {
182
+
type Authenticated = St::Authenticated;
183
+
type Did = St::Did;
184
+
type Handle = Set<members::handle>;
185
+
type Profile = St::Profile;
186
+
}
187
+
///State transition - sets the `profile` field to Set
188
+
pub struct SetProfile<St: State = Empty>(PhantomData<fn() -> St>);
189
+
impl<St: State> sealed::Sealed for SetProfile<St> {}
190
+
impl<St: State> State for SetProfile<St> {
191
+
type Authenticated = St::Authenticated;
192
+
type Did = St::Did;
193
+
type Handle = St::Handle;
194
+
type Profile = Set<members::profile>;
195
+
}
196
+
/// Marker types for field names
197
+
#[allow(non_camel_case_types)]
198
+
pub mod members {
199
+
///Marker type for the `authenticated` field
200
+
pub struct authenticated(());
201
+
///Marker type for the `did` field
202
+
pub struct did(());
203
+
///Marker type for the `handle` field
204
+
pub struct handle(());
205
+
///Marker type for the `profile` field
206
+
pub struct profile(());
207
+
}
208
+
}
209
+
210
+
/// Builder for constructing an instance of this type.
211
+
pub struct SessionAuthenticatedBuilder<
212
+
St: session_authenticated_state::State,
213
+
S: BosStr = DefaultStr,
214
+
> {
215
+
_state: PhantomData<fn() -> St>,
216
+
_fields: (Option<bool>, Option<Did<S>>, Option<Handle<S>>, Option<ProfileView<S>>),
217
+
_type: PhantomData<fn() -> S>,
218
+
}
219
+
220
+
impl SessionAuthenticated<DefaultStr> {
221
+
/// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed
222
+
pub fn new() -> SessionAuthenticatedBuilder<
223
+
session_authenticated_state::Empty,
224
+
DefaultStr,
225
+
> {
226
+
SessionAuthenticatedBuilder::new()
227
+
}
228
+
}
229
+
230
+
impl<S: BosStr> SessionAuthenticated<S> {
231
+
/// Create a new builder for this type
232
+
pub fn builder() -> SessionAuthenticatedBuilder<
233
+
session_authenticated_state::Empty,
234
+
S,
235
+
> {
236
+
SessionAuthenticatedBuilder::builder()
237
+
}
238
+
}
239
+
240
+
impl SessionAuthenticatedBuilder<session_authenticated_state::Empty, DefaultStr> {
241
+
/// Create a new builder with all fields unset, using the default string type, if needed
242
+
pub fn new() -> Self {
243
+
SessionAuthenticatedBuilder {
244
+
_state: PhantomData,
245
+
_fields: (None, None, None, None),
246
+
_type: PhantomData,
247
+
}
248
+
}
249
+
}
250
+
251
+
impl<S: BosStr> SessionAuthenticatedBuilder<session_authenticated_state::Empty, S> {
252
+
/// Create a new builder with all fields unset
253
+
pub fn builder() -> Self {
254
+
SessionAuthenticatedBuilder {
255
+
_state: PhantomData,
256
+
_fields: (None, None, None, None),
257
+
_type: PhantomData,
258
+
}
259
+
}
260
+
}
261
+
262
+
impl<St, S: BosStr> SessionAuthenticatedBuilder<St, S>
263
+
where
264
+
St: session_authenticated_state::State,
265
+
St::Authenticated: session_authenticated_state::IsUnset,
266
+
{
267
+
/// Set the `authenticated` field (required)
268
+
pub fn authenticated(
269
+
mut self,
270
+
value: impl Into<bool>,
271
+
) -> SessionAuthenticatedBuilder<
272
+
session_authenticated_state::SetAuthenticated<St>,
273
+
S,
274
+
> {
275
+
self._fields.0 = Option::Some(value.into());
276
+
SessionAuthenticatedBuilder {
277
+
_state: PhantomData,
278
+
_fields: self._fields,
279
+
_type: PhantomData,
280
+
}
281
+
}
282
+
}
283
+
284
+
impl<St, S: BosStr> SessionAuthenticatedBuilder<St, S>
285
+
where
286
+
St: session_authenticated_state::State,
287
+
St::Did: session_authenticated_state::IsUnset,
288
+
{
289
+
/// Set the `did` field (required)
290
+
pub fn did(
291
+
mut self,
292
+
value: impl Into<Did<S>>,
293
+
) -> SessionAuthenticatedBuilder<session_authenticated_state::SetDid<St>, S> {
294
+
self._fields.1 = Option::Some(value.into());
295
+
SessionAuthenticatedBuilder {
296
+
_state: PhantomData,
297
+
_fields: self._fields,
298
+
_type: PhantomData,
299
+
}
300
+
}
301
+
}
302
+
303
+
impl<St, S: BosStr> SessionAuthenticatedBuilder<St, S>
304
+
where
305
+
St: session_authenticated_state::State,
306
+
St::Handle: session_authenticated_state::IsUnset,
307
+
{
308
+
/// Set the `handle` field (required)
309
+
pub fn handle(
310
+
mut self,
311
+
value: impl Into<Handle<S>>,
312
+
) -> SessionAuthenticatedBuilder<session_authenticated_state::SetHandle<St>, S> {
313
+
self._fields.2 = Option::Some(value.into());
314
+
SessionAuthenticatedBuilder {
315
+
_state: PhantomData,
316
+
_fields: self._fields,
317
+
_type: PhantomData,
318
+
}
319
+
}
320
+
}
321
+
322
+
impl<St, S: BosStr> SessionAuthenticatedBuilder<St, S>
323
+
where
324
+
St: session_authenticated_state::State,
325
+
St::Profile: session_authenticated_state::IsUnset,
326
+
{
327
+
/// Set the `profile` field (required)
328
+
pub fn profile(
329
+
mut self,
330
+
value: impl Into<ProfileView<S>>,
331
+
) -> SessionAuthenticatedBuilder<session_authenticated_state::SetProfile<St>, S> {
332
+
self._fields.3 = Option::Some(value.into());
333
+
SessionAuthenticatedBuilder {
334
+
_state: PhantomData,
335
+
_fields: self._fields,
336
+
_type: PhantomData,
337
+
}
338
+
}
339
+
}
340
+
341
+
impl<St, S: BosStr> SessionAuthenticatedBuilder<St, S>
342
+
where
343
+
St: session_authenticated_state::State,
344
+
St::Authenticated: session_authenticated_state::IsSet,
345
+
St::Did: session_authenticated_state::IsSet,
346
+
St::Handle: session_authenticated_state::IsSet,
347
+
St::Profile: session_authenticated_state::IsSet,
348
+
{
349
+
/// Build the final struct.
350
+
pub fn build(self) -> SessionAuthenticated<S> {
351
+
SessionAuthenticated {
352
+
authenticated: self._fields.0.unwrap(),
353
+
did: self._fields.1.unwrap(),
354
+
handle: self._fields.2.unwrap(),
355
+
profile: self._fields.3.unwrap(),
356
+
extra_data: Default::default(),
357
+
}
358
+
}
359
+
/// Build the final struct with custom extra_data.
360
+
pub fn build_with_data(
361
+
self,
362
+
extra_data: BTreeMap<SmolStr, Data<S>>,
363
+
) -> SessionAuthenticated<S> {
364
+
SessionAuthenticated {
365
+
authenticated: self._fields.0.unwrap(),
366
+
did: self._fields.1.unwrap(),
367
+
handle: self._fields.2.unwrap(),
368
+
profile: self._fields.3.unwrap(),
369
+
extra_data: Some(extra_data),
370
+
}
371
+
}
372
+
}
373
+
374
+
fn lexicon_doc_space_polymodel_actor_getSession() -> LexiconDoc<'static> {
375
+
#[allow(unused_imports)]
376
+
use jacquard_common::{CowStr, deps::smol_str::SmolStr, types::blob::MimeType};
377
+
use jacquard_lexicon::lexicon::*;
378
+
use alloc::collections::BTreeMap;
379
+
LexiconDoc {
380
+
lexicon: Lexicon::Lexicon1,
381
+
id: CowStr::new_static("space.polymodel.actor.getSession"),
382
+
defs: {
383
+
let mut map = BTreeMap::new();
384
+
map.insert(
385
+
SmolStr::new_static("main"),
386
+
LexUserType::XrpcQuery(LexXrpcQuery {
387
+
parameters: None,
388
+
..Default::default()
389
+
}),
390
+
);
391
+
map.insert(
392
+
SmolStr::new_static("sessionAuthenticated"),
393
+
LexUserType::Object(LexObject {
394
+
description: Some(
395
+
CowStr::new_static(
396
+
"Authenticated viewer identity for client session seeding. If authenticated is true, did, handle, and profile are all present.",
397
+
),
398
+
),
399
+
required: Some(
400
+
vec![
401
+
SmolStr::new_static("authenticated"),
402
+
SmolStr::new_static("did"), SmolStr::new_static("handle"),
403
+
SmolStr::new_static("profile")
404
+
],
405
+
),
406
+
properties: {
407
+
#[allow(unused_mut)]
408
+
let mut map = BTreeMap::new();
409
+
map.insert(
410
+
SmolStr::new_static("authenticated"),
411
+
LexObjectProperty::Boolean(LexBoolean {
412
+
..Default::default()
413
+
}),
414
+
);
415
+
map.insert(
416
+
SmolStr::new_static("did"),
417
+
LexObjectProperty::String(LexString {
418
+
format: Some(LexStringFormat::Did),
419
+
..Default::default()
420
+
}),
421
+
);
422
+
map.insert(
423
+
SmolStr::new_static("handle"),
424
+
LexObjectProperty::String(LexString {
425
+
format: Some(LexStringFormat::Handle),
426
+
..Default::default()
427
+
}),
428
+
);
429
+
map.insert(
430
+
SmolStr::new_static("profile"),
431
+
LexObjectProperty::Ref(LexRef {
432
+
r#ref: CowStr::new_static(
433
+
"space.polymodel.actor.defs#profileView",
434
+
),
435
+
..Default::default()
436
+
}),
437
+
);
438
+
map
439
+
},
440
+
..Default::default()
441
+
}),
442
+
);
443
+
map.insert(
444
+
SmolStr::new_static("sessionUnauthenticated"),
445
+
LexUserType::Object(LexObject {
446
+
description: Some(
447
+
CowStr::new_static(
448
+
"Logged-out session marker. No identity fields are present when authenticated is false.",
449
+
),
450
+
),
451
+
required: Some(vec![SmolStr::new_static("authenticated")]),
452
+
properties: {
453
+
#[allow(unused_mut)]
454
+
let mut map = BTreeMap::new();
455
+
map.insert(
456
+
SmolStr::new_static("authenticated"),
457
+
LexObjectProperty::Boolean(LexBoolean {
458
+
..Default::default()
459
+
}),
460
+
);
461
+
map
462
+
},
463
+
..Default::default()
464
+
}),
465
+
);
466
+
map.insert(
467
+
SmolStr::new_static("sessionView"),
468
+
LexUserType::Union(LexRefUnion {
469
+
refs: vec![
470
+
CowStr::new_static("space.polymodel.actor.getSession#sessionUnauthenticated"),
471
+
CowStr::new_static("space.polymodel.actor.getSession#sessionAuthenticated")
472
+
],
473
+
closed: Some(true),
474
+
..Default::default()
475
+
}),
476
+
);
477
+
map
478
+
},
479
+
..Default::default()
480
+
}
481
+
}
482
+
483
+
pub mod session_unauthenticated_state {
484
+
485
+
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
486
+
#[allow(unused)]
487
+
use ::core::marker::PhantomData;
488
+
mod sealed {
489
+
pub trait Sealed {}
490
+
}
491
+
/// State trait tracking which required fields have been set
492
+
pub trait State: sealed::Sealed {
493
+
type Authenticated;
494
+
}
495
+
/// Empty state - all required fields are unset
496
+
pub struct Empty(());
497
+
impl sealed::Sealed for Empty {}
498
+
impl State for Empty {
499
+
type Authenticated = Unset;
500
+
}
501
+
///State transition - sets the `authenticated` field to Set
502
+
pub struct SetAuthenticated<St: State = Empty>(PhantomData<fn() -> St>);
503
+
impl<St: State> sealed::Sealed for SetAuthenticated<St> {}
504
+
impl<St: State> State for SetAuthenticated<St> {
505
+
type Authenticated = Set<members::authenticated>;
506
+
}
507
+
/// Marker types for field names
508
+
#[allow(non_camel_case_types)]
509
+
pub mod members {
510
+
///Marker type for the `authenticated` field
511
+
pub struct authenticated(());
512
+
}
513
+
}
514
+
515
+
/// Builder for constructing an instance of this type.
516
+
pub struct SessionUnauthenticatedBuilder<
517
+
St: session_unauthenticated_state::State,
518
+
S: BosStr = DefaultStr,
519
+
> {
520
+
_state: PhantomData<fn() -> St>,
521
+
_fields: (Option<bool>,),
522
+
_type: PhantomData<fn() -> S>,
523
+
}
524
+
525
+
impl SessionUnauthenticated<DefaultStr> {
526
+
/// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed
527
+
pub fn new() -> SessionUnauthenticatedBuilder<
528
+
session_unauthenticated_state::Empty,
529
+
DefaultStr,
530
+
> {
531
+
SessionUnauthenticatedBuilder::new()
532
+
}
533
+
}
534
+
535
+
impl<S: BosStr> SessionUnauthenticated<S> {
536
+
/// Create a new builder for this type
537
+
pub fn builder() -> SessionUnauthenticatedBuilder<
538
+
session_unauthenticated_state::Empty,
539
+
S,
540
+
> {
541
+
SessionUnauthenticatedBuilder::builder()
542
+
}
543
+
}
544
+
545
+
impl SessionUnauthenticatedBuilder<session_unauthenticated_state::Empty, DefaultStr> {
546
+
/// Create a new builder with all fields unset, using the default string type, if needed
547
+
pub fn new() -> Self {
548
+
SessionUnauthenticatedBuilder {
549
+
_state: PhantomData,
550
+
_fields: (None,),
551
+
_type: PhantomData,
552
+
}
553
+
}
554
+
}
555
+
556
+
impl<S: BosStr> SessionUnauthenticatedBuilder<session_unauthenticated_state::Empty, S> {
557
+
/// Create a new builder with all fields unset
558
+
pub fn builder() -> Self {
559
+
SessionUnauthenticatedBuilder {
560
+
_state: PhantomData,
561
+
_fields: (None,),
562
+
_type: PhantomData,
563
+
}
564
+
}
565
+
}
566
+
567
+
impl<St, S: BosStr> SessionUnauthenticatedBuilder<St, S>
568
+
where
569
+
St: session_unauthenticated_state::State,
570
+
St::Authenticated: session_unauthenticated_state::IsUnset,
571
+
{
572
+
/// Set the `authenticated` field (required)
573
+
pub fn authenticated(
574
+
mut self,
575
+
value: impl Into<bool>,
576
+
) -> SessionUnauthenticatedBuilder<
577
+
session_unauthenticated_state::SetAuthenticated<St>,
578
+
S,
579
+
> {
580
+
self._fields.0 = Option::Some(value.into());
581
+
SessionUnauthenticatedBuilder {
582
+
_state: PhantomData,
583
+
_fields: self._fields,
584
+
_type: PhantomData,
585
+
}
586
+
}
587
+
}
588
+
589
+
impl<St, S: BosStr> SessionUnauthenticatedBuilder<St, S>
590
+
where
591
+
St: session_unauthenticated_state::State,
592
+
St::Authenticated: session_unauthenticated_state::IsSet,
593
+
{
594
+
/// Build the final struct.
595
+
pub fn build(self) -> SessionUnauthenticated<S> {
596
+
SessionUnauthenticated {
597
+
authenticated: self._fields.0.unwrap(),
598
+
extra_data: Default::default(),
599
+
}
600
+
}
601
+
/// Build the final struct with custom extra_data.
602
+
pub fn build_with_data(
603
+
self,
604
+
extra_data: BTreeMap<SmolStr, Data<S>>,
605
+
) -> SessionUnauthenticated<S> {
606
+
SessionUnauthenticated {
607
+
authenticated: self._fields.0.unwrap(),
608
+
extra_data: Some(extra_data),
609
+
}
610
+
}
68
611
}
+7
-7
justfile
+7
-7
justfile
···
2
2
3
3
set dotenv-load := false
4
4
5
-
# Format and apply safe automatic fixes. This is the default pre-review cleanup command.
5
+
# Format Rust sources. Run clippy/check separately; clippy --fix can corrupt RSX.
6
6
fix:
7
7
cargo fmt --all
8
-
cargo clippy --workspace --all-targets --fix --allow-dirty --allow-staged --allow-no-vcs -- -D warnings
9
-
cargo clippy -p polymodel --all-targets --features server --fix --allow-dirty --allow-staged --allow-no-vcs -- -D warnings
10
-
cargo clippy -p polymodel --target wasm32-unknown-unknown --features web --fix --allow-dirty --allow-staged --allow-no-vcs -- -D warnings
11
-
8
+
# Run clippy without --fix; automatic clippy rewrites can corrupt Dioxus RSX.
9
+
lint:
10
+
cargo clippy --workspace --all-targets -- -D warnings
11
+
cargo clippy -p polymodel --all-targets --features server -- -D warnings
12
+
cargo clippy -p polymodel --target wasm32-unknown-unknown --features web -- -D warnings
12
13
# Compile checks across the whole workspace plus the app's server/wasm targets.
13
-
# Note: the server check uses compile-time `query!` macros that validate against a
14
14
# migrated SQLite database. Run `just migrate` first (or run `just sqlx-prepare`)
15
15
# so the macros can resolve.
16
16
check:
···
39
39
cargo nextest run -p polymodel --features server
40
40
41
41
# Run all local validation expected before review.
42
-
test-all: fix check test test-server
42
+
test-all: fix check lint test test-server
43
43
# Run browser end-to-end tests.
44
44
e2e:
45
45
cd e2e && npm test
+27
-11
lexicons/actor/getSession.json
+27
-11
lexicons/actor/getSession.json
···
2
2
"lexicon": 1,
3
3
"id": "space.polymodel.actor.getSession",
4
4
"defs": {
5
+
"sessionUnauthenticated": {
6
+
"type": "object",
7
+
"description": "Logged-out session marker. No identity fields are present when authenticated is false.",
8
+
"required": ["authenticated"],
9
+
"properties": { "authenticated": { "type": "boolean", "const": false } }
10
+
},
11
+
"sessionAuthenticated": {
12
+
"type": "object",
13
+
"description": "Authenticated viewer identity for client session seeding. If authenticated is true, did, handle, and profile are all present.",
14
+
"required": ["authenticated", "did", "handle", "profile"],
15
+
"properties": {
16
+
"authenticated": { "type": "boolean", "const": true },
17
+
"did": { "type": "string", "format": "did" },
18
+
"handle": { "type": "string", "format": "handle" },
19
+
"profile": { "type": "ref", "ref": "space.polymodel.actor.defs#profileView" }
20
+
}
21
+
},
22
+
"sessionView": {
23
+
"type": "union",
24
+
"refs": [
25
+
"space.polymodel.actor.getSession#sessionUnauthenticated",
26
+
"space.polymodel.actor.getSession#sessionAuthenticated"
27
+
],
28
+
"closed": true
29
+
},
5
30
"main": {
6
31
"type": "query",
7
-
"description": "Identity primitive (PM-9). Returns the authenticated viewer's identity plus profile for SSR-first session seeding, or an unauthenticated marker. The profile field reuses the getProfile union shape so the client renders identity + profile from a single first-paint value. PM-26 returns only the unauthenticated marker ({authenticated: false}); the authenticated fields (did/handle/profile) are populated once PM-27 wires OAuth session extraction, without changing this output contract. Takes no parameters: identity is derived from the request session, not an actor argument.",
32
+
"description": "Identity primitive (PM-9). Returns either a logged-out marker or the authenticated viewer's full identity/profile for client session seeding. Takes no parameters: identity is derived from the request session, not an actor argument.",
8
33
"output": {
9
34
"encoding": "application/json",
10
-
"schema": {
11
-
"type": "object",
12
-
"required": ["authenticated"],
13
-
"properties": {
14
-
"authenticated": { "type": "boolean", "description": "Always present. When false the response carries only this field (no identity/profile); when true, did/handle/profile are populated." },
15
-
"did": { "type": "string", "format": "did" },
16
-
"handle": { "type": "string" },
17
-
"profile": { "type": "ref", "ref": "space.polymodel.actor.defs#profileViewUnion" }
18
-
}
19
-
}
35
+
"schema": { "type": "ref", "ref": "space.polymodel.actor.getSession#sessionView" }
20
36
}
21
37
}
22
38
}
+8
-8
src/appview/actor.rs
+8
-8
src/appview/actor.rs
···
15
15
use polymodel_api::space_polymodel::actor::{
16
16
ProfileViewUnion,
17
17
get_profile::{GetProfileOutput, GetProfileRequest},
18
-
get_session::{GetSessionOutput, GetSessionRequest},
18
+
get_session::{GetSessionOutput, GetSessionRequest, SessionUnauthenticated, SessionView},
19
19
};
20
20
21
21
use super::error::{AppResult, internal};
···
82
82
pub(super) async fn get_session(
83
83
State(_state): State<Arc<AppState>>,
84
84
) -> AppResult<XrpcResponse<GetSessionRequest>> {
85
-
// PM-26 ships the read seam + output contract only. Authenticated state
86
-
// (did/handle/profile) is populated once PM-27 wires OAuth session extraction
87
-
// — the output shape does not change, only which fields are filled.
85
+
// PM-26 ships the unauthenticated arm only. PM-27 will return
86
+
// `SessionAuthenticated` once OAuth session extraction and profile writes are wired.
87
+
88
88
Ok(XrpcResponse(GetSessionOutput {
89
-
authenticated: false,
90
-
did: None,
91
-
handle: None,
92
-
profile: None,
89
+
value: SessionView::SessionUnauthenticated(Box::new(SessionUnauthenticated {
90
+
authenticated: false,
91
+
extra_data: None,
92
+
})),
93
93
extra_data: None,
94
94
}))
95
95
}
+150
src/auth.rs
+150
src/auth.rs
···
1
+
#[cfg(test)]
2
+
use crate::session::SessionIdentity;
3
+
4
+
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
5
+
pub const AUTH_BROADCAST_CHANNEL: &str = "polymodel-auth";
6
+
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
7
+
pub const SIGN_OUT_MESSAGE: &str = "sign-out";
8
+
9
+
#[derive(Clone, Debug, PartialEq, Eq)]
10
+
pub struct Toast {
11
+
pub id: u64,
12
+
pub message: String,
13
+
}
14
+
15
+
#[derive(Clone, Debug, Default, PartialEq, Eq)]
16
+
pub struct ToastState {
17
+
next_id: u64,
18
+
items: Vec<Toast>,
19
+
}
20
+
21
+
impl ToastState {
22
+
pub fn push(&mut self, message: impl Into<String>) -> u64 {
23
+
let id = self.next_id;
24
+
self.next_id += 1;
25
+
self.items.push(Toast {
26
+
id,
27
+
message: message.into(),
28
+
});
29
+
id
30
+
}
31
+
32
+
pub fn dismiss(&mut self, id: u64) {
33
+
self.items.retain(|toast| toast.id != id);
34
+
}
35
+
36
+
pub fn items(&self) -> &[Toast] {
37
+
&self.items
38
+
}
39
+
}
40
+
41
+
#[cfg(test)]
42
+
pub fn handle_remote_sign_out(session: &mut SessionIdentity, toasts: &mut ToastState) {
43
+
*session = SessionIdentity::Anonymous;
44
+
toasts.push("Signed out in another tab.");
45
+
}
46
+
47
+
pub fn login_url(identifier: &str) -> String {
48
+
let identifier = identifier.trim();
49
+
if identifier.is_empty() {
50
+
"/oauth/login".to_string()
51
+
} else {
52
+
format!(
53
+
"/oauth/start?identifier={}",
54
+
encode_query_component(identifier)
55
+
)
56
+
}
57
+
}
58
+
59
+
pub fn logout_url() -> &'static str {
60
+
"/oauth/logout"
61
+
}
62
+
63
+
fn encode_query_component(value: &str) -> String {
64
+
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
65
+
{
66
+
js_sys::encode_uri_component(value)
67
+
.as_string()
68
+
.unwrap_or_default()
69
+
}
70
+
71
+
#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
72
+
{
73
+
value
74
+
.bytes()
75
+
.flat_map(|byte| match byte {
76
+
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'.' | b'_' | b'~' => {
77
+
vec![byte as char]
78
+
}
79
+
_ => format!("%{byte:02X}").chars().collect(),
80
+
})
81
+
.collect()
82
+
}
83
+
}
84
+
85
+
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
86
+
pub fn navigate_to(url: &str) {
87
+
if let Some(window) = web_sys::window() {
88
+
let _ = window.location().set_href(url);
89
+
}
90
+
}
91
+
92
+
#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
93
+
pub fn navigate_to(_url: &str) {}
94
+
95
+
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
96
+
pub fn broadcast_sign_out() {
97
+
if let Ok(channel) = web_sys::BroadcastChannel::new(AUTH_BROADCAST_CHANNEL) {
98
+
let _ = channel.post_message(&wasm_bindgen::JsValue::from_str(SIGN_OUT_MESSAGE));
99
+
}
100
+
}
101
+
102
+
#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
103
+
pub fn broadcast_sign_out() {}
104
+
105
+
#[cfg(test)]
106
+
mod tests {
107
+
use super::*;
108
+
use jacquard::types::string::Handle;
109
+
use jacquard_common::types::did::Did;
110
+
111
+
#[test]
112
+
fn login_url_uses_oauth_login_when_identifier_empty() {
113
+
assert_eq!(login_url(" "), "/oauth/login");
114
+
}
115
+
116
+
#[test]
117
+
fn login_url_uses_oauth_start_with_encoded_identifier() {
118
+
assert_eq!(
119
+
login_url("alice model.example"),
120
+
"/oauth/start?identifier=alice%20model.example"
121
+
);
122
+
}
123
+
124
+
#[test]
125
+
fn remote_sign_out_clears_session_and_adds_toast() {
126
+
let mut session = SessionIdentity::Authenticated(crate::session::AuthenticatedIdentity {
127
+
did: Did::new_owned("did:plc:alice").unwrap(),
128
+
handle: Handle::new_owned("alice.test").unwrap(),
129
+
display_name: None,
130
+
});
131
+
let mut toasts = ToastState::default();
132
+
133
+
handle_remote_sign_out(&mut session, &mut toasts);
134
+
135
+
assert_eq!(session, SessionIdentity::Anonymous);
136
+
assert_eq!(toasts.items()[0].message, "Signed out in another tab.");
137
+
}
138
+
139
+
#[test]
140
+
fn toast_state_dismisses_by_id() {
141
+
let mut toasts = ToastState::default();
142
+
let first = toasts.push("one");
143
+
let _second = toasts.push("two");
144
+
145
+
toasts.dismiss(first);
146
+
147
+
assert_eq!(toasts.items().len(), 1);
148
+
assert_eq!(toasts.items()[0].message, "two");
149
+
}
150
+
}
+305
src/client.rs
+305
src/client.rs
···
1
+
//! Same-origin Polymodel appview client for browser UI calls.
2
+
//!
3
+
//! Polymodel deliberately uses this thin client rather than Jacquard's
4
+
//! credential/session `BasicClient` path: appview reads should target this
5
+
//! server's `/xrpc/space.polymodel.*` routes and rely on browser-managed
6
+
//! cookies once PM-27 wires OAuth sessions. Callers send generated payload
7
+
//! request values, for example `client.send(GetSession).await?.into_output()`.
8
+
//! Identity resolution is delegated to Jacquard's resolver over the same
9
+
//! injected HTTP transport; this keeps Polymodel's appview client thin without
10
+
//! adopting a credential/session agent for read calls.
11
+
12
+
use std::fmt;
13
+
use std::sync::{Arc, RwLock};
14
+
15
+
use jacquard::identity::JacquardResolver;
16
+
use jacquard::identity::resolver::{
17
+
DidDocResponse, IdentityError, IdentityResolver, ResolverOptions,
18
+
};
19
+
use jacquard_common::BosStr;
20
+
use jacquard_common::http_client::HttpClient;
21
+
use jacquard_common::types::did::Did;
22
+
use jacquard_common::types::string::Handle;
23
+
use jacquard_common::xrpc::{CallOptions, XrpcClient, XrpcExt, XrpcRequest, XrpcResponse};
24
+
use jacquard_common::{deps::fluent_uri::Uri, error::XrpcResult};
25
+
26
+
const DEFAULT_NATIVE_BASE_URI: &str = "http://127.0.0.1:8080";
27
+
28
+
#[derive(Clone)]
29
+
pub struct PolymodelClient {
30
+
http: reqwest::Client,
31
+
resolver: JacquardResolver<reqwest::Client>,
32
+
base_uri: Arc<RwLock<Uri<String>>>,
33
+
opts: Arc<RwLock<CallOptions>>,
34
+
}
35
+
36
+
impl fmt::Debug for PolymodelClient {
37
+
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
38
+
f.debug_struct("PolymodelClient")
39
+
.field("base_uri", &self.current_base_uri().as_str())
40
+
.finish_non_exhaustive()
41
+
}
42
+
}
43
+
44
+
impl PolymodelClient {
45
+
pub fn new() -> Result<Self, ClientError> {
46
+
Self::with_base_uri(default_base_uri()?)
47
+
}
48
+
49
+
pub fn with_base_uri(base_uri: Uri<String>) -> Result<Self, ClientError> {
50
+
Self::with_http_and_base_uri(reqwest::Client::new(), base_uri)
51
+
}
52
+
53
+
pub fn with_http_and_base_uri(
54
+
http: reqwest::Client,
55
+
base_uri: Uri<String>,
56
+
) -> Result<Self, ClientError> {
57
+
let resolver = JacquardResolver::new(http.clone(), ResolverOptions::default());
58
+
Ok(Self {
59
+
http,
60
+
resolver,
61
+
base_uri: Arc::new(RwLock::new(base_uri)),
62
+
opts: Arc::new(RwLock::new(CallOptions::default())),
63
+
})
64
+
}
65
+
66
+
pub fn parse_base_uri(value: &str) -> Result<Uri<String>, ClientError> {
67
+
Uri::parse(value.to_string()).map_err(|_| ClientError::InvalidBaseUri(value.to_string()))
68
+
}
69
+
70
+
pub fn current_base_uri(&self) -> Uri<String> {
71
+
self.base_uri
72
+
.read()
73
+
.expect("Polymodel client base URI lock is not poisoned")
74
+
.clone()
75
+
}
76
+
}
77
+
78
+
impl Default for PolymodelClient {
79
+
fn default() -> Self {
80
+
Self::new().expect("default Polymodel appview base URI is valid")
81
+
}
82
+
}
83
+
84
+
impl HttpClient for PolymodelClient {
85
+
type Error = reqwest::Error;
86
+
87
+
async fn send_http(
88
+
&self,
89
+
request: http::Request<Vec<u8>>,
90
+
) -> Result<http::Response<Vec<u8>>, Self::Error> {
91
+
self.http.send_http(request).await
92
+
}
93
+
}
94
+
95
+
impl XrpcClient for PolymodelClient {
96
+
async fn base_uri(&self) -> Uri<String> {
97
+
self.current_base_uri()
98
+
}
99
+
100
+
async fn set_base_uri(&self, uri: Uri<String>) {
101
+
*self
102
+
.base_uri
103
+
.write()
104
+
.expect("Polymodel client base URI lock is not poisoned") = uri;
105
+
}
106
+
107
+
async fn opts(&self) -> CallOptions {
108
+
self.opts
109
+
.read()
110
+
.expect("Polymodel client XRPC options lock is not poisoned")
111
+
.clone()
112
+
}
113
+
114
+
async fn set_opts(&self, opts: CallOptions) {
115
+
*self
116
+
.opts
117
+
.write()
118
+
.expect("Polymodel client XRPC options lock is not poisoned") = opts;
119
+
}
120
+
121
+
#[cfg(not(target_arch = "wasm32"))]
122
+
async fn send<R>(&self, request: R) -> XrpcResult<XrpcResponse<R>>
123
+
where
124
+
R: XrpcRequest + Send + Sync + serde::Serialize,
125
+
<R as XrpcRequest>::Response: Send + Sync,
126
+
Self: Sync,
127
+
{
128
+
let base = self.base_uri().await;
129
+
let opts = self.opts().await;
130
+
let base_ref: Uri<&str> = base.borrow();
131
+
self.xrpc(base_ref).with_options(opts).send(&request).await
132
+
}
133
+
134
+
#[cfg(target_arch = "wasm32")]
135
+
async fn send<R>(&self, request: R) -> XrpcResult<XrpcResponse<R>>
136
+
where
137
+
R: XrpcRequest + Send + Sync + serde::Serialize,
138
+
<R as XrpcRequest>::Response: Send + Sync,
139
+
{
140
+
let base = self.base_uri().await;
141
+
let opts = self.opts().await;
142
+
let base_ref: Uri<&str> = base.borrow();
143
+
self.xrpc(base_ref).with_options(opts).send(&request).await
144
+
}
145
+
146
+
#[cfg(not(target_arch = "wasm32"))]
147
+
async fn send_with_opts<R>(&self, request: R, opts: CallOptions) -> XrpcResult<XrpcResponse<R>>
148
+
where
149
+
R: XrpcRequest + Send + Sync + serde::Serialize,
150
+
<R as XrpcRequest>::Response: Send + Sync,
151
+
Self: Sync,
152
+
{
153
+
let base = self.base_uri().await;
154
+
let base_ref: Uri<&str> = base.borrow();
155
+
self.xrpc(base_ref).with_options(opts).send(&request).await
156
+
}
157
+
158
+
#[cfg(target_arch = "wasm32")]
159
+
async fn send_with_opts<R>(&self, request: R, opts: CallOptions) -> XrpcResult<XrpcResponse<R>>
160
+
where
161
+
R: XrpcRequest + Send + Sync + serde::Serialize,
162
+
<R as XrpcRequest>::Response: Send + Sync,
163
+
{
164
+
let base = self.base_uri().await;
165
+
let base_ref: Uri<&str> = base.borrow();
166
+
self.xrpc(base_ref).with_options(opts).send(&request).await
167
+
}
168
+
}
169
+
170
+
impl IdentityResolver for PolymodelClient {
171
+
fn options(&self) -> &ResolverOptions {
172
+
self.resolver.options()
173
+
}
174
+
175
+
#[cfg(not(target_arch = "wasm32"))]
176
+
async fn resolve_handle<S: BosStr + Sync>(
177
+
&self,
178
+
handle: &Handle<S>,
179
+
) -> Result<Did, IdentityError>
180
+
where
181
+
Self: Sync,
182
+
{
183
+
self.resolver.resolve_handle(handle).await
184
+
}
185
+
186
+
#[cfg(target_arch = "wasm32")]
187
+
async fn resolve_handle<S: BosStr + Sync>(
188
+
&self,
189
+
handle: &Handle<S>,
190
+
) -> Result<Did, IdentityError> {
191
+
self.resolver.resolve_handle(handle).await
192
+
}
193
+
194
+
#[cfg(not(target_arch = "wasm32"))]
195
+
async fn resolve_did_doc<S: BosStr + Sync>(
196
+
&self,
197
+
did: &Did<S>,
198
+
) -> Result<DidDocResponse, IdentityError>
199
+
where
200
+
Self: Sync,
201
+
{
202
+
self.resolver.resolve_did_doc(did).await
203
+
}
204
+
205
+
#[cfg(target_arch = "wasm32")]
206
+
async fn resolve_did_doc<S: BosStr + Sync>(
207
+
&self,
208
+
did: &Did<S>,
209
+
) -> Result<DidDocResponse, IdentityError> {
210
+
self.resolver.resolve_did_doc(did).await
211
+
}
212
+
}
213
+
214
+
#[derive(Debug, thiserror::Error, PartialEq, Eq)]
215
+
pub enum ClientError {
216
+
#[error("invalid Polymodel appview base URI: {0}")]
217
+
InvalidBaseUri(String),
218
+
}
219
+
220
+
fn default_base_uri() -> Result<Uri<String>, ClientError> {
221
+
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
222
+
{
223
+
let origin = web_sys::window()
224
+
.and_then(|window| window.location().origin().ok())
225
+
.filter(|origin| !origin.is_empty())
226
+
.unwrap_or_else(|| DEFAULT_NATIVE_BASE_URI.to_string());
227
+
PolymodelClient::parse_base_uri(&origin)
228
+
}
229
+
230
+
#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
231
+
{
232
+
PolymodelClient::parse_base_uri(DEFAULT_NATIVE_BASE_URI)
233
+
}
234
+
}
235
+
236
+
#[cfg(test)]
237
+
mod tests {
238
+
use super::*;
239
+
use jacquard::ToSmolStr;
240
+
use jacquard_common::xrpc::{CallOptions, build_http_request};
241
+
use polymodel_api::space_polymodel::actor::get_session::GetSession;
242
+
use polymodel_api::space_polymodel::library::get_feed::GetFeed;
243
+
244
+
#[test]
245
+
fn stores_base_uri_without_rewriting_it() {
246
+
let client = PolymodelClient::with_base_uri(
247
+
PolymodelClient::parse_base_uri("https://example.test/app").unwrap(),
248
+
)
249
+
.unwrap();
250
+
251
+
assert_eq!(
252
+
client.current_base_uri().as_str(),
253
+
"https://example.test/app"
254
+
);
255
+
}
256
+
257
+
#[test]
258
+
fn get_feed_payload_builds_same_origin_xrpc_query() {
259
+
let base = Uri::parse("https://example.test".to_string()).unwrap();
260
+
let base_ref = Uri::parse(base.as_str()).unwrap();
261
+
let request = GetFeed::new()
262
+
.algorithm(Some("recent".to_smolstr()))
263
+
.limit(24)
264
+
.build();
265
+
let http = build_http_request(&base_ref, &request, &CallOptions::default()).unwrap();
266
+
267
+
assert_eq!(http.method(), http::Method::GET);
268
+
assert_eq!(
269
+
http.uri().to_string(),
270
+
"https://example.test/xrpc/space.polymodel.library.getFeed?algorithm=recent&limit=24"
271
+
);
272
+
}
273
+
274
+
#[test]
275
+
fn get_session_payload_builds_no_param_query() {
276
+
let base = Uri::parse("https://example.test".to_string()).unwrap();
277
+
let base_ref = Uri::parse(base.as_str()).unwrap();
278
+
let http = build_http_request(&base_ref, &GetSession, &CallOptions::default()).unwrap();
279
+
280
+
assert_eq!(http.method(), http::Method::GET);
281
+
assert_eq!(
282
+
http.uri().to_string(),
283
+
"https://example.test/xrpc/space.polymodel.actor.getSession"
284
+
);
285
+
}
286
+
287
+
#[test]
288
+
fn polymodel_client_exposes_jacquard_identity_resolver_options() {
289
+
let client = PolymodelClient::with_base_uri(
290
+
PolymodelClient::parse_base_uri("https://example.test").unwrap(),
291
+
)
292
+
.unwrap();
293
+
294
+
let _: &ResolverOptions = client.options();
295
+
}
296
+
297
+
#[test]
298
+
fn client_error_formats_for_ui() {
299
+
let error = PolymodelClient::parse_base_uri("not a uri").unwrap_err();
300
+
assert_eq!(
301
+
error.to_string(),
302
+
"invalid Polymodel appview base URI: not a uri"
303
+
);
304
+
}
305
+
}
+3
-3
src/indexing/projection.rs
+3
-3
src/indexing/projection.rs
···
886
886
record: Some(json!({
887
887
"name": name,
888
888
"summary": "a thing summary",
889
-
"tags": ["cube", "calibration"],
889
+
"license": "MIT", "tags": ["cube", "calibration"],
890
890
"createdAt": "2024-01-15T12:00:00.000Z",
891
891
"models": models.iter().map(|m| json!({"uri": m, "cid": "c"})).collect::<Vec<_>>(),
892
892
})),
···
1236
1236
action: "create".to_string(),
1237
1237
record: Some(json!({
1238
1238
"name": "Calibration Cube",
1239
-
"tags": ["cube"],
1239
+
"license": "MIT", "tags": ["cube"],
1240
1240
"createdAt": "2024-01-01T00:00:00.000Z",
1241
1241
"models": [],
1242
1242
})),
···
1253
1253
update.cid = Some("cid2".to_string());
1254
1254
update.record = Some(json!({
1255
1255
"name": "Friendly Sphere",
1256
-
"tags": ["sphere"],
1256
+
"license": "MIT", "tags": ["sphere"],
1257
1257
"createdAt": "2024-01-02T00:00:00.000Z",
1258
1258
"models": [],
1259
1259
}));
+243
-9
src/main.rs
+243
-9
src/main.rs
···
1
1
use dioxus::prelude::*;
2
+
use jacquard_common::xrpc::XrpcClient;
3
+
use polymodel_api::space_polymodel::{actor::get_session::GetSession, library};
2
4
5
+
mod auth;
6
+
mod client;
3
7
mod fonts;
4
8
mod mesh;
9
+
mod session;
5
10
mod thing_card;
6
11
mod viewer;
7
12
···
14
19
#[cfg(feature = "server")]
15
20
mod appview;
16
21
17
-
use thing_card::{ThingCard, thing_card_fixtures};
22
+
use auth::{ToastState, broadcast_sign_out, login_url, logout_url, navigate_to};
23
+
use client::PolymodelClient;
24
+
use session::SessionIdentity;
25
+
use thing_card::ThingCard;
18
26
use viewer::{ViewerPage, demo_model_for_route, demo_models};
19
27
20
28
const FAVICON: Asset = asset!("/assets/favicon.jpg");
···
73
81
74
82
#[component]
75
83
fn App() -> Element {
84
+
let client = use_context_provider(PolymodelClient::default);
85
+
let session = use_context_provider(|| Signal::new(SessionIdentity::Anonymous));
86
+
let toasts = use_context_provider(|| Signal::new(ToastState::default()));
87
+
88
+
let _session_seed = use_resource(move || {
89
+
let client = client.clone();
90
+
let mut session = session;
91
+
async move {
92
+
match client.send(GetSession).await {
93
+
Ok(response) => match response.into_output() {
94
+
Ok(output) => session.set(SessionIdentity::from_get_session(output)),
95
+
Err(error) => tracing::warn!(%error, "failed to decode Polymodel session"),
96
+
},
97
+
Err(error) => tracing::warn!(%error, "failed to fetch Polymodel session"),
98
+
}
99
+
}
100
+
});
101
+
76
102
rsx! {
77
103
document::Meta { name: "viewport", content: "width=device-width, initial-scale=1" }
78
104
document::Title { "Polymodel" }
···
84
110
Stylesheet { href: POLYMODEL_CSS }
85
111
86
112
Router::<Route> {}
113
+
ToastShelf { toasts }
87
114
}
88
115
}
89
116
117
+
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
118
+
enum FeedAlgorithm {
119
+
Recent,
120
+
Hot,
121
+
}
122
+
123
+
impl FeedAlgorithm {
124
+
fn as_str(self) -> &'static str {
125
+
match self {
126
+
Self::Recent => "recent",
127
+
Self::Hot => "hot",
128
+
}
129
+
}
130
+
131
+
fn label(self) -> &'static str {
132
+
match self {
133
+
Self::Recent => "Recent",
134
+
Self::Hot => "Hot",
135
+
}
136
+
}
137
+
}
138
+
139
+
#[derive(Clone, Debug, PartialEq, Eq)]
140
+
enum BrowseFeedState {
141
+
Loading,
142
+
Error(String),
143
+
Empty,
144
+
Populated(Vec<library::ThingViewBasic>),
145
+
}
146
+
147
+
fn browse_feed_state(
148
+
pending: bool,
149
+
result: Option<&Result<Vec<library::ThingViewBasic>, String>>,
150
+
) -> BrowseFeedState {
151
+
if pending && result.is_none() {
152
+
return BrowseFeedState::Loading;
153
+
}
154
+
155
+
match result {
156
+
Some(Ok(things)) if things.is_empty() => BrowseFeedState::Empty,
157
+
Some(Ok(things)) => BrowseFeedState::Populated(things.clone()),
158
+
Some(Err(error)) => BrowseFeedState::Error(error.clone()),
159
+
None => BrowseFeedState::Loading,
160
+
}
161
+
}
162
+
163
+
#[allow(clippy::useless_format)]
90
164
#[component]
91
165
fn Browse() -> Element {
92
166
let viewer_model = demo_models()[0].id.to_string();
93
-
let things = thing_card_fixtures();
167
+
let client = use_context::<PolymodelClient>();
168
+
let session = use_context::<Signal<SessionIdentity>>();
169
+
let toasts = use_context::<Signal<ToastState>>();
170
+
let selected_algorithm = use_signal(|| FeedAlgorithm::Recent);
171
+
172
+
let mut feed = use_resource(move || {
173
+
let client = client.clone();
174
+
let algorithm = *selected_algorithm.read();
175
+
async move {
176
+
let request = library::get_feed::GetFeed::new()
177
+
.algorithm(Some(algorithm.as_str().into()))
178
+
.limit(24)
179
+
.build();
180
+
let response = client
181
+
.send(request)
182
+
.await
183
+
.map_err(|error| format!("Feed request failed: {error}"))?;
184
+
let output = response
185
+
.into_output()
186
+
.map_err(|error| format!("Feed decode failed: {error}"))?;
187
+
Ok(output
188
+
.value
189
+
.items
190
+
.into_iter()
191
+
.map(|item| item.thing)
192
+
.collect::<Vec<_>>())
193
+
}
194
+
});
195
+
196
+
let feed_result = feed.read();
197
+
let feed_state = browse_feed_state(feed.pending(), feed_result.as_ref());
94
198
95
199
rsx! {
96
200
main { class: "browse-page product-shell",
···
108
212
to: Route::Viewer { model_id: viewer_model },
109
213
"Open viewer"
110
214
}
215
+
SessionControl { session, toasts }
111
216
}
112
217
}
113
218
}
···
121
226
aria_label: "Search model projects"
122
227
}
123
228
}
124
-
div { class: "tab-row", role: "tablist", aria_label: "Feed placeholders",
125
-
button { class: "tab is-active", role: "tab", aria_selected: "true", "Recent" }
126
-
button { class: "tab", role: "tab", aria_selected: "false", "Hot" }
127
-
button { class: "tab", role: "tab", aria_selected: "false", "Following" }
229
+
div { class: "tab-row", role: "tablist", aria_label: "Feeds",
230
+
FeedTab { algorithm: FeedAlgorithm::Recent, selected_algorithm }
231
+
FeedTab { algorithm: FeedAlgorithm::Hot, selected_algorithm }
232
+
button { class: "tab", role: "tab", aria_selected: "false", disabled: true, "Following" }
128
233
}
129
234
}
130
235
131
236
section { class: "browse-results-grid", aria_label: "Browse results",
132
-
for thing in things {
133
-
ThingCard { key: "{thing.uri}", thing }
237
+
match feed_state {
238
+
BrowseFeedState::Loading => rsx! {
239
+
for index in 0..6 {
240
+
div { key: "skeleton-{index}", class: "state-card loading-state",
241
+
span { class: "status-pill", "Loading" }
242
+
div { class: "skeleton-line skeleton-wide" }
243
+
div { class: "skeleton-line" }
244
+
div { class: "skeleton-box" }
245
+
}
246
+
}
247
+
},
248
+
BrowseFeedState::Error(error) => {
249
+
let error_message = error.clone();
250
+
rsx! {
251
+
div { class: "state-card error-state browse-state-card",
252
+
p { "{error_message}" }
253
+
button {
254
+
class: "button button-secondary",
255
+
onclick: move |_| feed.restart(),
256
+
"Retry"
257
+
}
258
+
}
259
+
} },
260
+
BrowseFeedState::Empty => rsx! {
261
+
div { class: "state-card empty-state browse-state-card",
262
+
span { class: "status-pill status-muted", "Empty" }
263
+
h2 { "No projects yet" }
264
+
p { "Polymodel reached the appview feed, but this local index has no projects for the selected feed yet." }
265
+
}
266
+
},
267
+
BrowseFeedState::Populated(things) => rsx! {
268
+
for thing in things {
269
+
ThingCard { key: "{thing.uri}", thing }
270
+
}
271
+
},
272
+
}
273
+
}
274
+
}
275
+
}
276
+
}
277
+
278
+
#[component]
279
+
fn FeedTab(algorithm: FeedAlgorithm, selected_algorithm: Signal<FeedAlgorithm>) -> Element {
280
+
let is_active = *selected_algorithm.read() == algorithm;
281
+
let class = if is_active { "tab is-active" } else { "tab" };
282
+
283
+
rsx! {
284
+
button {
285
+
class,
286
+
role: "tab",
287
+
aria_selected: "{is_active}",
288
+
onclick: move |_| selected_algorithm.set(algorithm),
289
+
"{algorithm.label()}"
290
+
}
291
+
}
292
+
}
293
+
294
+
#[component]
295
+
fn SessionControl(session: Signal<SessionIdentity>, toasts: Signal<ToastState>) -> Element {
296
+
let identity = session.read().clone();
297
+
let mut identifier = use_signal(String::new);
298
+
299
+
match identity {
300
+
SessionIdentity::Anonymous => rsx! {
301
+
form {
302
+
class: "session-control",
303
+
onsubmit: move |_| navigate_to(&login_url(&identifier.read())),
304
+
input {
305
+
r#type: "text",
306
+
placeholder: "handle.test",
307
+
aria_label: "ATProto handle",
308
+
value: "{identifier}",
309
+
oninput: move |event| identifier.set(event.value())
310
+
}
311
+
button { class: "button button-primary", r#type: "submit", "Sign in" }
312
+
}
313
+
},
314
+
SessionIdentity::Authenticated(identity) => {
315
+
let label = SessionIdentity::Authenticated(identity).label();
316
+
rsx! {
317
+
div { class: "session-control session-control-authenticated",
318
+
span { class: "status-pill", "{label}" }
319
+
button {
320
+
class: "button button-secondary",
321
+
onclick: move |_| {
322
+
broadcast_sign_out();
323
+
session.set(SessionIdentity::Anonymous);
324
+
toasts.write().push("Signing out…");
325
+
navigate_to(logout_url());
326
+
},
327
+
"Sign out"
328
+
}
329
+
}
330
+
}
331
+
}
332
+
}
333
+
}
334
+
335
+
#[component]
336
+
fn ToastShelf(toasts: Signal<ToastState>) -> Element {
337
+
let items = toasts.read().items().to_vec();
338
+
339
+
rsx! {
340
+
div { class: "toast-shelf", aria_live: "polite",
341
+
for toast in items {
342
+
div { key: "toast-{toast.id}", class: "toast blueprint-panel",
343
+
span { "{toast.message}" }
344
+
button {
345
+
class: "toast-dismiss",
346
+
aria_label: "Dismiss notification",
347
+
onclick: move |_| toasts.write().dismiss(toast.id),
348
+
"×"
349
+
}
134
350
}
135
351
}
136
352
}
···
268
484
269
485
#[cfg(test)]
270
486
mod tests {
271
-
use super::foundation_items;
487
+
use super::*;
488
+
use thing_card::thing_card_fixtures;
272
489
273
490
#[test]
274
491
fn foundation_items_cover_base_primitives() {
···
287
504
.join(" ");
288
505
assert!(!combined.contains("Jira"));
289
506
assert!(!combined.contains("Polytoken"));
507
+
}
508
+
509
+
#[test]
510
+
fn browse_state_distinguishes_loading_empty_error_and_populated() {
511
+
assert_eq!(browse_feed_state(true, None), BrowseFeedState::Loading);
512
+
assert_eq!(
513
+
browse_feed_state(false, Some(&Ok(vec![]))),
514
+
BrowseFeedState::Empty
515
+
);
516
+
assert_eq!(
517
+
browse_feed_state(false, Some(&Err("boom".to_string()))),
518
+
BrowseFeedState::Error("boom".to_string())
519
+
);
520
+
match browse_feed_state(false, Some(&Ok(thing_card_fixtures()))) {
521
+
BrowseFeedState::Populated(things) => assert_eq!(things.len(), 3),
522
+
state => panic!("expected populated state, got {state:?}"),
523
+
}
290
524
}
291
525
}
+124
src/session.rs
+124
src/session.rs
···
1
+
use jacquard_common::deps::smol_str::{SmolStr, ToSmolStr};
2
+
use jacquard_common::types::string::{Did, Handle};
3
+
use polymodel_api::space_polymodel::actor::ProfileView;
4
+
use polymodel_api::space_polymodel::actor::get_session::{GetSessionOutput, SessionView};
5
+
#[derive(Clone, Debug, Default, PartialEq, Eq)]
6
+
pub enum SessionIdentity {
7
+
#[default]
8
+
Anonymous,
9
+
Authenticated(AuthenticatedIdentity),
10
+
}
11
+
12
+
#[derive(Clone, Debug, PartialEq, Eq)]
13
+
pub struct AuthenticatedIdentity {
14
+
pub did: Did,
15
+
pub handle: Handle,
16
+
pub display_name: Option<SmolStr>,
17
+
}
18
+
19
+
impl SessionIdentity {
20
+
pub fn from_get_session(output: GetSessionOutput) -> Self {
21
+
match output.value {
22
+
SessionView::SessionUnauthenticated(_) => Self::Anonymous,
23
+
SessionView::SessionAuthenticated(session) => {
24
+
Self::Authenticated(AuthenticatedIdentity {
25
+
did: session.did,
26
+
handle: session.handle,
27
+
display_name: profile_display_name(&session.profile),
28
+
})
29
+
}
30
+
}
31
+
}
32
+
33
+
pub fn label(&self) -> SmolStr {
34
+
match self {
35
+
Self::Anonymous => SmolStr::new_static("Signed out"),
36
+
Self::Authenticated(identity) => identity
37
+
.display_name
38
+
.clone()
39
+
.unwrap_or_else(|| identity.handle.as_str().to_smolstr()),
40
+
}
41
+
}
42
+
}
43
+
44
+
fn profile_display_name(profile: &ProfileView) -> Option<SmolStr> {
45
+
profile
46
+
.display_name
47
+
.as_ref()
48
+
.map(|value| value.to_smolstr())
49
+
.filter(|value| !value.trim().is_empty())
50
+
}
51
+
52
+
#[cfg(test)]
53
+
mod tests {
54
+
use super::*;
55
+
use jacquard_common::types::did::Did;
56
+
use polymodel_api::space_polymodel::actor::ProfileView;
57
+
use polymodel_api::space_polymodel::actor::get_session::{
58
+
SessionAuthenticated, SessionUnauthenticated,
59
+
};
60
+
#[test]
61
+
fn unauthenticated_get_session_maps_to_anonymous() {
62
+
let output = GetSessionOutput {
63
+
value: SessionView::SessionUnauthenticated(Box::new(SessionUnauthenticated {
64
+
authenticated: false,
65
+
extra_data: None,
66
+
})),
67
+
extra_data: None,
68
+
};
69
+
70
+
assert_eq!(
71
+
SessionIdentity::from_get_session(output),
72
+
SessionIdentity::Anonymous
73
+
);
74
+
}
75
+
76
+
#[test]
77
+
fn authenticated_get_session_maps_identity_label() {
78
+
let output = GetSessionOutput {
79
+
value: SessionView::SessionAuthenticated(Box::new(SessionAuthenticated {
80
+
did: Did::new_owned("did:plc:alice").unwrap(),
81
+
handle: Handle::new_owned("alice.test").unwrap(),
82
+
profile: ProfileView {
83
+
avatar: None,
84
+
default_license: None,
85
+
indexed_at: None,
86
+
description: None,
87
+
did: Did::new_owned("did:plc:alice").unwrap(),
88
+
display_name: Some("Alice Maker".into()),
89
+
handle: "alice.test".into(),
90
+
pronouns: None,
91
+
thing_count: None,
92
+
extra_data: None,
93
+
links: None,
94
+
printers: None,
95
+
record: jacquard::Data::Null,
96
+
total_likes: None,
97
+
},
98
+
extra_data: None,
99
+
authenticated: true,
100
+
})),
101
+
extra_data: None,
102
+
};
103
+
104
+
let identity = SessionIdentity::from_get_session(output);
105
+
assert!(matches!(identity, SessionIdentity::Authenticated(_)));
106
+
assert_eq!(identity.label(), "Alice Maker");
107
+
}
108
+
#[test]
109
+
fn get_session_json_decodes_unauthenticated_union_arm() {
110
+
let output: GetSessionOutput = serde_json::from_str(r#"{"$type":"space.polymodel.actor.getSession#sessionUnauthenticated","authenticated":false}"#).unwrap();
111
+
assert_eq!(
112
+
SessionIdentity::from_get_session(output),
113
+
SessionIdentity::Anonymous
114
+
);
115
+
}
116
+
#[test]
117
+
fn get_session_json_decodes_authenticated_union_arm() {
118
+
let output: GetSessionOutput = serde_json::from_str(r#"{"$type":"space.polymodel.actor.getSession#sessionAuthenticated","authenticated":true,"did":"did:plc:alice","handle":"alice.test","profile":{"avatar":null,"description":null,"did":"did:plc:alice","displayName":"Alice Maker","handle":"alice.test","record":null}}"#).unwrap();
119
+
assert_eq!(
120
+
SessionIdentity::from_get_session(output).label(),
121
+
"Alice Maker"
122
+
);
123
+
}
124
+
}
+4
src/thing_card.rs
+4
src/thing_card.rs
···
1
1
use dioxus::prelude::*;
2
+
#[cfg(test)]
2
3
use jacquard_common::types::{
3
4
string::{AtUri, Datetime, Did, Handle},
4
5
uri::UriValue,
5
6
};
6
7
use polymodel_api::space_polymodel::library;
7
8
9
+
#[cfg(test)]
8
10
const COMPLETE_PREVIEW_SVG: &str = "data:image/svg+xml,%3Csvg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 640 480\"%3E%3Crect width=\"640\" height=\"480\" fill=\"%23f4efe4\"/%3E%3Cg stroke=\"%232a6f97\" stroke-width=\"2\" fill=\"none\"%3E%3Cpath d=\"M64 96h512v288H64zM160 144h320v192H160zM256 192h128v96H256z\"/%3E%3Cpath d=\"M64 384 160 336M576 384 480 336M160 144 64 96M480 144 576 96\"/%3E%3C/g%3E%3Cg fill=\"%2366767f\" font-family=\"monospace\" font-size=\"24\"%3E%3Ctext x=\"72\" y=\"438\"%3Eparametric enclosure preview%3C/text%3E%3C/g%3E%3C/svg%3E";
9
11
10
12
#[derive(Clone, Debug, PartialEq)]
···
13
15
pub alt: String,
14
16
}
15
17
18
+
#[cfg(test)]
16
19
pub fn thing_card_fixtures() -> Vec<library::ThingViewBasic> {
17
20
vec![
18
21
library::ThingViewBasic {
···
234
237
})
235
238
}
236
239
240
+
#[cfg(test)]
237
241
fn actor(
238
242
did: &str,
239
243
handle: &str,