Add write function

Author: jmcharter

src/git_store.gleam

@@ -6,6 +6,7 @@ import gleam/http/response
 import gleam/httpc
 import gleam/io
 import gleam/json
+import gleam/option.{type Option, None, Some}
 import gleam/result
 import gleam/string
 
@@ -28,11 +29,21 @@ pub type GitHubResponse {
   GitHubFileResponse(content: String, encoding: String, sha: String, size: Int)
 }
 
+/// The required fields to create a new file in a GitHub repo.
+/// Message is the commit message
+/// Content is the base64 encoded text content of the file
+pub type GitHubFile {
+  GitHubFile(message: String, content: String)
+}
+
 pub fn repos_url(config: GitHubConfig) -> String {
   config.base_url <> "/repos"
 }
 
-pub fn read_file(
+/// Get a file object from a GitHub repository at the given path
+/// Path should be a '/' separated String, e.g:
+/// 'foo/bar/baz'
+pub fn get_file(
   config: GitHubConfig,
   path: String,
 ) -> Result(response.Response(String), GitStoreError) {
@@ -46,10 +57,15 @@ pub fn read_file(
     <> "/"
     <> path
 
-  request(config, http.Get, url)
+  request(config, http.Get, url, None)
 }
 
-fn request(config: GitHubConfig, method: http.Method, endpoint: String) {
+fn request(
+  config: GitHubConfig,
+  method: http.Method,
+  endpoint: String,
+  json_body: Option(String),
+) {
   use req <- result.try(
     request.to(endpoint)
     |> result.map_error(fn(_) {
@@ -62,6 +78,7 @@ fn request(config: GitHubConfig, method: http.Method, endpoint: String) {
     |> request.set_header("Authorization", "Bearer " <> config.token)
     |> request.set_header("Accept", "application/vnd.github+json")
     |> request.set_header("User-Agent", "GitStore-Gleam")
+    |> utils.set_json(json_body)
     |> request.set_method(method)
     |> httpc.send()
 
@@ -72,18 +89,30 @@ fn request(config: GitHubConfig, method: http.Method, endpoint: String) {
   })
 }
 
+/// Parse the JSON data from file.body, converting the base64 encoded content
+/// into a String
 fn file_from_json(
   json_string: String,
 ) -> Result(GitHubResponse, json.DecodeError) {
+  logging.log(logging.Debug, json_string)
   let file_decoder = {
     use content <- decode.field(
       "content",
       decode.then(decode.string, fn(item) {
         let decoded =
-          item |> bit_array.base64_decode |> result.try(bit_array.to_string)
+          item
+          |> string.replace("\n", "")
+          |> bit_array.base64_decode
+          |> result.try(bit_array.to_string)
         case decoded {
           Ok(str) -> decode.success(str)
-          Error(_) -> decode.failure("", "A base64 encoded String")
+          Error(_) -> {
+            logging.log(
+              logging.Error,
+              "Failed to decode expected base64 string: " <> item,
+            )
+            decode.failure("", "A base64 encoded String")
+          }
         }
       }),
     )
@@ -95,15 +124,47 @@ fn file_from_json(
   json.parse(json_string, using: file_decoder)
 }
 
+fn file_to_json(file: GitHubFile) -> String {
+  json.object([
+    #("message", json.string(file.message)),
+    #("content", json.string(file.content)),
+  ])
+  |> json.to_string
+}
+
+fn create_file(config: GitHubConfig, filename: String, content: String) {
+  let url =
+    utils.build_path(config.base_url, [
+      "repos",
+      config.owner,
+      config.repo,
+      "contents",
+    ])
+    <> "/"
+    <> filename
+  let content =
+    content
+    |> bit_array.from_string
+    |> bit_array.base64_encode(True)
+  let file = GitHubFile("add: " <> filename, content:)
+  let res = request(config, http.Put, url, Some(file |> file_to_json))
+  logging.log(logging.Debug, "Writing file: " <> string.inspect(res))
+}
+
 pub fn main() -> Nil {
   logging.configure()
+  logging.set_level(logging.Debug)
   let owner = envoy.get("GITHUB_OWNER") |> result.unwrap("")
   let repo = envoy.get("GITHUB_REPO") |> result.unwrap("")
   let token = envoy.get("GITHUB_TOKEN") |> result.unwrap("")
   let base_url =
     envoy.get("GITHUB_BASE_URL") |> result.unwrap("https://api.github.com")
   let config = GithubConfig(owner, repo, token, base_url)
-  let file = read_file(config, "README.md") |> result.unwrap(response.new(400))
+  logging.log(logging.Debug, config |> string.inspect)
+  let file = get_file(config, "README.md") |> result.unwrap(response.new(400))
+  echo file_from_json(file.body)
+  let new_file = create_file(config, "test", "foo bar baz")
+  let file = get_file(config, "test") |> result.unwrap(response.new(400))
   echo file_from_json(file.body)
   io.println("Hello from git_store!")
 }

src/git_store/utils.gleam

@@ -1,6 +1,20 @@
+import gleam/http/request
 import gleam/list
+import gleam/option.{type Option, None, Some}
 
 pub fn build_path(base: String, segments: List(String)) -> String {
   segments
   |> list.fold(base, fn(path, segment) { path <> "/" <> segment })
 }
+
+/// Set the JSON content type header and JSON body if json_body is not None
+pub fn set_json(req: request.Request(String), json_body: Option(String)) {
+  case json_body {
+    Some(body) ->
+      req
+      |> request.set_header("Content-Type", "application/json")
+      |> request.set_body(body)
+
+    None -> req
+  }
+}