undo response nesting and align case

src/godon/client.nim

@@ -72,12 +72,17 @@ proc handleResponse*[T](client: GodonClient; response: Response): ApiResponse[T]
             if value.kind == JArray:
               result = ApiResponse[T](success: true, data: value.to(T), error: "")
               return
-        # Check for wrapped single object responses
+        # For single objects, try direct conversion first (bare objects)
         else:
-          for key, value in jsonData.pairs:
-            if value.kind == JObject:
-              result = ApiResponse[T](success: true, data: value.to(T), error: "")
-              return
+          try:
+            result = ApiResponse[T](success: true, data: jsonData.to(T), error: "")
+            return
+          except CatchableError:
+            # If direct conversion fails, try finding wrapped object
+            for key, value in jsonData.pairs:
+              if value.kind == JObject:
+                result = ApiResponse[T](success: true, data: value.to(T), error: "")
+                return
 
       # Fallback to direct conversion
       result = ApiResponse[T](success: true, data: jsonData.to(T), error: "")

src/godon/credential.nim

@@ -4,39 +4,46 @@ import client, types
 
 # Credential API client methods
 
-proc listCredentials*(client: GodonClient): ApiResponseList[Credential] =
+proc listCredentials*(client: GodonClient): ApiResponse[seq[Credential]] =
   ## List all credentials
   let url = client.baseUrl() & "/credentials"
 
   try:
     let response = client.httpClient.get(url)
     if response.code == Http200:
       let body = parseJson(response.body)
-      let credentials = body["credentials"]
+      var credentials: seq[Credential] = @[]
 
-      var result: seq[Credential] = @[]
-      for cred in credentials.items:
-        result.add(parseCredentialFromJson(cred))
+      # Handle both bare array and wrapped responses
+      let jsonArray = if body.kind == JArray:
+        body
+      elif body.hasKey("credentials"):
+        body["credentials"]
+      else:
+        raise newException(ValueError, "Unexpected response format")
 
-      return ApiResponseList[Credential](
+      for credJson in jsonArray.items:
+        credentials.add(parseCredentialFromJson(credJson))
+
+      return ApiResponse[seq[Credential]](
         success: true,
-        data: result,
+        data: credentials,
         error: ""
       )
     else:
-      return ApiResponseList[Credential](
+      return ApiResponse[seq[Credential]](
         success: false,
         data: @[],
         error: "Failed to list credentials: " & response.status
       )
   except Exception as e:
-    return ApiResponseList[Credential](
+    return ApiResponse[seq[Credential]](
       success: false,
       data: @[],
       error: "Exception: " & e.msg
     )
 
-proc createCredential*(client: GodonClient, credentialData: JsonNode): ApiResponseSingle[Credential] =
+proc createCredential*(client: GodonClient, credentialData: JsonNode): ApiResponse[Credential] =
   ## Create a new credential
   let url = client.baseUrl() & "/credentials"
 
@@ -45,49 +52,47 @@ proc createCredential*(client: GodonClient, credentialData: JsonNode): ApiRespon
     let response = client.httpClient.post(url, $credentialData)
     if response.code == Http201:
       let body = parseJson(response.body)
-      let credential = parseCredentialFromJson(body["credential"])
-
-      return ApiResponseSingle[Credential](
+      let credential = parseCredentialFromJson(body)
+      return ApiResponse[Credential](
         success: true,
         data: credential,
         error: ""
       )
     else:
-      return ApiResponseSingle[Credential](
+      return ApiResponse[Credential](
         success: false,
         data: Credential(),
         error: "Failed to create credential: " & response.status
       )
   except Exception as e:
-    return ApiResponseSingle[Credential](
+    return ApiResponse[Credential](
       success: false,
       data: Credential(),
       error: "Exception: " & e.msg
     )
 
-proc getCredential*(client: GodonClient, credentialId: string): ApiResponseSingle[Credential] =
+proc getCredential*(client: GodonClient, credentialId: string): ApiResponse[Credential] =
   ## Get a specific credential by ID (including content)
   let url = client.baseUrl() & "/credentials/" & encodeUrl(credentialId)
 
   try:
     let response = client.httpClient.get(url)
     if response.code == Http200:
       let body = parseJson(response.body)
-      let credential = parseCredentialFromJson(body["credential"])
-
-      return ApiResponseSingle[Credential](
+      let credential = parseCredentialFromJson(body)
+      return ApiResponse[Credential](
         success: true,
         data: credential,
         error: ""
       )
     else:
-      return ApiResponseSingle[Credential](
+      return ApiResponse[Credential](
         success: false,
         data: Credential(),
         error: "Failed to get credential: " & response.status
       )
   except Exception as e:
-    return ApiResponseSingle[Credential](
+    return ApiResponse[Credential](
       success: false,
       data: Credential(),
       error: "Exception: " & e.msg
@@ -120,7 +125,7 @@ proc deleteCredential*(client: GodonClient, credentialId: string): ApiResponse[J
       error: "Exception: " & e.msg
     )
 
-proc createCredentialFromYaml*(client: GodonClient, yamlContent: string): ApiResponseSingle[Credential] =
+proc createCredentialFromYaml*(client: GodonClient, yamlContent: string): ApiResponse[Credential] =
   ## Create credential from YAML content
   ## This is a convenience method that parses YAML and converts to JSON
 
@@ -133,7 +138,7 @@ proc createCredentialFromYaml*(client: GodonClient, yamlContent: string): ApiRes
 
     # Add required fields
     credentialData.add("name", newJString(yamlData["name"]))
-    credentialData.add("credential_type", newJString(yamlData["credential_type"]))
+    credentialData.add("credentialType", newJString(yamlData["credential_type"]))
 
     # Add optional fields
     if "description" in yamlData:
@@ -145,15 +150,15 @@ proc createCredentialFromYaml*(client: GodonClient, yamlContent: string): ApiRes
     if "content" in yamlData:
       credentialData.add("content", newJString(yamlData["content"]))
     else:
-      return ApiResponseSingle[Credential](
+      return ApiResponse[Credential](
         success: false,
         data: Credential(),
         error: "Missing required field: content"
       )
 
     return client.createCredential(credentialData)
   except Exception as e:
-    return ApiResponseSingle[Credential](
+    return ApiResponse[Credential](
       success: false,
       data: Credential(),
       error: "Failed to parse YAML: " & e.msg

src/godon/types.nim

@@ -69,20 +69,20 @@ proc parseCredentialFromJson*(json: JsonNode): Credential =
     result.id = json["id"].getStr()
   if json.hasKey("name"):
     result.name = json["name"].getStr()
-  if json.hasKey("credential_type"):
-    result.credentialType = json["credential_type"].getStr()
+  if json.hasKey("credentialType"):
+    result.credentialType = json["credentialType"].getStr()
   if json.hasKey("description"):
     result.description = json["description"].getStr()
   else:
     result.description = ""
-  if json.hasKey("windmill_variable"):
-    result.windmillVariable = json["windmill_variable"].getStr()
-  if json.hasKey("created_at"):
-    result.createdAt = json["created_at"].getStr()
+  if json.hasKey("windmillVariable"):
+    result.windmillVariable = json["windmillVariable"].getStr()
+  if json.hasKey("createdAt"):
+    result.createdAt = json["createdAt"].getStr()
   else:
     result.createdAt = ""
-  if json.hasKey("last_used_at"):
-    result.lastUsedAt = json["last_used_at"].getStr()
+  if json.hasKey("lastUsedAt"):
+    result.lastUsedAt = json["lastUsedAt"].getStr()
   else:
     result.lastUsedAt = ""
   if json.hasKey("content"):