fix: AuditEntry fields org and org_id can be array

Author: alexandear

github/orgs_audit_log.go

@@ -9,6 +9,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"strings"
 )
 
 // GetAuditLogOptions sets up optional parameters to query audit-log endpoint.
@@ -57,12 +58,39 @@ type AuditEntry struct {
 }
 
 // UnmarshalJSON implements the json.Unmarshaler interface.
+//
+// GitHub's audit-log API occasionally returns "org" as a JSON array of strings
+// and "org_id" as a JSON array of integers instead of the documented scalar types.
+// This implementation normalises both fields to their scalar forms
+// (joining multiple org names with a comma, and using the first org_id) so
+// callers always receive a consistent type regardless of the API response shape.
 func (a *AuditEntry) UnmarshalJSON(data []byte) error {
 	type entryAlias AuditEntry
-	var v entryAlias
-	if err := json.Unmarshal(data, &v); err != nil {
+	var raw struct {
+		entryAlias
+		Org   json.RawMessage `json:"org,omitempty"`
+		OrgID json.RawMessage `json:"org_id,omitempty"`
+	}
+	if err := json.Unmarshal(data, &raw); err != nil {
 		return err
 	}
+	v := raw.entryAlias
+
+	if len(raw.Org) > 0 && string(raw.Org) != "null" {
+		var err error
+		v.Org, err = unmarshalStringOrArray(raw.Org)
+		if err != nil {
+			return fmt.Errorf("unmarshal org: %w", err)
+		}
+	}
+
+	if len(raw.OrgID) > 0 && string(raw.OrgID) != "null" {
+		var err error
+		v.OrgID, err = unmarshalIntOrArray(raw.OrgID)
+		if err != nil {
+			return fmt.Errorf("unmarshal org_id: %w", err)
+		}
+	}
 
 	rawDefinedFields, err := json.Marshal(v)
 	if err != nil {
@@ -90,6 +118,40 @@ func (a *AuditEntry) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
+// unmarshalStringOrArray decodes a JSON value that is either a plain string or an array of strings.
+// Arrays are joined with ", ".
+func unmarshalStringOrArray(raw json.RawMessage) (*string, error) {
+	var s string
+	if err := json.Unmarshal(raw, &s); err == nil {
+		return &s, nil
+	}
+	var ss []string
+	if err := json.Unmarshal(raw, &ss); err != nil {
+		return nil, err
+	}
+	if len(ss) == 0 {
+		return nil, nil
+	}
+	return Ptr(strings.Join(ss, ", ")), nil
+}
+
+// unmarshalIntOrArray decodes a JSON value that is either a plain integer or an array of integers.
+// Arrays use the first element.
+func unmarshalIntOrArray(raw json.RawMessage) (*int64, error) {
+	var n int64
+	if err := json.Unmarshal(raw, &n); err == nil {
+		return &n, nil
+	}
+	var ns []int64
+	if err := json.Unmarshal(raw, &ns); err != nil {
+		return nil, err
+	}
+	if len(ns) == 0 {
+		return nil, nil
+	}
+	return &ns[0], nil
+}
+
 // MarshalJSON implements the json.Marshaler interface.
 func (a AuditEntry) MarshalJSON() ([]byte, error) {
 	type entryAlias AuditEntry

github/orgs_audit_log_test.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"encoding/json"
 	"fmt"
 	"net/http"
 	"testing"
@@ -366,5 +367,90 @@ func TestAuditEntry_MarshalJSON(t *testing.T) {
 
 	testJSONMarshalOnly(t, u, want)
 	testJSONMarshalOnly(t, &u, want)
-	// can't unmarshal AdditionalFields back into map[string]any, so skip testJSONUnmarshalOnly
+}
+
+func TestAuditEntry_UnmarshalJSON(t *testing.T) {
+	t.Parallel()
+	testJSONUnmarshalOnly(t, &AuditEntry{}, "{}")
+
+	tests := []struct {
+		name    string
+		payload string
+		want    *AuditEntry
+	}{
+		{
+			name:    "org is scalar",
+			payload: `{"action":"test","org":"myorg","org_id":42}`,
+			want:    &AuditEntry{Action: Ptr("test"), Org: Ptr("myorg"), OrgID: Ptr(int64(42))},
+		},
+		{
+			name:    "org is single element array",
+			payload: `{"action":"test","org":["myorg"],"org_id":[42]}`,
+			want:    &AuditEntry{Action: Ptr("test"), Org: Ptr("myorg"), OrgID: Ptr(int64(42))},
+		},
+		{
+			name:    "org is multi-element array",
+			payload: `{"action":"test","org":["org1","org2","org3"],"org_id":[1,2,3]}`,
+			want:    &AuditEntry{Action: Ptr("test"), Org: Ptr("org1, org2, org3"), OrgID: Ptr(int64(1))},
+		},
+		{
+			name:    "org_id is scalar",
+			payload: `{"action":"test","org_id":42}`,
+			want:    &AuditEntry{Action: Ptr("test"), OrgID: Ptr(int64(42))},
+		},
+		{
+			name:    "org_id is array",
+			payload: `{"action":"test","org_id":[42,43,44]}`,
+			want:    &AuditEntry{Action: Ptr("test"), OrgID: Ptr(int64(42))}, // first element
+		},
+		{
+			name:    "org is empty array",
+			payload: `{"action":"test","org":[]}`,
+			want:    &AuditEntry{Action: Ptr("test"), AdditionalFields: map[string]any{"org": []any{}}},
+		},
+		{
+			name:    "org_id is empty array",
+			payload: `{"action":"test","org_id":[]}`,
+			want:    &AuditEntry{Action: Ptr("test"), AdditionalFields: map[string]any{"org_id": []any{}}},
+		},
+		{
+			name:    "org and org_id are null",
+			payload: `{"action":"test","org":null,"org_id":null}`,
+			want:    &AuditEntry{Action: Ptr("test")},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			testJSONUnmarshalOnly(t, tc.want, tc.payload)
+		})
+	}
+}
+
+func TestAuditEntry_UnmarshalJSON_Errors(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name    string
+		payload string
+	}{
+		{
+			name:    "invalid org type",
+			payload: `{"action":"test","org":{"key":"value"}}`,
+		},
+		{
+			name:    "invalid org_id type",
+			payload: `{"action":"test","org_id":{"key":"value"}}`,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			var entry AuditEntry
+			if err := json.Unmarshal([]byte(tc.payload), &entry); err == nil {
+				t.Errorf("AuditEntry.UnmarshalJSON(%q) = nil, but want error", tc.payload)
+			}
+		})
+	}
 }