wip: currently rewriting the project as a full stack application
tangled.org/kacaii.dev/sigo
gleam
:lock: consider the enviroment when running the code
+67
-27
+7
-1
dev/app_dev.gleam
+7
-1
dev/app_dev.gleam
···
85
85
let db_process_name = process.new_name("db_conn")
86
86
let registry_name = process.new_name("registry")
87
87
88
-
let assert Ok(config) = app.read_connection_uri(db_process_name)
88
+
let env = case envoy.get("SIGO_PROD") {
89
+
Error(_) -> context.Dev
90
+
Ok(_) -> context.Production
91
+
}
92
+
93
+
let assert Ok(config) = app.read_connection_url(db_process_name, env)
89
94
let assert Ok(secret_key_base) = envoy.get("COOKIE_TOKEN")
90
95
91
96
let db = pog.named_connection(db_process_name)
···
96
101
db:,
97
102
registry_name:,
98
103
secret_key_base:,
104
+
env:,
99
105
)
100
106
}
+16
-6
src/app.gleam
+16
-6
src/app.gleam
···
31
31
pub fn main() -> Nil {
32
32
web.configure_logger()
33
33
34
+
// Enviroment where the code is running on
35
+
let env = case envoy.get("SIGO_PROD") {
36
+
Error(_) -> context.Dev
37
+
Ok(_) -> context.Production
38
+
}
39
+
34
40
// NAMES ---------------------------------------------------------------------
35
41
// Setup registry process name
36
42
let registry_name = process.new_name("registry")
···
44
50
as " Cookie secret key is available"
45
51
46
52
// Postgresql connection URI
47
-
let assert Ok(pog_config) = read_connection_uri(db_process_name)
53
+
let assert Ok(pog_config) = read_connection_url(db_process_name, env)
48
54
as " DataBase connection URI is available"
49
55
50
56
// Pass the application context to the router
···
54
60
db: pog.named_connection(db_process_name),
55
61
registry_name:,
56
62
secret_key_base:,
63
+
env:,
57
64
)
58
65
59
66
let wisp_handler = http_router.handle_request(_, ctx)
···
75
82
76
83
/// Read the `DATABASE_URL` environment variable and then
77
84
/// build the `pog.Config` from that database URI.
78
-
pub fn read_connection_uri(
85
+
///
86
+
/// Disables SSL during development
87
+
pub fn read_connection_url(
79
88
name: process.Name(pog.Message),
89
+
env: context.Enviroment,
80
90
) -> Result(pog.Config, Nil) {
81
91
// Remember to set the enviroment variable before running the app
82
92
use postgres_url <- result.try(envoy.get("DATABASE_URL"))
83
93
84
-
// Disable SSL when not in production
85
-
case envoy.get("SIGO_PROD") {
86
-
Error(_) -> pog.url_config(name, postgres_url)
87
-
Ok(_) -> {
94
+
// Disable SSL when not in production
95
+
case env {
96
+
context.Dev -> pog.url_config(name, postgres_url)
97
+
context.Production -> {
88
98
use config <- result.map(pog.url_config(name, postgres_url))
89
99
pog.ssl(config, pog.SslVerified)
90
100
}
+28
-19
src/app/web.gleam
+28
-19
src/app/web.gleam
···
17
17
18
18
import app/web/context
19
19
import cors_builder as cors
20
-
import envoy
21
20
import gleam/dynamic/decode
22
21
import gleam/http
23
22
import gleam/json
···
32
31
pub fn middleware(
33
32
request req: wisp.Request,
34
33
context ctx: context.Context,
35
-
next handle_request: fn(wisp.Request) -> wisp.Response,
34
+
next handler: fn(wisp.Request) -> wisp.Response,
36
35
) -> wisp.Response {
37
36
let path = "/static"
38
37
let request = wisp.method_override(req)
···
40
39
use <- wisp.log_request(request)
41
40
use <- wisp.rescue_crashes()
42
41
use request <- wisp.handle_head(request)
43
-
use request <- cors.wisp_middleware(request, cors_config())
42
+
use request <- setup_cors(request, ctx)
44
43
45
44
use <- wisp.serve_static(request, under: path, from: ctx.static_directory)
46
-
handle_request(request)
45
+
handler(request)
46
+
}
47
+
48
+
/// Disable CORS during development
49
+
fn setup_cors(
50
+
request request: wisp.Request,
51
+
ctx ctx: context.Context,
52
+
next handler: fn(wisp.Request) -> wisp.Response,
53
+
) -> wisp.Response {
54
+
case ctx.env {
55
+
context.Dev -> handler(request)
56
+
context.Production -> {
57
+
use request <- cors.wisp_middleware(request, cors_config())
58
+
handler(request)
59
+
}
60
+
}
47
61
}
48
62
49
63
/// Configure the Erlang logger
···
65
79
priv_directory <> "/log"
66
80
}
67
81
68
-
/// Disable CORS when not in production
69
82
fn cors_config() -> cors.Cors {
70
-
case envoy.get("SIGO_PROD") {
71
-
Error(_) -> cors.new()
72
-
Ok(_) ->
73
-
cors.new()
74
-
|> cors.allow_origin("https://sigo.cbpm.vercel.app")
75
-
|> cors.allow_method(http.Get)
76
-
|> cors.allow_method(http.Post)
77
-
|> cors.allow_method(http.Put)
78
-
|> cors.allow_method(http.Delete)
79
-
|> cors.allow_header("authorization")
80
-
|> cors.allow_header("content-type")
81
-
|> cors.allow_header("origin")
82
-
|> cors.allow_credentials()
83
-
}
83
+
cors.new()
84
+
|> cors.allow_origin("https://sigo.cbpm.vercel.app")
85
+
|> cors.allow_method(http.Get)
86
+
|> cors.allow_method(http.Post)
87
+
|> cors.allow_method(http.Put)
88
+
|> cors.allow_method(http.Delete)
89
+
|> cors.allow_header("authorization")
90
+
|> cors.allow_header("content-type")
91
+
|> cors.allow_header("origin")
92
+
|> cors.allow_credentials()
84
93
}
85
94
86
95
pub fn handle_decode_error(
+9
src/app/web/context.gleam
+9
src/app/web/context.gleam
···
11
11
db: pog.Connection,
12
12
secret_key_base: String,
13
13
registry_name: process.Name(group_registry.Message(msg.Msg)),
14
+
env: Enviroment,
14
15
)
15
16
}
17
+
18
+
/// Enviroment where the code is running on
19
+
pub type Enviroment {
20
+
/// Code is running locally
21
+
Dev
22
+
/// Code is running in production
23
+
Production
24
+
}
+7
-1
test/app_test.gleam
+7
-1
test/app_test.gleam
···
22
22
let db_process_name = process.new_name("db_conn")
23
23
let registry_name = process.new_name("registry")
24
24
25
-
let assert Ok(config) = app.read_connection_uri(db_process_name)
25
+
let env = case envoy.get("SIGO_PROD") {
26
+
Error(_) -> context.Dev
27
+
Ok(_) -> context.Production
28
+
}
29
+
30
+
let assert Ok(config) = app.read_connection_url(db_process_name, env)
26
31
let assert Ok(secret_key_base) = envoy.get("COOKIE_TOKEN")
27
32
28
33
let db = pog.named_connection(db_process_name)
···
33
38
db:,
34
39
registry_name:,
35
40
secret_key_base:,
41
+
env:,
36
42
)
37
43
})
38
44
}