kacaii.dev
๐ฉโ๐ Firefighters API written in Gleam!
lustre
gleam
:passport_control: use "user" module for generating seed
+174
-104
+1
-1
server/src/server.gleam
+1
-1
server/src/server.gleam
+31
-18
server/src/server/seed.gleam
+31
-18
server/src/server/seed.gleam
···
2
import gleam/result
3
import pog
4
import server/auth
5
import server/seed/sql
6
7
pub type UserTableState {
8
Empty
9
Populated
10
}
11
12
pub const full_name = "SIGO"
13
14
pub const password = "root"
···
17
18
pub const phone = "0000000000"
19
20
-
pub const role = sql.Admin
21
22
/// ๎ถง Generate a root user when starting the system for the first time
23
-
pub fn germinate(
24
-
db: pog.Connection,
25
-
salt: String,
26
-
) -> Result(Nil, pog.QueryError) {
27
-
use state <- result.try(guard(db))
28
use <- bool.guard(when: state == Populated, return: Ok(Nil))
29
30
-
let hashed = auth.hash(value: password, salt:)
31
-
use _ <- result.map(sql.germinate(
32
-
db,
33
-
full_name,
34
-
role,
35
-
hashed,
36
-
email,
37
-
phone,
38
-
True,
39
-
))
40
41
Nil
42
}
43
44
-
fn guard(db: pog.Connection) -> Result(UserTableState, pog.QueryError) {
45
-
use returned <- result.map(sql.guard(db))
46
case returned.count {
47
0 -> Empty
48
_ -> Populated
···
2
import gleam/result
3
import pog
4
import server/auth
5
+
import server/context
6
import server/seed/sql
7
+
import server/user
8
+
import shared/role
9
10
pub type UserTableState {
11
Empty
12
Populated
13
}
14
15
+
pub type SeedError {
16
+
Auth(auth.AuthError)
17
+
UserError(user.UserError)
18
+
Database(pog.QueryError)
19
+
}
20
+
21
pub const full_name = "SIGO"
22
23
pub const password = "root"
···
26
27
pub const phone = "0000000000"
28
29
+
pub const role = role.Admin
30
31
/// ๎ถง Generate a root user when starting the system for the first time
32
+
pub fn germinate(ctx: context.Context, salt: String) -> Result(Nil, SeedError) {
33
+
use state <- result.try(guard(ctx.db))
34
use <- bool.guard(when: state == Populated, return: Ok(Nil))
35
+
let hashed = auth.hash(value: password, salt:)
36
37
+
use _ <- result.map(
38
+
user.register(
39
+
ctx: ctx,
40
+
user_name: full_name,
41
+
user_role: role,
42
+
user_password: hashed,
43
+
user_email: email,
44
+
user_phone: phone,
45
+
is_active: True,
46
+
)
47
+
|> result.map_error(UserError),
48
+
)
49
50
Nil
51
}
52
53
+
fn guard(db: pog.Connection) -> Result(UserTableState, SeedError) {
54
+
use returned <- result.map(
55
+
sql.guard(db)
56
+
|> result.map_error(Database),
57
+
)
58
+
59
case returned.count {
60
0 -> Empty
61
_ -> Populated
-65
server/src/server/seed/sql.gleam
-65
server/src/server/seed/sql.gleam
···
7
import gleam/dynamic/decode
8
import pog
9
10
-
/// ๎ถง creates a default user when starting the system
11
-
///
12
-
/// > ๐ฟ๏ธ This function was generated automatically using v4.6.0 of
13
-
/// > the [squirrel package](https://github.com/giacomocavalieri/squirrel).
14
-
///
15
-
pub fn germinate(
16
-
db: pog.Connection,
17
-
arg_1: String,
18
-
arg_2: UserRoleEnum,
19
-
arg_3: String,
20
-
arg_4: String,
21
-
arg_5: String,
22
-
arg_6: Bool,
23
-
) -> Result(pog.Returned(Nil), pog.QueryError) {
24
-
let decoder = decode.map(decode.dynamic, fn(_) { Nil })
25
-
26
-
"-- ๎ถง creates a default user when starting the system
27
-
insert into public.user_account as u (
28
-
full_name,
29
-
user_role,
30
-
password_hash,
31
-
email,
32
-
phone,
33
-
is_active
34
-
) values ($1, $2, $3, $4, $5, $6);
35
-
"
36
-
|> pog.query
37
-
|> pog.parameter(pog.text(arg_1))
38
-
|> pog.parameter(user_role_enum_encoder(arg_2))
39
-
|> pog.parameter(pog.text(arg_3))
40
-
|> pog.parameter(pog.text(arg_4))
41
-
|> pog.parameter(pog.text(arg_5))
42
-
|> pog.parameter(pog.bool(arg_6))
43
-
|> pog.returning(decoder)
44
-
|> pog.execute(db)
45
-
}
46
-
47
/// A row you get from running the `guard` query
48
/// defined in `./src/server/seed/sql/guard.sql`.
49
///
···
76
|> pog.returning(decoder)
77
|> pog.execute(db)
78
}
79
-
80
-
// --- Enums -------------------------------------------------------------------
81
-
82
-
/// Corresponds to the Postgres `user_role_enum` enum.
83
-
///
84
-
/// > ๐ฟ๏ธ This type definition was generated automatically using v4.6.0 of the
85
-
/// > [squirrel package](https://github.com/giacomocavalieri/squirrel).
86
-
///
87
-
pub type UserRoleEnum {
88
-
Sargeant
89
-
Firefighter
90
-
Developer
91
-
Captain
92
-
Analyst
93
-
Admin
94
-
}
95
-
96
-
fn user_role_enum_encoder(user_role_enum) -> pog.Value {
97
-
case user_role_enum {
98
-
Sargeant -> "sargeant"
99
-
Firefighter -> "firefighter"
100
-
Developer -> "developer"
101
-
Captain -> "captain"
102
-
Analyst -> "analyst"
103
-
Admin -> "admin"
104
-
}
105
-
|> pog.text
106
-
}
-9
server/src/server/seed/sql/germinate.sql
-9
server/src/server/seed/sql/germinate.sql
+55
-9
server/src/server/user.gleam
+55
-9
server/src/server/user.gleam
···
1
import gleam/list
2
import gleam/result
3
import pog
4
import server/user/sql
5
import shared/role
6
import shared/user
···
27
user.User(
28
uuid:,
29
full_name: row.full_name,
30
-
role: role_from_enum(row.role),
31
email: row.email,
32
phone: row.phone,
33
)
34
}
35
36
-
fn role_from_enum(enum: sql.UserRoleEnum) -> role.Role {
37
case enum {
38
sql.Sargeant -> role.Sargeant
39
sql.Firefighter -> role.Firefighter
···
41
sql.Captain -> role.Captain
42
sql.Analyst -> role.Analyst
43
sql.Admin -> role.Admin
44
}
45
}
46
47
-
pub fn handle_error(err: UserError) -> wisp.Response {
48
-
case err {
49
-
Database(_) -> wisp.internal_server_error()
50
-
NotFound ->
51
-
"User not found"
52
-
|> wisp.Text
53
-
|> wisp.set_body(wisp.response(404), _)
54
}
55
}
···
1
import gleam/list
2
import gleam/result
3
import pog
4
+
import server/auth
5
+
import server/context
6
import server/user/sql
7
import shared/role
8
import shared/user
···
29
user.User(
30
uuid:,
31
full_name: row.full_name,
32
+
role: enum_to_role(row.role),
33
email: row.email,
34
phone: row.phone,
35
)
36
}
37
38
+
pub fn register(
39
+
ctx ctx: context.Context,
40
+
user_name full_name: String,
41
+
user_role role: role.Role,
42
+
user_password password: String,
43
+
user_email email: String,
44
+
user_phone phone: String,
45
+
is_active is_active: Bool,
46
+
) -> Result(user.User, UserError) {
47
+
let hashed = auth.hash(value: password, salt: ctx.secret_key)
48
+
let role_enum = role_to_enum(role)
49
+
50
+
use returned <- result.try(
51
+
sql.register(ctx.db, full_name, role_enum, hashed, email, phone, is_active)
52
+
|> result.map_error(Database),
53
+
)
54
+
55
+
use row <- result.map(
56
+
list.first(returned.rows)
57
+
|> result.replace_error(NotFound),
58
+
)
59
+
60
+
user.User(
61
+
uuid: row.id,
62
+
role: row.user_role |> enum_to_role,
63
+
full_name: row.full_name,
64
+
email: row.email,
65
+
phone: row.phone,
66
+
)
67
+
}
68
+
69
+
pub fn handle_error(err: UserError) -> wisp.Response {
70
+
case err {
71
+
Database(_) -> wisp.internal_server_error()
72
+
NotFound ->
73
+
"User not found"
74
+
|> wisp.Text
75
+
|> wisp.set_body(wisp.response(404), _)
76
+
}
77
+
}
78
+
79
+
fn enum_to_role(enum: sql.UserRoleEnum) -> role.Role {
80
case enum {
81
sql.Sargeant -> role.Sargeant
82
sql.Firefighter -> role.Firefighter
···
84
sql.Captain -> role.Captain
85
sql.Analyst -> role.Analyst
86
sql.Admin -> role.Admin
87
+
sql.None -> role.None
88
}
89
}
90
91
+
fn role_to_enum(role: role.Role) -> sql.UserRoleEnum {
92
+
case role {
93
+
role.Admin -> sql.Admin
94
+
role.Analyst -> sql.Analyst
95
+
role.Captain -> sql.Captain
96
+
role.Developer -> sql.Developer
97
+
role.Firefighter -> sql.Firefighter
98
+
role.Sargeant -> sql.Sargeant
99
+
role.None -> sql.None
100
}
101
}
+81
-1
server/src/server/user/sql.gleam
+81
-1
server/src/server/user/sql.gleam
···
58
|> pog.execute(db)
59
}
60
61
// --- Enums -------------------------------------------------------------------
62
63
/// Corresponds to the Postgres `user_role_enum` enum.
···
66
/// > [squirrel package](https://github.com/giacomocavalieri/squirrel).
67
///
68
pub type UserRoleEnum {
69
Sargeant
70
Firefighter
71
Developer
···
77
fn user_role_enum_decoder() -> decode.Decoder(UserRoleEnum) {
78
use user_role_enum <- decode.then(decode.string)
79
case user_role_enum {
80
"sargeant" -> decode.success(Sargeant)
81
"firefighter" -> decode.success(Firefighter)
82
"developer" -> decode.success(Developer)
83
"captain" -> decode.success(Captain)
84
"analyst" -> decode.success(Analyst)
85
"admin" -> decode.success(Admin)
86
-
_ -> decode.failure(Sargeant, "UserRoleEnum")
87
}
88
}
89
90
// --- Encoding/decoding utils -------------------------------------------------
···
58
|> pog.execute(db)
59
}
60
61
+
/// A row you get from running the `register` query
62
+
/// defined in `./src/server/user/sql/register.sql`.
63
+
///
64
+
/// > ๐ฟ๏ธ This type definition was generated automatically using v4.6.0 of the
65
+
/// > [squirrel package](https://github.com/giacomocavalieri/squirrel).
66
+
///
67
+
pub type RegisterRow {
68
+
RegisterRow(
69
+
id: Uuid,
70
+
full_name: String,
71
+
user_role: UserRoleEnum,
72
+
email: String,
73
+
phone: String,
74
+
is_active: Bool,
75
+
)
76
+
}
77
+
78
+
/// ๏ด register an user
79
+
///
80
+
/// > ๐ฟ๏ธ This function was generated automatically using v4.6.0 of
81
+
/// > the [squirrel package](https://github.com/giacomocavalieri/squirrel).
82
+
///
83
+
pub fn register(
84
+
db: pog.Connection,
85
+
arg_1: String,
86
+
arg_2: UserRoleEnum,
87
+
arg_3: String,
88
+
arg_4: String,
89
+
arg_5: String,
90
+
arg_6: Bool,
91
+
) -> Result(pog.Returned(RegisterRow), pog.QueryError) {
92
+
let decoder = {
93
+
use id <- decode.field(0, uuid_decoder())
94
+
use full_name <- decode.field(1, decode.string)
95
+
use user_role <- decode.field(2, user_role_enum_decoder())
96
+
use email <- decode.field(3, decode.string)
97
+
use phone <- decode.field(4, decode.string)
98
+
use is_active <- decode.field(5, decode.bool)
99
+
decode.success(RegisterRow(
100
+
id:,
101
+
full_name:,
102
+
user_role:,
103
+
email:,
104
+
phone:,
105
+
is_active:,
106
+
))
107
+
}
108
+
109
+
"-- ๏ด register an user
110
+
insert into public.user_account as u
111
+
(full_name, user_role, password_hash, email, phone, is_active)
112
+
values ($1, $2, $3, $4, $5, $6)
113
+
returning u.id, u.full_name, u.user_role, u.email, u.phone, u.is_active;
114
+
"
115
+
|> pog.query
116
+
|> pog.parameter(pog.text(arg_1))
117
+
|> pog.parameter(user_role_enum_encoder(arg_2))
118
+
|> pog.parameter(pog.text(arg_3))
119
+
|> pog.parameter(pog.text(arg_4))
120
+
|> pog.parameter(pog.text(arg_5))
121
+
|> pog.parameter(pog.bool(arg_6))
122
+
|> pog.returning(decoder)
123
+
|> pog.execute(db)
124
+
}
125
+
126
// --- Enums -------------------------------------------------------------------
127
128
/// Corresponds to the Postgres `user_role_enum` enum.
···
131
/// > [squirrel package](https://github.com/giacomocavalieri/squirrel).
132
///
133
pub type UserRoleEnum {
134
+
None
135
Sargeant
136
Firefighter
137
Developer
···
143
fn user_role_enum_decoder() -> decode.Decoder(UserRoleEnum) {
144
use user_role_enum <- decode.then(decode.string)
145
case user_role_enum {
146
+
"none" -> decode.success(None)
147
"sargeant" -> decode.success(Sargeant)
148
"firefighter" -> decode.success(Firefighter)
149
"developer" -> decode.success(Developer)
150
"captain" -> decode.success(Captain)
151
"analyst" -> decode.success(Analyst)
152
"admin" -> decode.success(Admin)
153
+
_ -> decode.failure(None, "UserRoleEnum")
154
}
155
+
}
156
+
157
+
fn user_role_enum_encoder(user_role_enum) -> pog.Value {
158
+
case user_role_enum {
159
+
None -> "none"
160
+
Sargeant -> "sargeant"
161
+
Firefighter -> "firefighter"
162
+
Developer -> "developer"
163
+
Captain -> "captain"
164
+
Analyst -> "analyst"
165
+
Admin -> "admin"
166
+
}
167
+
|> pog.text
168
}
169
170
// --- Encoding/decoding utils -------------------------------------------------
+5
server/src/server/user/sql/register.sql
+5
server/src/server/user/sql/register.sql
+1
-1
server/test/server_test.gleam
+1
-1
server/test/server_test.gleam
···
21
let assert Ok(secret_key) = envoy.get("SECRET_KEY")
22
let assert Ok(pog_config) = server.read_connection_uri(db_process_name)
23
let assert Ok(_db_process) = pog.start(pog_config)
24
-
let assert Ok(_result) = seed.germinate(db, secret_key)
25
26
let ctx = Context(priv:, db:, secret_key:)
27
next(ctx)
28
}
···
21
let assert Ok(secret_key) = envoy.get("SECRET_KEY")
22
let assert Ok(pog_config) = server.read_connection_uri(db_process_name)
23
let assert Ok(_db_process) = pog.start(pog_config)
24
25
let ctx = Context(priv:, db:, secret_key:)
26
+
let assert Ok(_result) = seed.germinate(ctx, secret_key)
27
next(ctx)
28
}