From cf544c9c6ecd4af09c75fd2a53f46073ddf178ff Mon Sep 17 00:00:00 2001 From: "cloudquery-ci[bot]" <271027272+cloudquery-ci[bot]@users.noreply.github.com> Date: Mon, 21 Sep 2026 10:57:12 +0000 Subject: [PATCH] fix: Generate CloudQuery Go API Client from `spec.json` --- client.gen.go | 141 ++++++++++++++++++++++++++++++++++++++++++++++++++ models.gen.go | 72 ++++++++++++++++++++++++++ spec.json | 45 ++++++++++++++++ 3 files changed, 258 insertions(+) diff --git a/client.gen.go b/client.gen.go index 9658394..983b5f9 100644 --- a/client.gen.go +++ b/client.gen.go @@ -342,6 +342,9 @@ type ClientInterface interface { AIOnboardingNewConversation(ctx context.Context, teamName string, body AIOnboardingNewConversationJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + // GetTeamAnalyticsSalt request + GetTeamAnalyticsSalt(ctx context.Context, teamName TeamName, reqEditors ...RequestEditorFn) (*http.Response, error) + // ListTeamAPIKeys request ListTeamAPIKeys(ctx context.Context, teamName TeamName, params *ListTeamAPIKeysParams, reqEditors ...RequestEditorFn) (*http.Response, error) @@ -1652,6 +1655,18 @@ func (c *Client) AIOnboardingNewConversation(ctx context.Context, teamName strin return c.Client.Do(req) } +func (c *Client) GetTeamAnalyticsSalt(ctx context.Context, teamName TeamName, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewGetTeamAnalyticsSaltRequest(c.Server, teamName) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + func (c *Client) ListTeamAPIKeys(ctx context.Context, teamName TeamName, params *ListTeamAPIKeysParams, reqEditors ...RequestEditorFn) (*http.Response, error) { req, err := NewListTeamAPIKeysRequest(c.Server, teamName, params) if err != nil { @@ -6356,6 +6371,40 @@ func NewAIOnboardingNewConversationRequestWithBody(server string, teamName strin return req, nil } +// NewGetTeamAnalyticsSaltRequest generates requests for GetTeamAnalyticsSalt +func NewGetTeamAnalyticsSaltRequest(server string, teamName TeamName) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "team_name", runtime.ParamLocationPath, teamName) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/teams/%s/analytics-salt", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + // NewListTeamAPIKeysRequest generates requests for ListTeamAPIKeys func NewListTeamAPIKeysRequest(server string, teamName TeamName, params *ListTeamAPIKeysParams) (*http.Request, error) { var err error @@ -9387,6 +9436,9 @@ type ClientWithResponsesInterface interface { AIOnboardingNewConversationWithResponse(ctx context.Context, teamName string, body AIOnboardingNewConversationJSONRequestBody, reqEditors ...RequestEditorFn) (*AIOnboardingNewConversationResponse, error) + // GetTeamAnalyticsSaltWithResponse request + GetTeamAnalyticsSaltWithResponse(ctx context.Context, teamName TeamName, reqEditors ...RequestEditorFn) (*GetTeamAnalyticsSaltResponse, error) + // ListTeamAPIKeysWithResponse request ListTeamAPIKeysWithResponse(ctx context.Context, teamName TeamName, params *ListTeamAPIKeysParams, reqEditors ...RequestEditorFn) (*ListTeamAPIKeysResponse, error) @@ -11263,6 +11315,32 @@ func (r AIOnboardingNewConversationResponse) StatusCode() int { return 0 } +type GetTeamAnalyticsSaltResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *GetTeamAnalyticsSalt200Response + JSON401 *RequiresAuthentication + JSON403 *Forbidden + JSON404 *NotFound + JSON500 *InternalError +} + +// Status returns HTTPResponse.Status +func (r GetTeamAnalyticsSaltResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r GetTeamAnalyticsSaltResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + type ListTeamAPIKeysResponse struct { Body []byte HTTPResponse *http.Response @@ -13505,6 +13583,15 @@ func (c *ClientWithResponses) AIOnboardingNewConversationWithResponse(ctx contex return ParseAIOnboardingNewConversationResponse(rsp) } +// GetTeamAnalyticsSaltWithResponse request returning *GetTeamAnalyticsSaltResponse +func (c *ClientWithResponses) GetTeamAnalyticsSaltWithResponse(ctx context.Context, teamName TeamName, reqEditors ...RequestEditorFn) (*GetTeamAnalyticsSaltResponse, error) { + rsp, err := c.GetTeamAnalyticsSalt(ctx, teamName, reqEditors...) + if err != nil { + return nil, err + } + return ParseGetTeamAnalyticsSaltResponse(rsp) +} + // ListTeamAPIKeysWithResponse request returning *ListTeamAPIKeysResponse func (c *ClientWithResponses) ListTeamAPIKeysWithResponse(ctx context.Context, teamName TeamName, params *ListTeamAPIKeysParams, reqEditors ...RequestEditorFn) (*ListTeamAPIKeysResponse, error) { rsp, err := c.ListTeamAPIKeys(ctx, teamName, params, reqEditors...) @@ -17655,6 +17742,60 @@ func ParseAIOnboardingNewConversationResponse(rsp *http.Response) (*AIOnboarding return response, nil } +// ParseGetTeamAnalyticsSaltResponse parses an HTTP response from a GetTeamAnalyticsSaltWithResponse call +func ParseGetTeamAnalyticsSaltResponse(rsp *http.Response) (*GetTeamAnalyticsSaltResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &GetTeamAnalyticsSaltResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest GetTeamAnalyticsSalt200Response + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest RequiresAuthentication + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest Forbidden + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404: + var dest NotFound + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON404 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500: + var dest InternalError + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON500 = &dest + + } + + return response, nil +} + // ParseListTeamAPIKeysResponse parses an HTTP response from a ListTeamAPIKeysWithResponse call func ParseListTeamAPIKeysResponse(rsp *http.Response) (*ListTeamAPIKeysResponse, error) { bodyBytes, err := io.ReadAll(rsp.Body) diff --git a/models.gen.go b/models.gen.go index ec12e0e..5499ad7 100644 --- a/models.gen.go +++ b/models.gen.go @@ -895,6 +895,12 @@ type GetManagedDatabases200Response struct { Metadata ListMetadata `json:"metadata"` } +// GetTeamAnalyticsSalt200Response defines model for GetTeamAnalyticsSalt_200_response. +type GetTeamAnalyticsSalt200Response struct { + Salt interface{} `json:"salt"` + AdditionalProperties map[string]interface{} `json:"-"` +} + // GetTeamMemberships200Response defines model for GetTeamMemberships_200_response. type GetTeamMemberships200Response struct { Items []MembershipWithUser `json:"items"` @@ -3766,6 +3772,72 @@ func (a FunctionCallOutput) MarshalJSON() ([]byte, error) { return json.Marshal(object) } +// Getter for additional properties for GetTeamAnalyticsSalt200Response. Returns the specified +// element and whether it was found +func (a GetTeamAnalyticsSalt200Response) Get(fieldName string) (value interface{}, found bool) { + if a.AdditionalProperties != nil { + value, found = a.AdditionalProperties[fieldName] + } + return +} + +// Setter for additional properties for GetTeamAnalyticsSalt200Response +func (a *GetTeamAnalyticsSalt200Response) Set(fieldName string, value interface{}) { + if a.AdditionalProperties == nil { + a.AdditionalProperties = make(map[string]interface{}) + } + a.AdditionalProperties[fieldName] = value +} + +// Override default JSON handling for GetTeamAnalyticsSalt200Response to handle AdditionalProperties +func (a *GetTeamAnalyticsSalt200Response) UnmarshalJSON(b []byte) error { + object := make(map[string]json.RawMessage) + err := json.Unmarshal(b, &object) + if err != nil { + return err + } + + if raw, found := object["salt"]; found { + err = json.Unmarshal(raw, &a.Salt) + if err != nil { + return fmt.Errorf("error reading 'salt': %w", err) + } + delete(object, "salt") + } + + if len(object) != 0 { + a.AdditionalProperties = make(map[string]interface{}) + for fieldName, fieldBuf := range object { + var fieldVal interface{} + err := json.Unmarshal(fieldBuf, &fieldVal) + if err != nil { + return fmt.Errorf("error unmarshaling field %s: %w", fieldName, err) + } + a.AdditionalProperties[fieldName] = fieldVal + } + } + return nil +} + +// Override default JSON handling for GetTeamAnalyticsSalt200Response to handle AdditionalProperties +func (a GetTeamAnalyticsSalt200Response) MarshalJSON() ([]byte, error) { + var err error + object := make(map[string]json.RawMessage) + + object["salt"], err = json.Marshal(a.Salt) + if err != nil { + return nil, fmt.Errorf("error marshaling 'salt': %w", err) + } + + for fieldName, field := range a.AdditionalProperties { + object[fieldName], err = json.Marshal(field) + if err != nil { + return nil, fmt.Errorf("error marshaling '%s': %w", fieldName, err) + } + } + return json.Marshal(object) +} + // Getter for additional properties for LoginUserRequest. Returns the specified // element and whether it was found func (a LoginUserRequest) Get(fieldName string) (value interface{}, found bool) { diff --git a/spec.json b/spec.json index 62ba387..973e4e1 100644 --- a/spec.json +++ b/spec.json @@ -2375,6 +2375,41 @@ "tags" : [ "addons" ] } }, + "/teams/{team_name}/analytics-salt" : { + "get" : { + "description" : "Return the team's analytics salt, used by the CLI to pseudonymize cloud account identifiers before they are reported to CloudQuery analytics.", + "operationId" : "GetTeamAnalyticsSalt", + "parameters" : [ { + "$ref" : "#/components/parameters/team_name" + } ], + "responses" : { + "200" : { + "content" : { + "application/json" : { + "schema" : { + "$ref" : "#/components/schemas/GetTeamAnalyticsSalt_200_response" + } + } + }, + "description" : "The team's analytics salt." + }, + "401" : { + "$ref" : "#/components/responses/RequiresAuthentication" + }, + "403" : { + "$ref" : "#/components/responses/Forbidden" + }, + "404" : { + "$ref" : "#/components/responses/NotFound" + }, + "500" : { + "$ref" : "#/components/responses/InternalError" + } + }, + "tags" : [ "teams" ], + "x-internal" : true + } + }, "/teams/{team_name}/memberships" : { "delete" : { "description" : "Remove a user from the team", @@ -8253,6 +8288,16 @@ }, "required" : [ "items", "metadata" ] }, + "GetTeamAnalyticsSalt_200_response" : { + "additionalProperties" : { }, + "properties" : { + "salt" : { + "example" : "1a7c1cb2-2f47-4f8a-9a8b-4f9f4f8a9a8b", + "format" : "uuid" + } + }, + "required" : [ "salt" ] + }, "GetTeamMemberships_200_response" : { "properties" : { "items" : {