feat: BatchCheck for go-sdk

Makefile

@@ -1,6 +1,6 @@
 # Main config
 OPENFGA_DOCKER_TAG = v1.8.1
-OPEN_API_REF ?= 0bb89b73d6550b627f79c53b4b97dec1ee3fe0ad
+OPEN_API_REF ?= c14fb4b3d4b44836436cf1bab13e21b322e38ae9
 OPEN_API_URL = https://raw.githubusercontent.com/openfga/api/${OPEN_API_REF}/docs/openapiv2/apidocs.swagger.json
 OPENAPI_GENERATOR_CLI_DOCKER_TAG = v6.4.0
 NODE_DOCKER_TAG = 20-alpine

config/clients/go/template/client/client.mustache

@@ -337,17 +337,17 @@ type SdkClient interface {
 	CheckExecute(request SdkClientCheckRequestInterface) (*ClientCheckResponse, error)
 
 	/*
-	 * BatchCheck Run a set of [checks](#check). Batch Check will return `allowed: false` if it encounters an error, and will return the error in the body.
+	 * ClientBatchCheck Run a set of [checks](#check). Batch Check will return `allowed: false` if it encounters an error, and will return the error in the body.
 	 * @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 	 * @return SdkClientBatchCheckRequestInterface
 	 */
-	BatchCheck(ctx _context.Context) SdkClientBatchCheckRequestInterface
+	ClientBatchCheck(ctx _context.Context) SdkClientBatchCheckClientRequestInterface
 
 	/*
-	 * BatchCheckExecute executes the BatchCheck request
+	 * ClientBatchCheckExecute executes the BatchCheck request
 	 * @return *ClientBatchCheckResponse
 	 */
-	BatchCheckExecute(request SdkClientBatchCheckRequestInterface) (*ClientBatchCheckResponse, error)
+	ClientBatchCheckExecute(request SdkClientBatchCheckClientRequestInterface) (*ClientBatchCheckClientResponse, error)
 
 	/*
 	 * Expand Expands the relationships in userset tree format.
@@ -1927,93 +1927,93 @@ func (client *{{appShortName}}Client) CheckExecute(request SdkClientCheckRequest
 	return &ClientCheckResponse{CheckResponse: data, HttpResponse: httpResponse}, err
 }
 
-/// BatchCheck
+/// ClientBatchCheck
 
-type SdkClientBatchCheckRequest struct {
+type SdkClientBatchCheckClientRequest struct {
 	ctx    _context.Context
 	Client *{{appShortName}}Client
 
-	body    *ClientBatchCheckBody
-	options *ClientBatchCheckOptions
+	body    *ClientBatchCheckClientBody
+	options *ClientBatchCheckClientOptions
 }
 
-type SdkClientBatchCheckRequestInterface interface {
-	Options(options ClientBatchCheckOptions) SdkClientBatchCheckRequestInterface
-	Body(body ClientBatchCheckBody) SdkClientBatchCheckRequestInterface
-	Execute() (*ClientBatchCheckResponse, error)
+type SdkClientBatchCheckClientRequestInterface interface {
+	Options(options ClientBatchCheckClientOptions) SdkClientBatchCheckClientRequestInterface
+	Body(body ClientBatchCheckClientBody) SdkClientBatchCheckClientRequestInterface
+	Execute() (*ClientBatchCheckClientResponse, error)
 	GetAuthorizationModelIdOverride() *string
 	GetStoreIdOverride() *string
 
 	GetContext() _context.Context
-	GetBody() *ClientBatchCheckBody
-	GetOptions() *ClientBatchCheckOptions
+	GetBody() *ClientBatchCheckClientBody
+	GetOptions() *ClientBatchCheckClientOptions
 }
 
-type ClientBatchCheckBody = []ClientCheckRequest
+type ClientBatchCheckClientBody = []ClientCheckRequest
 
-type ClientBatchCheckOptions struct {
+type ClientBatchCheckClientOptions struct {
 	AuthorizationModelId *string `json:"authorization_model_id,omitempty"`
 	StoreId              *string `json:"store_id,omitempty"`
 	MaxParallelRequests  *int32  `json:"max_parallel_requests,omitempty"`
 	Consistency       *fgaSdk.ConsistencyPreference `json:"consistency,omitempty"`
 }
 
-type ClientBatchCheckSingleResponse struct {
+type ClientBatchCheckClientSingleResponse struct {
 	ClientCheckResponse
 	Request ClientCheckRequest
 	Error   error
 }
 
-type ClientBatchCheckResponse = []ClientBatchCheckSingleResponse
+type ClientBatchCheckClientResponse = []ClientBatchCheckClientSingleResponse
 
-func (client *{{appShortName}}Client) BatchCheck(ctx _context.Context) SdkClientBatchCheckRequestInterface {
-	return &SdkClientBatchCheckRequest{
+func (client *{{appShortName}}Client) ClientBatchCheck(ctx _context.Context) SdkClientBatchCheckClientRequestInterface {
+	return &SdkClientBatchCheckClientRequest{
 		Client: client,
 		ctx:    ctx,
 	}
 }
 
-func (request *SdkClientBatchCheckRequest) Options(options ClientBatchCheckOptions) SdkClientBatchCheckRequestInterface {
+func (request *SdkClientBatchCheckClientRequest) Options(options ClientBatchCheckClientOptions) SdkClientBatchCheckClientRequestInterface {
 	request.options = &options
 	return request
 }
 
-func (request *SdkClientBatchCheckRequest) GetAuthorizationModelIdOverride() *string {
+func (request *SdkClientBatchCheckClientRequest) GetAuthorizationModelIdOverride() *string {
 	if request.options == nil {
 		return nil
 	}
 	return request.options.AuthorizationModelId
 }
 
-func (request *SdkClientBatchCheckRequest) GetStoreIdOverride() *string {
+func (request *SdkClientBatchCheckClientRequest) GetStoreIdOverride() *string {
 	if request.options == nil {
 		return nil
 	}
 	return request.options.StoreId
 }
 
-func (request *SdkClientBatchCheckRequest) Body(body ClientBatchCheckBody) SdkClientBatchCheckRequestInterface {
+func (request *SdkClientBatchCheckClientRequest) Body(body ClientBatchCheckClientBody) SdkClientBatchCheckClientRequestInterface {
 	request.body = &body
 	return request
 }
 
-func (request *SdkClientBatchCheckRequest) Execute() (*ClientBatchCheckResponse, error) {
-	return request.Client.BatchCheckExecute(request)
+func (request *SdkClientBatchCheckClientRequest) Execute() (*ClientBatchCheckClientResponse, error) {
+	return request.Client.ClientBatchCheckExecute(request)
 }
 
-func (request *SdkClientBatchCheckRequest) GetContext() _context.Context {
+func (request *SdkClientBatchCheckClientRequest) GetContext() _context.Context {
 	return request.ctx
 }
 
-func (request *SdkClientBatchCheckRequest) GetBody() *ClientBatchCheckBody {
+func (request *SdkClientBatchCheckClientRequest) GetBody() *ClientBatchCheckClientBody {
 	return request.body
 }
 
-func (request *SdkClientBatchCheckRequest) GetOptions() *ClientBatchCheckOptions {
+func (request *SdkClientBatchCheckClientRequest) GetOptions() *ClientBatchCheckClientOptions {
     return request.options
 }
 
-func (client *{{appShortName}}Client) BatchCheckExecute(request SdkClientBatchCheckRequestInterface) (*ClientBatchCheckResponse, error) {
+func (client *{{appShortName}}Client) ClientBatchCheckExecute(request SdkClientBatchCheckClientRequestInterface) (*ClientBatchCheckClientResponse, error) {
 	group, ctx := errgroup.WithContext(request.GetContext())
 	var maxParallelReqs int
 	if request.GetOptions() == nil || request.GetOptions().MaxParallelRequests == nil {
@@ -2023,7 +2023,7 @@ func (client *{{appShortName}}Client) BatchCheckExecute(request SdkClientBatchCh
 	}
 	group.SetLimit(maxParallelReqs)
 	var numOfChecks = len(*request.GetBody())
-	response := make(ClientBatchCheckResponse, numOfChecks)
+	response := make(ClientBatchCheckClientResponse, numOfChecks)
 	authorizationModelId, err := client.getAuthorizationModelId(request.GetAuthorizationModelIdOverride())
 	if err != nil {
 		return nil, err
@@ -2057,7 +2057,7 @@ func (client *{{appShortName}}Client) BatchCheckExecute(request SdkClientBatchCh
 				return err
 			}
 
-			response[index] = ClientBatchCheckSingleResponse{
+			response[index] = ClientBatchCheckClientSingleResponse{
 				Request:             checkBody,
 				ClientCheckResponse: *singleResponse,
 				Error:               err,
@@ -2400,7 +2400,7 @@ func (client *{{appShortName}}Client) ListRelationsExecute(request SdkClientList
 		return nil, fmt.Errorf("ListRelations - expected len(Relations) > 0")
 	}
 
-	batchRequestBody := ClientBatchCheckBody{}
+	batchRequestBody := ClientBatchCheckClientBody{}
 	for index := 0; index < len(request.GetBody().Relations); index++ {
 		batchRequestBody = append(batchRequestBody, ClientCheckRequest{
 			User:             request.GetBody().User,
@@ -2419,7 +2419,7 @@ func (client *{{appShortName}}Client) ListRelationsExecute(request SdkClientList
 		return nil, err
 	}
 
-	options := &ClientBatchCheckOptions{
+	options := &ClientBatchCheckClientOptions{
 		AuthorizationModelId: authorizationModelId,
 		StoreId:              storeId,
 	}
@@ -2428,7 +2428,7 @@ func (client *{{appShortName}}Client) ListRelationsExecute(request SdkClientList
 		options.MaxParallelRequests = request.GetOptions().MaxParallelRequests
 	}
 
-	batchResponse, err := client.BatchCheckExecute(&SdkClientBatchCheckRequest{
+	batchResponse, err := client.ClientBatchCheckExecute(&SdkClientBatchCheckClientRequest{
 		ctx:     request.GetContext(),
 		Client:  client,
 		body:    &batchRequestBody,

config/clients/go/template/client/client_test.mustache

@@ -2034,15 +2034,15 @@ func Test{{appShortName}}Client(t *testing.T) {
 		}
 	})
 
-	t.Run("BatchCheck", func(t *testing.T) {
+	t.Run("ClientBatchCheck", func(t *testing.T) {
 		test := TestDefinition{
 			Name:           "Check",
 			JsonResponse:   `{"allowed":true, "resolution":""}`,
 			ResponseStatus: http.StatusOK,
 			Method:         http.MethodPost,
 			RequestPath:    "check",
 		}
-		requestBody := ClientBatchCheckBody{ {
+		requestBody := ClientBatchCheckClientBody{ {
 			User:     "user:81684243-9356-4421-8fbf-a4f8d36aa31b",
 			Relation: "viewer",
 			Object:   "document:0192ab2a-d83f-756d-9397-c5ed9f3cb69a",
@@ -2072,7 +2072,7 @@ func Test{{appShortName}}Client(t *testing.T) {
 
 		const authModelId = "01GAHCE4YVKPQEKZQHT2R89MQV"
 
-		options := ClientBatchCheckOptions{
+		options := ClientBatchCheckClientOptions{
 			AuthorizationModelId: {{packageName}}.PtrString(authModelId),
 			MaxParallelRequests:  {{packageName}}.PtrInt32(5),
 		}
@@ -2094,7 +2094,7 @@ func Test{{appShortName}}Client(t *testing.T) {
 			},
 		)
 
-		got, err := fgaClient.BatchCheck(context.Background()).Body(requestBody).Options(options).Execute()
+		got, err := fgaClient.ClientBatchCheck(context.Background()).Body(requestBody).Options(options).Execute()
 		if err != nil {
 			t.Fatalf("%v", err)
 		}
@@ -2125,28 +2125,28 @@ func Test{{appShortName}}Client(t *testing.T) {
 				t.Fatalf("{{appShortName}}Client.%v() = %v, want %v", test.Name, string(responseJson), test.JsonResponse)
 			}
 		}
-		// BatchCheck without options should work
-		_, err = fgaClient.BatchCheck(context.Background()).Body(requestBody).Execute()
+		// ClientBatchCheck without options should work
+		_, err = fgaClient.ClientBatchCheck(context.Background()).Body(requestBody).Execute()
 		if err != nil {
 			t.Fatalf("%v", err)
 		}
 
 		httpmock.ZeroCallCounters()
-		// BatchCheck with invalid auth model ID should fail
-		badOptions := ClientBatchCheckOptions{
+		// ClientBatchCheck with invalid auth model ID should fail
+		badOptions := ClientBatchCheckClientOptions{
 			AuthorizationModelId: {{packageName}}.PtrString("INVALID"),
 			MaxParallelRequests:  {{packageName}}.PtrInt32(5),
 		}
-		_, err = fgaClient.BatchCheck(context.Background()).Body(requestBody).Options(badOptions).Execute()
+		_, err = fgaClient.ClientBatchCheck(context.Background()).Body(requestBody).Options(badOptions).Execute()
 		if err == nil {
 			t.Fatalf("Expect error with invalid auth model id but there is none")
 		}
 		// invalid store ID should fail
-		badStoreOptions := ClientBatchCheckOptions{
+		badStoreOptions := ClientBatchCheckClientOptions{
 			StoreId:             {{packageName}}.PtrString("INVALID"),
 			MaxParallelRequests: {{packageName}}.PtrInt32(5),
 		}
-		_, err = fgaClient.BatchCheck(context.Background()).Body(requestBody).Options(badStoreOptions).Execute()
+		_, err = fgaClient.ClientBatchCheck(context.Background()).Body(requestBody).Options(badStoreOptions).Execute()
 		if err == nil {
 			t.Fatalf("Expect error with invalid auth model id but there is none")
 		}
@@ -2161,14 +2161,14 @@ func Test{{appShortName}}Client(t *testing.T) {
 				return httpmock.NewStringResponse(http.StatusUnauthorized, ""), nil
 			},
 		)
-		// BatchCheck with invalid auth should fail
-		_, err = fgaClient.BatchCheck(context.Background()).Body(requestBody).Options(options).Execute()
+		// ClientBatchCheck with invalid auth should fail
+		_, err = fgaClient.ClientBatchCheck(context.Background()).Body(requestBody).Options(options).Execute()
 		if err == nil {
 			t.Fatalf("Expect error with invalid auth but there is none")
 		}
 
 		// store should be overridden
-		storeOverrideOptions := ClientBatchCheckOptions{
+		storeOverrideOptions := ClientBatchCheckClientOptions{
 			StoreId:             {{packageName}}.PtrString("7777HCE4YVKPQEKZQHT2R89MQV"),
 			MaxParallelRequests: {{packageName}}.PtrInt32(5),
 		}
@@ -2182,21 +2182,21 @@ func Test{{appShortName}}Client(t *testing.T) {
 			},
 		)
 
-		_, err = fgaClient.BatchCheck(context.Background()).Body(requestBody).Options(storeOverrideOptions).Execute()
+		_, err = fgaClient.ClientBatchCheck(context.Background()).Body(requestBody).Options(storeOverrideOptions).Execute()
 		if err != nil {
 			t.Fatalf("%v", err)
 		}
 	})
 
-	t.Run("BatchCheckWithConsistency", func(t *testing.T) {
+	t.Run("ClientBatchCheckWithConsistency", func(t *testing.T) {
 		test := TestDefinition{
 			Name:           "Check",
 			JsonResponse:   `{"allowed":true, "resolution":""}`,
 			ResponseStatus: http.StatusOK,
 			Method:         http.MethodPost,
 			RequestPath:    "check",
 		}
-		requestBody := ClientBatchCheckBody{ {
+		requestBody := ClientBatchCheckClientBody{ {
 			User:     "user:81684243-9356-4421-8fbf-a4f8d36aa31b",
 			Relation: "viewer",
 			Object:   "document:0192ab2a-d83f-756d-9397-c5ed9f3cb69a",
@@ -2226,7 +2226,7 @@ func Test{{appShortName}}Client(t *testing.T) {
 
 		const authModelId = "01GAHCE4YVKPQEKZQHT2R89MQV"
 
-		options := ClientBatchCheckOptions{
+		options := ClientBatchCheckClientOptions{
 			AuthorizationModelId: {{packageName}}.PtrString(authModelId),
 			MaxParallelRequests:  {{packageName}}.PtrInt32(5),
 			Consistency:          {{packageName}}.CONSISTENCYPREFERENCE_HIGHER_CONSISTENCY.Ptr(),
@@ -2250,7 +2250,7 @@ func Test{{appShortName}}Client(t *testing.T) {
 			},
 		)
 
-		checks, err := fgaClient.BatchCheck(context.Background()).Body(requestBody).Options(options).Execute()
+		checks, err := fgaClient.ClientBatchCheck(context.Background()).Body(requestBody).Options(options).Execute()
 		if err != nil {
 			t.Fatalf("%v", err)
 		}