kacaii.dev
wip: currently rewriting the project as a full stack application
tangled.org/kacaii.dev/sigo
gleam
:label: properly map to a `Session` error type
+3
-3
src/app/domain/notification/get_notification_preferences.gleam
+3
-3
src/app/domain/notification/get_notification_preferences.gleam
···
38
39
fn handle_error(err: GetNotificationPreferencesError) -> wisp.Response {
40
case err {
41
-
AccessControl(err) -> session.handle_error(err)
42
DatabaseError(err) -> web.handle_database_error(err)
43
}
44
}
···
49
) -> Result(String, GetNotificationPreferencesError) {
50
use token <- result.try(
51
session.extract(req)
52
-
|> result.map_error(AccessControl),
53
)
54
55
use returned <- result.try(
···
77
/// Querying the user notification preferences can fail
78
type GetNotificationPreferencesError {
79
/// Authentication failed
80
-
AccessControl(session.SessionError)
81
/// An error occurred while querying the DataBase
82
DatabaseError(pog.QueryError)
83
}
···
38
39
fn handle_error(err: GetNotificationPreferencesError) -> wisp.Response {
40
case err {
41
+
Session(err) -> session.handle_error(err)
42
DatabaseError(err) -> web.handle_database_error(err)
43
}
44
}
···
49
) -> Result(String, GetNotificationPreferencesError) {
50
use token <- result.try(
51
session.extract(req)
52
+
|> result.map_error(Session),
53
)
54
55
use returned <- result.try(
···
77
/// Querying the user notification preferences can fail
78
type GetNotificationPreferencesError {
79
/// Authentication failed
80
+
Session(session.SessionError)
81
/// An error occurred while querying the DataBase
82
DatabaseError(pog.QueryError)
83
}
+3
-3
src/app/domain/notification/update_notification_preferences.gleam
+3
-3
src/app/domain/notification/update_notification_preferences.gleam
···
40
41
type UpdateNotificationPreferencesError {
42
/// Authentication failed
43
-
AccessControl(session.SessionError)
44
/// Failed to query Database
45
DataBase(pog.QueryError)
46
NotFound
···
78
79
fn handle_error(err: UpdateNotificationPreferencesError) -> wisp.Response {
80
case err {
81
-
AccessControl(err) -> session.handle_error(err)
82
DataBase(err) -> web.handle_database_error(err)
83
NotFound ->
84
"O banco de dados não retornou resultados após atualizar as preferências"
···
97
) {
98
use token <- result.try(
99
session.extract(req)
100
-
|> result.map_error(AccessControl),
101
)
102
103
use acc, #(key, value) <- list.try_fold(
···
40
41
type UpdateNotificationPreferencesError {
42
/// Authentication failed
43
+
Session(session.SessionError)
44
/// Failed to query Database
45
DataBase(pog.QueryError)
46
NotFound
···
78
79
fn handle_error(err: UpdateNotificationPreferencesError) -> wisp.Response {
80
case err {
81
+
Session(err) -> session.handle_error(err)
82
DataBase(err) -> web.handle_database_error(err)
83
NotFound ->
84
"O banco de dados não retornou resultados após atualizar as preferências"
···
97
) {
98
use token <- result.try(
99
session.extract(req)
100
+
|> result.map_error(Session),
101
)
102
103
use acc, #(key, value) <- list.try_fold(
+3
-3
src/app/domain/occurrence/close_occurrence.gleam
+3
-3
src/app/domain/occurrence/close_occurrence.gleam
···
23
/// An error occurred whe naccessing the DataBase
24
DataBase(pog.QueryError)
25
/// Errors related to authentication / authorization
26
-
AccessControl(session.SessionError)
27
}
28
29
/// Updates the `resolved_at` field of a occurrence
···
55
) -> Result(String, ResolveOccurrenceError) {
56
use _ <- result.try(
57
session.extract(req)
58
-
|> result.map_error(AccessControl),
59
)
60
61
use target <- result.try(
···
102
103
fn handle_error(err: ResolveOccurrenceError) -> wisp.Response {
104
case err {
105
-
AccessControl(err) -> session.handle_error(err)
106
DataBase(err) -> web.handle_database_error(err)
107
InvalidUuid(id) ->
108
wisp.bad_request("Ocorrência possui Uuid inválido: " <> id)
···
23
/// An error occurred whe naccessing the DataBase
24
DataBase(pog.QueryError)
25
/// Errors related to authentication / authorization
26
+
Session(session.SessionError)
27
}
28
29
/// Updates the `resolved_at` field of a occurrence
···
55
) -> Result(String, ResolveOccurrenceError) {
56
use _ <- result.try(
57
session.extract(req)
58
+
|> result.map_error(Session),
59
)
60
61
use target <- result.try(
···
102
103
fn handle_error(err: ResolveOccurrenceError) -> wisp.Response {
104
case err {
105
+
Session(err) -> session.handle_error(err)
106
DataBase(err) -> web.handle_database_error(err)
107
InvalidUuid(id) ->
108
wisp.bad_request("Ocorrência possui Uuid inválido: " <> id)
+3
-3
src/app/domain/occurrence/delete_occurrence.gleam
+3
-3
src/app/domain/occurrence/delete_occurrence.gleam
···
15
/// Occurrence has invalid Uuid
16
InvalidUuid(String)
17
/// Authentication failed
18
-
AccessControl(session.SessionError)
19
/// Failed to query the DataBase
20
DataBase(pog.QueryError)
21
/// Occurrence was not found in the system
···
58
use _ <- result.try(
59
// Armazenamos o UUID do usuário caso precisemos para autorização
60
session.extract(req)
61
-
|> result.map_error(AccessControl),
62
)
63
64
use returned <- result.try(
···
81
InvalidUuid(uuid_string) ->
82
// 404 Bad Request
83
wisp.bad_request("UUID inválido: " <> uuid_string)
84
-
AccessControl(err) -> session.handle_error(err)
85
DataBase(db_err) -> web.handle_database_error(db_err)
86
OccurrenceNotFound(occ_uuid) -> {
87
// 404 not found
···
15
/// Occurrence has invalid Uuid
16
InvalidUuid(String)
17
/// Authentication failed
18
+
Session(session.SessionError)
19
/// Failed to query the DataBase
20
DataBase(pog.QueryError)
21
/// Occurrence was not found in the system
···
58
use _ <- result.try(
59
// Armazenamos o UUID do usuário caso precisemos para autorização
60
session.extract(req)
61
+
|> result.map_error(Session),
62
)
63
64
use returned <- result.try(
···
81
InvalidUuid(uuid_string) ->
82
// 404 Bad Request
83
wisp.bad_request("UUID inválido: " <> uuid_string)
84
+
Session(err) -> session.handle_error(err)
85
DataBase(db_err) -> web.handle_database_error(db_err)
86
OccurrenceNotFound(occ_uuid) -> {
87
// 404 not found
+3
-3
src/app/domain/occurrence/register_new_occurrence.gleam
+3
-3
src/app/domain/occurrence/register_new_occurrence.gleam
···
86
87
type RegisterNewOccurrenceError {
88
/// Failed to authenticate the user
89
-
AccessControl(session.SessionError)
90
/// Failed to access the database
91
DataBase(pog.QueryError)
92
/// Database returned no results
···
97
98
fn handle_error(err: RegisterNewOccurrenceError) -> wisp.Response {
99
case err {
100
-
AccessControl(err) -> session.handle_error(err)
101
DataBase(err) -> web.handle_database_error(err)
102
FailedToAssignBrigade(id) -> {
103
let body = "Não foi possível designar a equipe: " <> uuid.to_string(id)
···
148
) -> Result(String, RegisterNewOccurrenceError) {
149
use token <- result.try(
150
session.extract(request)
151
-
|> result.map_error(AccessControl),
152
)
153
154
use returned <- result.try(
···
86
87
type RegisterNewOccurrenceError {
88
/// Failed to authenticate the user
89
+
Session(session.SessionError)
90
/// Failed to access the database
91
DataBase(pog.QueryError)
92
/// Database returned no results
···
97
98
fn handle_error(err: RegisterNewOccurrenceError) -> wisp.Response {
99
case err {
100
+
Session(err) -> session.handle_error(err)
101
DataBase(err) -> web.handle_database_error(err)
102
FailedToAssignBrigade(id) -> {
103
let body = "Não foi possível designar a equipe: " <> uuid.to_string(id)
···
148
) -> Result(String, RegisterNewOccurrenceError) {
149
use token <- result.try(
150
session.extract(request)
151
+
|> result.map_error(Session),
152
)
153
154
use returned <- result.try(
+3
-3
src/app/domain/occurrence/reopen_occurrence.gleam
+3
-3
src/app/domain/occurrence/reopen_occurrence.gleam
···
23
/// An error occurred whe naccessing the DataBase
24
DataBase(pog.QueryError)
25
/// Errors related to authentication / authorization
26
-
AccessControl(session.SessionError)
27
}
28
29
/// Updates the `resolved_at` field of a occurrence
···
55
) -> Result(String, ResolveOccurrenceError) {
56
use _ <- result.try(
57
session.extract(req)
58
-
|> result.map_error(AccessControl),
59
)
60
61
use target <- result.try(
···
101
102
fn handle_error(err: ResolveOccurrenceError) -> wisp.Response {
103
case err {
104
-
AccessControl(err) -> session.handle_error(err)
105
DataBase(err) -> web.handle_database_error(err)
106
InvalidUuid(id) ->
107
wisp.bad_request("Ocorrência possui Uuid inválido: " <> id)
···
23
/// An error occurred whe naccessing the DataBase
24
DataBase(pog.QueryError)
25
/// Errors related to authentication / authorization
26
+
Session(session.SessionError)
27
}
28
29
/// Updates the `resolved_at` field of a occurrence
···
55
) -> Result(String, ResolveOccurrenceError) {
56
use _ <- result.try(
57
session.extract(req)
58
+
|> result.map_error(Session),
59
)
60
61
use target <- result.try(
···
101
102
fn handle_error(err: ResolveOccurrenceError) -> wisp.Response {
103
case err {
104
+
Session(err) -> session.handle_error(err)
105
DataBase(err) -> web.handle_database_error(err)
106
InvalidUuid(id) ->
107
wisp.bad_request("Ocorrência possui Uuid inválido: " <> id)
+8
-19
src/app/domain/user.gleam
+8
-19
src/app/domain/user.gleam
···
11
import wisp
12
import youid/uuid
13
14
-
pub const uuid_cookie_name = "USER_ID"
15
-
16
-
/// Errors related to user access control (authentication & authorization)
17
pub type AccessControlError {
18
/// Authentication failed
19
-
Authentication(session.SessionError)
20
/// User is authentication but lacks permissions
21
-
AuthorizationError(
22
user_uuid: uuid.Uuid,
23
user_role: role.Role,
24
authorized_roles: List(role.Role),
···
31
InvalidRole(String)
32
}
33
34
-
/// Authentication-specific failures
35
-
pub type AuthenticationError {
36
-
/// Request is missing the authetication Cookie
37
-
MissingCookie
38
-
/// User doesn't have a valid UUID
39
-
InvalidUUID(String)
40
-
}
41
-
42
/// Broadcast an arbitrary message to an user
43
///
44
/// Spawns a new process
···
62
) -> Result(role.Role, AccessControlError) {
63
use token <- result.try(
64
session.extract(request)
65
-
|> result.map_error(Authentication),
66
)
67
68
// Check if that role has authorization
69
list.find(authorized_roles, fn(authorized) { token.user_role == authorized })
70
-
|> result.replace_error(AuthorizationError(
71
user_uuid: token.user_id,
72
user_role: token.user_role,
73
authorized_roles:,
···
76
77
pub fn handle_access_control_error(err: AccessControlError) {
78
case err {
79
-
Authentication(err) -> session.handle_error(err)
80
DataBase(err) -> web.handle_database_error(err)
81
RoleNotFound ->
82
-
"Não foi possível confirmar o Cargo do usuário autenticado"
83
|> wisp.Text
84
|> wisp.set_body(wisp.response(401), _)
85
86
InvalidRole(str) ->
87
-
wisp.Text("Usuário autenticado possui cargo inválido: " <> str)
88
|> wisp.set_body(wisp.response(401), _)
89
90
-
AuthorizationError(user_uuid:, user_role:, authorized_roles:) -> {
91
json.object([
92
#("id", json.string(uuid.to_string(user_uuid))),
93
#("user_role", json.string(role.to_string_pt_br(user_role:))),
···
11
import wisp
12
import youid/uuid
13
14
pub type AccessControlError {
15
/// Authentication failed
16
+
Session(session.SessionError)
17
/// User is authentication but lacks permissions
18
+
NotAuthorized(
19
user_uuid: uuid.Uuid,
20
user_role: role.Role,
21
authorized_roles: List(role.Role),
···
28
InvalidRole(String)
29
}
30
31
/// Broadcast an arbitrary message to an user
32
///
33
/// Spawns a new process
···
51
) -> Result(role.Role, AccessControlError) {
52
use token <- result.try(
53
session.extract(request)
54
+
|> result.map_error(Session),
55
)
56
57
// Check if that role has authorization
58
list.find(authorized_roles, fn(authorized) { token.user_role == authorized })
59
+
|> result.replace_error(NotAuthorized(
60
user_uuid: token.user_id,
61
user_role: token.user_role,
62
authorized_roles:,
···
65
66
pub fn handle_access_control_error(err: AccessControlError) {
67
case err {
68
+
Session(err) -> session.handle_error(err)
69
DataBase(err) -> web.handle_database_error(err)
70
RoleNotFound ->
71
+
"Não foi possível confirmar o cargo do usuário"
72
|> wisp.Text
73
|> wisp.set_body(wisp.response(401), _)
74
75
InvalidRole(str) ->
76
+
wisp.Text("Usuário autenticado possui cargo não reconhecido: " <> str)
77
|> wisp.set_body(wisp.response(401), _)
78
79
+
NotAuthorized(user_uuid:, user_role:, authorized_roles:) -> {
80
json.object([
81
#("id", json.string(uuid.to_string(user_uuid))),
82
#("user_role", json.string(role.to_string_pt_br(user_role:))),
+16
-13
src/app/web/socket.gleam
+16
-13
src/app/web/socket.gleam
···
1
import app/domain/notification/sql as notif_sql
2
import app/domain/occurrence/category
3
-
import app/domain/user
4
import app/domain/user/sql as user_sql
5
import app/web/context.{type Context}
6
import app/web/socket/envelope
7
import app/web/socket/message as msg
8
import gleam/bit_array
···
40
InvalidSignature
41
/// The signed message could not be properly decrypted
42
InvalidUtf8
43
-
/// Session token has invalid Uuid fomat
44
-
InvalidUuid(String)
45
/// Failed to access the DataBase
46
Database(pog.QueryError)
47
/// Content-length header is missing
···
56
pub fn handle_request(req: Request, ctx: Context) -> Response {
57
let registry = group_registry.get_registry(ctx.registry_name)
58
59
-
case extract_uuid(req, ctx) {
60
Error(err) -> handle_error(err)
61
-
Ok(user_uuid) -> handle_connection(req, ctx, user_uuid, registry)
62
}
63
}
64
···
288
}
289
}
290
291
-
fn extract_uuid(req: Request, ctx: Context) -> Result(uuid.Uuid, WebSocketError) {
292
let cookies = request.get_cookies(req)
293
let salt = <<ctx.secret_key_base:utf8>>
294
295
-
use hashed_uuid <- result.try(
296
-
list.key_find(cookies, user.uuid_cookie_name)
297
|> result.replace_error(MissingCookie),
298
)
299
300
use decrypted <- result.try(
301
-
crypto.verify_signed_message(hashed_uuid, salt)
302
|> result.replace_error(InvalidSignature),
303
)
304
305
-
use maybe_uuid_str <- result.try(
306
bit_array.to_string(decrypted)
307
|> result.replace_error(InvalidUtf8),
308
)
309
310
-
uuid.from_string(maybe_uuid_str)
311
-
|> result.replace_error(InvalidUuid(maybe_uuid_str))
312
}
313
314
// ON INIT ---------------------------------------------------------------------
···
413
414
fn handle_error(err: WebSocketError) -> Response {
415
case err {
416
-
InvalidUuid(id) -> {
417
let body = "Usuário possui Uuid inválido: " <> id
418
send_response(body, 401)
419
}
···
1
import app/domain/notification/sql as notif_sql
2
import app/domain/occurrence/category
3
import app/domain/user/sql as user_sql
4
import app/web/context.{type Context}
5
+
import app/web/session
6
import app/web/socket/envelope
7
import app/web/socket/message as msg
8
import gleam/bit_array
···
40
InvalidSignature
41
/// The signed message could not be properly decrypted
42
InvalidUtf8
43
+
/// Session token has invalid format
44
+
InvalidToken(String)
45
/// Failed to access the DataBase
46
Database(pog.QueryError)
47
/// Content-length header is missing
···
56
pub fn handle_request(req: Request, ctx: Context) -> Response {
57
let registry = group_registry.get_registry(ctx.registry_name)
58
59
+
case extract_token(req, ctx) {
60
Error(err) -> handle_error(err)
61
+
Ok(token) -> handle_connection(req, ctx, token.user_id, registry)
62
}
63
}
64
···
288
}
289
}
290
291
+
fn extract_token(
292
+
req: Request,
293
+
ctx: Context,
294
+
) -> Result(session.Session, WebSocketError) {
295
let cookies = request.get_cookies(req)
296
let salt = <<ctx.secret_key_base:utf8>>
297
298
+
use hashed_token <- result.try(
299
+
list.key_find(cookies, session.cookie_name)
300
|> result.replace_error(MissingCookie),
301
)
302
303
use decrypted <- result.try(
304
+
crypto.verify_signed_message(hashed_token, salt)
305
|> result.replace_error(InvalidSignature),
306
)
307
308
+
use session_str <- result.try(
309
bit_array.to_string(decrypted)
310
|> result.replace_error(InvalidUtf8),
311
)
312
313
+
json.parse(session_str, session.decoder())
314
+
|> result.replace_error(InvalidToken(session_str))
315
}
316
317
// ON INIT ---------------------------------------------------------------------
···
416
417
fn handle_error(err: WebSocketError) -> Response {
418
case err {
419
+
InvalidToken(id) -> {
420
let body = "Usuário possui Uuid inválido: " <> id
421
send_response(body, 401)
422
}