gleam.toml

@@ -1,5 +1,5 @@
 name = "spacetraders_sdk"
-version = "1.5.0"
+version = "1.4.0"
 gleam = ">= 1.11.0"
 description = "A Gleam SDK for the spacetraders.io game API"
 licences = ["MIT"]

src/spacetraders_api.gleam

@@ -56,11 +56,10 @@ import spacetraders_models/waypoint_modifier.{type WaypointModifier}
 import spacetraders_models/waypoint_symbol.{type WaypointSymbol}
 import spacetraders_models/waypoint_trait_symbol.{type WaypointTraitSymbol}
 import spacetraders_models/waypoint_type.{type WaypointType}
-import spacetraders_sdk.{
+import spacetraders_sdk/internal/api.{
   type AccountToken, type AgentToken, type ApiResponse, type PagedData,
   AccountAuth, AgentAuth, NoAuth,
 }
-import spacetraders_sdk/internal/api
 import spacetraders_sdk/internal/time
 
 pub fn get_account(token: AgentToken) -> ApiResponse(Account) {
@@ -104,10 +103,7 @@ pub fn register_new_agent(
   case response.status {
     201 ->
       api.parse_data_response(response, {
-        use token <- decode.field(
+        use token <- decode.field("token", api.agent_token_decoder())
-          "token",
-          spacetraders_sdk.agent_token_decoder(),
-        )
         use agent <- decode.field("agent", agent.decoder())
         use faction <- decode.field("faction", faction.decoder())
         use contract <- decode.field("contract", contract.decoder())

src/spacetraders_sdk.gleam

@@ -1,93 +1,33 @@
-import gleam/dynamic.{type Dynamic}
+import spacetraders_sdk/internal/api
-import gleam/dynamic/decode.{type Decoder}
-import gleam/http/request.{type Request}
-import gleam/httpc.{type HttpError}
-import gleam/json.{type DecodeError}
-import gleam/option.{type Option}
-import gleam/result
-import spacetraders_models/meta.{type Meta}
-import spacetraders_sdk/internal/jwt
 
-pub type ErrorResponse {
+pub type ApiResponse(data) =
-  ErrorResponse(
+  api.ApiResponse(data)
-    code: Int,
-    message: String,
-    data: Option(Dynamic),
-    request_id: Option(String),
-  )
-}
 
-pub type ApiError {
+pub type ApiError =
-  HttpcError(HttpError)
+  api.ApiError
-  JsonDecodeError(DecodeError)
-  ResponseError(ErrorResponse)
-}
 
-pub type ApiResponse(a) =
+pub type ErrorResponse =
-  Result(a, ApiError)
+  api.ErrorResponse
 
-pub type PagedData(data) {
+pub type PagedData(data) =
-  PagedData(data: data, meta: Meta)
+  api.PagedData(data)
-}
 
-pub opaque type AccountToken {
+pub type AccountToken =
-  AccountToken(token: String)
+  api.AccountToken
-}
 
-pub opaque type AgentToken {
+pub type AgentToken =
-  AgentToken(token: String)
+  api.AgentToken
-}
 
-pub type TokenParseError {
+pub type TokenParseError =
-  InvalidToken
+  api.TokenParseError
-  IncorrectType
-}
 
-pub type AuthMethod {
+pub type AuthMethod =
-  AccountAuth(AccountToken)
+  api.AuthMethod
-  AgentAuth(AgentToken)
-  NoAuth
-}
 
-pub fn parse_account_token(
+pub const parse_account_token = api.parse_account_token
-  value: String,
-) -> Result(AccountToken, TokenParseError) {
-  use jwt <- result.try(jwt.parse(value) |> result.replace_error(InvalidToken))
-  case jwt.payload.subject {
-    "account-token" -> Ok(AccountToken(value))
-    _ -> Error(IncorrectType)
-  }
-}
 
-pub fn account_token_decoder() -> Decoder(AccountToken) {
+pub const account_token_decoder = api.account_token_decoder
-  use value <- decode.then(decode.string)
-  case parse_account_token(value) {
-    Ok(token) -> decode.success(token)
-    Error(_) -> decode.failure(AccountToken("invalid"), "AccountToken")
-  }
-}
 
-pub fn parse_agent_token(value: String) -> Result(AgentToken, TokenParseError) {
+pub const parse_agent_token = api.parse_agent_token
-  use jwt <- result.try(jwt.parse(value) |> result.replace_error(InvalidToken))
-  case jwt.payload.subject {
-    "agent-token" -> Ok(AgentToken(value))
-    _ -> Error(IncorrectType)
-  }
-}
 
-pub fn agent_token_decoder() -> Decoder(AgentToken) {
+pub const agent_token_decoder = api.agent_token_decoder
-  use value <- decode.then(decode.string)
-  case parse_agent_token(value) {
-    Ok(token) -> decode.success(token)
-    Error(_) -> decode.failure(AgentToken("invalid"), "AgentToken")
-  }
-}
-
-@internal
-pub fn set_request_auth(req: Request(a), auth_method: AuthMethod) -> Request(a) {
-  case auth_method {
-    NoAuth -> req
-    AccountAuth(AccountToken(token)) | AgentAuth(AgentToken(token)) ->
-      req |> request.set_header("Authorization", "Bearer " <> token)
-  }
-}

src/spacetraders_sdk/internal/api.gleam

@@ -1,18 +1,99 @@
 import gleam/bit_array
+import gleam/dynamic.{type Dynamic}
 import gleam/dynamic/decode.{type Decoder}
 import gleam/http.{type Method}
 import gleam/http/request.{type Request}
 import gleam/http/response.{type Response}
-import gleam/httpc
+import gleam/httpc.{type HttpError}
 import gleam/int
-import gleam/json.{type Json}
+import gleam/json.{type DecodeError, type Json}
 import gleam/option.{type Option}
 import gleam/result
 import gleam/string_tree
-import spacetraders_models/meta
+import spacetraders_models/meta.{type Meta}
-import spacetraders_sdk.{
+import spacetraders_sdk/internal/jwt
-  type ApiResponse, type AuthMethod, type ErrorResponse, type PagedData,
+
-  ErrorResponse, HttpcError, JsonDecodeError, PagedData, ResponseError,
+pub type ErrorResponse {
+  ErrorResponse(
+    code: Int,
+    message: String,
+    data: Option(Dynamic),
+    request_id: Option(String),
+  )
+}
+
+pub type ApiError {
+  HttpcError(HttpError)
+  JsonDecodeError(DecodeError)
+  ResponseError(ErrorResponse)
+}
+
+pub type ApiResponse(a) =
+  Result(a, ApiError)
+
+pub type PagedData(data) {
+  PagedData(data: data, meta: Meta)
+}
+
+pub opaque type AccountToken {
+  AccountToken(token: String)
+}
+
+pub opaque type AgentToken {
+  AgentToken(token: String)
+}
+
+pub type TokenParseError {
+  InvalidToken
+  IncorrectType
+}
+
+pub type AuthMethod {
+  AccountAuth(AccountToken)
+  AgentAuth(AgentToken)
+  NoAuth
+}
+
+pub fn parse_account_token(
+  value: String,
+) -> Result(AccountToken, TokenParseError) {
+  use jwt <- result.try(jwt.parse(value) |> result.replace_error(InvalidToken))
+  case jwt.payload.subject {
+    "account-token" -> Ok(AccountToken(value))
+    _ -> Error(IncorrectType)
+  }
+}
+
+pub fn account_token_decoder() -> Decoder(AccountToken) {
+  use value <- decode.then(decode.string)
+  case parse_account_token(value) {
+    Ok(token) -> decode.success(token)
+    Error(_) -> decode.failure(AccountToken("invalid"), "AccountToken")
+  }
+}
+
+pub fn parse_agent_token(value: String) -> Result(AgentToken, TokenParseError) {
+  use jwt <- result.try(jwt.parse(value) |> result.replace_error(InvalidToken))
+  case jwt.payload.subject {
+    "agent-token" -> Ok(AgentToken(value))
+    _ -> Error(IncorrectType)
+  }
+}
+
+pub fn agent_token_decoder() -> Decoder(AgentToken) {
+  use value <- decode.then(decode.string)
+  case parse_agent_token(value) {
+    Ok(token) -> decode.success(token)
+    Error(_) -> decode.failure(AgentToken("invalid"), "AgentToken")
+  }
+}
+
+fn set_auth(req: Request(a), auth_method: AuthMethod) -> Request(a) {
+  case auth_method {
+    NoAuth -> req
+    AccountAuth(AccountToken(token)) | AgentAuth(AgentToken(token)) ->
+      req |> request.set_header("Authorization", "Bearer " <> token)
+  }
 }
 
 const base_request = request.Request(
@@ -54,7 +135,7 @@ fn set_json_body(req: Request(a), json: Json) {
 fn make_request(method: Method, auth_method: AuthMethod, path: String) {
   base_request
   |> request.set_method(method)
-  |> spacetraders_sdk.set_request_auth(auth_method)
+  |> set_auth(auth_method)
   |> request.set_path(base_request.path <> path)
 }