this repo has no description
lustre
frontent
oat-ui
gleam
:reycle: use api uri for `whoami` request
+51
-27
+49
-26
client/src/client.gleam
+49
-26
client/src/client.gleam
···
24
24
route: route.Route,
25
25
/// Current Page model
26
26
page: page.Page,
27
-
/// Server uri
27
+
/// Server uri used for HTTP requests
28
28
api: uri.Uri,
29
29
)
30
30
}
···
34
34
}
35
35
36
36
pub fn main() -> Nil {
37
+
// ┌──client──┐ ┌─────────server──────────┐
38
+
// │ │─→│ https://localhost:8080/ │
39
+
// └──────────┘ └─────────────────────────┘
37
40
let assert Ok(api) = {
38
41
use value <- result.try(envoy.get("API_URL"))
39
42
uri.parse(value)
···
47
50
}
48
51
49
52
pub type Msg {
50
-
UserNavigatedTo(route.Route)
51
-
UserRestoredSession(Result(session.Session, rsvp.Error))
53
+
UserNavigatedTo(to: route.Route)
54
+
UserRestoredSession(result: Result(session.Session, rsvp.Error))
52
55
53
-
LoginMsg(login.Msg)
54
-
HomeMsg(home.Msg)
56
+
LoginMsg(msg: login.Msg)
57
+
HomeMsg(msg: home.Msg)
55
58
56
-
ServerRemovedToken(Result(response.Response(String), rsvp.Error))
59
+
ServerRemovedToken(return: Result(response.Response(String), rsvp.Error))
57
60
}
58
61
59
-
// INIT
62
+
// INIT ------------------------------------------------------------------------
60
63
61
64
pub fn init(opts: InitOpts) -> #(Model, Effect(Msg)) {
65
+
// Get the `Uri` of the page when it first loaded.
62
66
let assert Ok(uri) = modem.initial_uri()
63
67
let route = route.parse(uri)
64
68
let page = page.init(route)
65
69
let is_protected = route.is_protected(route)
66
-
let session = init_session(route, is_protected)
70
+
let session = init_session(route:, is_protected:)
67
71
68
-
let router_effect =
69
-
modem.init(fn(uri) { route.parse(uri) |> UserNavigatedTo })
72
+
let init_modem = {
73
+
use uri <- modem.init
74
+
UserNavigatedTo(route.parse(uri))
75
+
}
76
+
77
+
let url =
78
+
uri.Uri(..opts.api, path: "/api/whoami")
79
+
|> uri.to_string
70
80
71
-
let session_effect =
81
+
let restore_session =
72
82
UserRestoredSession
73
83
|> rsvp.expect_json(session.decoder(), _)
74
-
|> rsvp.get("/api/whoami", _)
84
+
|> rsvp.get(url, _)
75
85
76
-
let effect = effect.batch([session_effect, router_effect])
86
+
let effect = effect.batch([restore_session, init_modem])
77
87
#(Model(session:, route:, page:, api: opts.api), effect)
78
88
}
79
89
80
-
fn init_session(route: route.Route, is_protected: Bool) -> session.Session {
90
+
fn init_session(
91
+
route route: route.Route,
92
+
is_protected is_protected: Bool,
93
+
) -> session.Session {
81
94
case route {
82
95
route.Login | route.Home ->
83
96
session.Pending(on_success: route.Home, on_error: route)
···
89
102
}
90
103
}
91
104
105
+
// VIEW ------------------------------------------------------------------------
92
106
fn layout(
93
107
element_view: element.Element(a),
94
108
f: fn(a) -> Msg,
···
110
124
}
111
125
}
112
126
113
-
// UPDATE
127
+
// UPDATE ----------------------------------------------------------------------
128
+
//
114
129
pub fn update(model: Model, msg: Msg) -> #(Model, Effect(Msg)) {
115
130
case model, msg {
116
-
// NAVIGATION --------------------------------------------------------------
117
-
//
131
+
// NAVIGATION
118
132
model, UserNavigatedTo(route) -> handle_navigation(model, route)
119
133
120
-
// SESSION MANAGEMENT -------------------------------------------------------
134
+
// SESSION MANAGEMENT -----------------------------------------------------
121
135
//
136
+
// Success
122
137
Model(session: session.Pending(on_success:, on_error: _), ..),
123
138
UserRestoredSession(Ok(session))
124
139
-> #(
···
126
141
modem.push(route.to_path(on_success), option.None, option.None),
127
142
)
128
143
144
+
// Failure
129
145
Model(session: session.Pending(on_success: _, on_error:), ..),
130
146
UserRestoredSession(Error(_))
131
147
-> #(
···
133
149
modem.push(route.to_path(on_error), option.None, option.None),
134
150
)
135
151
152
+
// Ended Session
153
+
//
154
+
// Redirect user to the Home page
136
155
model, ServerRemovedToken(Ok(_)) -> {
137
156
let session = session.None
138
-
let redirect_to = route.to_path(route.Home)
157
+
let route = route.to_path(route.Home)
139
158
140
159
let new = Model(..model, session:)
141
-
let effect = modem.push(redirect_to, option.None, option.None)
160
+
let effect = modem.push(route, option.None, option.None)
142
161
143
162
#(new, effect)
144
163
}
···
150
169
LoginMsg(page_msg)
151
170
-> handle_login_step(model, page_model, page_msg)
152
171
153
-
// FALLBACK ----------------------------------------------------------------
172
+
// FALLBACK
154
173
//
155
174
_, _ -> #(model, effect.none())
156
175
}
···
167
186
_, _ -> route
168
187
}
169
188
170
-
let new = Model(..model, route:, page: page.init(route))
171
-
#(new, effect.none())
189
+
let page = page.init(route)
190
+
#(Model(..model, route:, page:), effect.none())
172
191
}
173
192
174
193
fn handle_login_step(
···
177
196
msg: login.Msg,
178
197
) -> #(Model, Effect(Msg)) {
179
198
case login.update(page_model, msg, model.api) {
199
+
// Continue execution
180
200
login.Continue(page_model, effect) -> #(
181
201
Model(..model, page: page.Login(page_model)),
182
202
effect.map(effect, LoginMsg),
183
203
)
184
204
205
+
// Authentication was sucessful
185
206
login.ServerAuthenticatedUser(session) -> #(
186
207
Model(..model, session:),
187
208
route.Home
···
189
210
|> modem.push(option.None, option.None),
190
211
)
191
212
213
+
// Authentication failed
192
214
login.ServerFailedToAuthenticate(reason) -> {
193
215
let message = case reason {
194
216
rsvp.HttpError(resp) -> resp.body
···
197
219
_ -> ""
198
220
}
199
221
200
-
let page_model = login.Model(..page_model, loading: False, message:)
201
-
let new = Model(..model, page: page.Login(page_model))
222
+
let page =
223
+
login.Model(..page_model, loading: False, message:)
224
+
|> page.Login
202
225
203
-
#(new, effect.none())
226
+
#(Model(..model, page:), effect.none())
204
227
}
205
228
}
206
229
}