Wrap http request type

src/glitch.gleam

@@ -1,13 +1,13 @@
 import gleam/io
-// import gleam/option.{None}
+import gleam/option.{None}
 // import gleam/result
 import gleam/uri
 import dot_env/env
 import glitch/api/client.{Options}
-// import glitch/api/chat.{SendMessageRequest}
+import glitch/api/chat.{SendMessageRequest}
 import glitch/api/auth.{AuthorizationCode, GetTokenRequest}
 
-// const user_id = "209286766"
+const user_id = "209286766"
 
 pub fn main() {
   let assert Ok(client_id) = env.get("CLIENT_ID")
@@ -18,15 +18,15 @@ pub fn main() {
   let client_options = Options(client_id: client_id, access_token: access_token)
   let client = client.new(client_options)
 
-  // let send_message_request =
-  //   SendMessageRequest(
-  //     broadcaster_id: user_id,
-  //     sender_id: user_id,
-  //     message: "Hello Twitter from Glitch and Gleam!",
-  //     reply_parent_message_id: None,
-  //   )
-  //
-  // let assert Ok(_) = chat.send_message(client, send_message_request)
+  let send_message_request =
+    SendMessageRequest(
+      broadcaster_id: user_id,
+      sender_id: user_id,
+      message: "Hello Twitch Chat from Glitch and Gleam!",
+      reply_parent_message_id: None,
+    )
+
+  let assert Ok(_) = chat.send_message(client, send_message_request)
 
   let get_token_request = GetTokenRequest(code, AuthorizationCode, redirect_uri)
 

src/glitch/api/api_request.gleam

@@ -1,13 +1,133 @@
-import gleam/http.{Https}
-import gleam/http/request.{type Request}
+import gleam/result
+import gleam/http.{type Header, Https}
+import gleam/http/request.{type Request, Request}
+import gleam/http/response.{type Response}
+import gleam/httpc
+import glitch/api/error.{type TwitchApiError, RequestError}
+import glitch/extended/request_ext
 
-pub type TwitchApiRequest =
-  Request(String)
+pub opaque type TwitchApiRequest {
+  ApiRequest(Request(String))
+  IdApiRequest(Request(String))
+}
 
-const host = "api.twitch.tv/helix"
+const api_host = "api.twitch.tv"
 
-pub fn from_request(request: Request(String)) -> TwitchApiRequest {
-  request
+const id_api_host = "id.twitch.tv"
+
+fn api_request_from_request(request: Request(String)) -> TwitchApiRequest {
+  ApiRequest(request)
+}
+
+fn id_api_request_from_request(request: Request(String)) -> TwitchApiRequest {
+  IdApiRequest(request)
+}
+
+pub fn new_api_request() -> TwitchApiRequest {
+  request.new()
   |> request.set_scheme(Https)
-  |> request.set_host(host)
+  |> request.set_host(api_host)
+  |> api_request_from_request
+}
+
+pub fn new_id_api_request() {
+  request.new()
+  |> request.set_scheme(Https)
+  |> request.set_host(id_api_host)
+  |> id_api_request_from_request
+}
+
+fn to_http_request(request: TwitchApiRequest) -> Request(String) {
+  case request {
+    ApiRequest(http_request) -> http_request
+    IdApiRequest(http_request) -> http_request
+  }
+}
+
+pub fn send(
+  request: TwitchApiRequest,
+) -> Result(Response(String), TwitchApiError(error)) {
+  request
+  |> to_http_request
+  |> httpc.send
+  |> result.map_error(RequestError)
+}
+
+pub fn set_headers(
+  request: TwitchApiRequest,
+  headers: List(Header),
+) -> TwitchApiRequest {
+  let set_headers_internal = fn(request, headers) {
+    request
+    |> to_http_request
+    |> request_ext.set_headers(headers)
+  }
+
+  case request {
+    ApiRequest(_) as http_request ->
+      http_request
+      |> set_headers_internal(headers)
+      |> ApiRequest
+    IdApiRequest(_) as http_request ->
+      http_request
+      |> set_headers_internal(headers)
+      |> ApiRequest
+  }
+}
+
+pub fn set_header(request, header) {
+  let set_header_internal = fn(request, header) {
+    request
+    |> to_http_request
+    |> request_ext.set_header(header)
+  }
+
+  case request {
+    ApiRequest(_) as http_request ->
+      http_request
+      |> set_header_internal(header)
+      |> ApiRequest
+    IdApiRequest(_) as http_request ->
+      http_request
+      |> set_header_internal(header)
+      |> ApiRequest
+  }
+}
+
+pub fn set_method(request, method) {
+  case request {
+    ApiRequest(http_request) ->
+      ApiRequest(Request(..http_request, method: method))
+    IdApiRequest(http_request) ->
+      IdApiRequest(Request(..http_request, method: method))
+  }
+}
+
+pub fn set_query(request, query_params) {
+  case request {
+    ApiRequest(http_request) ->
+      http_request
+      |> request.set_query(query_params)
+      |> ApiRequest
+    IdApiRequest(http_request) ->
+      http_request
+      |> request.set_query(query_params)
+      |> IdApiRequest
+  }
+}
+
+pub fn set_body(request, body) {
+  case request {
+    ApiRequest(http_request) -> ApiRequest(Request(..http_request, body: body))
+    IdApiRequest(http_request) ->
+      IdApiRequest(Request(..http_request, body: body))
+  }
+}
+
+pub fn set_path(request, path) {
+  case request {
+    ApiRequest(http_request) -> ApiRequest(Request(..http_request, path: path))
+    IdApiRequest(http_request) ->
+      IdApiRequest(Request(..http_request, path: path))
+  }
 }

src/glitch/api/chat.gleam

@@ -58,7 +58,7 @@ pub fn send_message(
   let request =
     request.new()
     |> request.set_body(body)
-    |> request.set_path("chat/messages")
+    |> request.set_path("helix/chat/messages")
 
   use response <- result.try(client.post(client, request))
 

src/glitch/api/client.gleam

@@ -1,11 +1,14 @@
 import gleam/list
+import gleam/io
+import gleam/function
 import gleam/pair
 import gleam/result
+import gleam/uri
 import gleam/http.{type Header, Get, Post}
 import gleam/http/request.{type Request, Request}
 import gleam/http/response.{type Response}
 import gleam/httpc
-import glitch/api/api_request
+import glitch/api/api_request.{type TwitchApiRequest}
 import glitch/api/error.{type TwitchApiError, RequestError}
 import glitch/extended/request_ext
 
@@ -38,47 +41,44 @@ pub fn headers(client: Client) -> List(Header) {
   ]
 }
 
-fn merge_headers(
-  base_headers: List(Header),
-  new_headers: List(Header),
-) -> List(Header) {
-  list.fold(new_headers, base_headers, fn(acc, header) {
-    let key = pair.first(header)
-    let value = pair.second(header)
-    list.key_set(acc, key, value)
-  })
-}
-
 pub fn get(
   client: Client,
-  request: Request(String),
+  request: TwitchApiRequest,
 ) -> Result(Response(String), TwitchApiError(error)) {
-  let headers =
-    client
-    |> headers
-    |> merge_headers(request.headers)
-
-  request
-  |> request.set_method(Get)
-  |> request_ext.set_headers(headers)
-  |> api_request.from_request
-  |> httpc.send
-  |> result.map_error(RequestError)
+  todo
+  // let headers =
+  //   client
+  //   |> headers
+  //   |> merge_headers(request.headers)
+  //
+  // request
+  // |> request.set_method(Get)
+  // |> request_ext.set_headers(headers)
+  // |> api_request.from_request
+  // |> httpc.send
+  // |> result.map_error(RequestError)
 }
 
 pub fn post(
   client: Client,
   request: Request(String),
 ) -> Result(Response(String), TwitchApiError(error)) {
-  let headers =
-    client
-    |> headers
-    |> merge_headers(request.headers)
-
-  request
-  |> request.set_method(Post)
-  |> request_ext.set_headers(headers)
-  |> api_request.from_request
-  |> httpc.send
-  |> result.map_error(RequestError)
+  // let headers =
+  //   client
+  //   |> headers
+  //   |> merge_headers(request.headers)
+  //
+  // request
+  // |> request.set_method(Post)
+  // |> request_ext.set_headers(headers)
+  // |> api_request.from_request
+  // |> function.tap(fn(req) {
+  //   io.debug(
+  //     request.to_uri(req)
+  //     |> uri.to_string,
+  //   )
+  // })
+  // |> httpc.send
+  // |> result.map_error(RequestError)
+  todo
 }

src/glitch/api/user.gleam

@@ -105,7 +105,7 @@ pub fn get_users(
     request.new()
     |> request.set_body("")
     |> request.set_query(query_params_from_get_users_request(request))
-    |> request.set_path("users")
+    |> request.set_path("helix/users")
 
   use response <- result.try(client.get(client, request))
 

src/glitch/extended/request_ext.gleam

@@ -18,6 +18,16 @@ pub fn set_headers(
   Request(..request, headers: new_headers)
 }
 
+pub fn set_header(
+  request: Request(body),
+  header: #(String, String),
+) -> Request(body) {
+  let key = string.lowercase(header.0)
+  let value = header.1
+
+  request.set_header(request, key, value)
+}
+
 pub fn set_query_string(
   request: Request(body),
   query: Option(String),