Singleton support for autogen parser (GoogleCloudPlatform#16057)

Author: slevenick

mmv1/openapi_generate/parser.go

@@ -99,39 +99,49 @@ func (parser Parser) WriteYaml(filePath string) {
 	log.Printf("Generated product %+v/product.yaml", productPath)
 	for name, resource := range resources {
 		if resource.create == nil {
-			continue
-		}
-		resource := buildResource(filePath, name, resource, doc)
+			if resource.update == nil {
+				continue
+			}
+			singleton := buildSingleton(name, resource, doc)
 
-		// marshal method
-		var yamlContent bytes.Buffer
-		resourceOutPathMarshal := filepath.Join(productPath, fmt.Sprintf("%s.yaml", resource.Name))
-		encoder := yaml.NewEncoder(&yamlContent)
-		encoder.SetIndent(2)
+			parser.writeResource(singleton, productPath)
+		} else {
+			resource := buildResource(name, resource, doc)
 
-		err := encoder.Encode(&resource)
-		if err != nil {
-			log.Fatalf("Failed to encode: %v", err)
+			parser.writeResource(resource, productPath)
 		}
+	}
+}
 
-		f, err := os.Create(resourceOutPathMarshal)
-		if err != nil {
-			log.Fatalf("error creating resource file %v", err)
-		}
-		_, err = f.Write(header)
-		if err != nil {
-			log.Fatalf("error writing resource file header %v", err)
-		}
-		_, err = f.Write(yamlContent.Bytes())
-		if err != nil {
-			log.Fatalf("error writing resource file %v", err)
-		}
-		err = f.Close()
-		if err != nil {
-			log.Fatalf("error closing resource file %v", err)
-		}
-		log.Printf("Generated resource %s", resourceOutPathMarshal)
+func (parser Parser) writeResource(resource api.Resource, productPath string) {
+	// marshal method
+	var yamlContent bytes.Buffer
+	resourceOutPathMarshal := filepath.Join(productPath, fmt.Sprintf("%s.yaml", resource.Name))
+	encoder := yaml.NewEncoder(&yamlContent)
+	encoder.SetIndent(2)
+
+	err := encoder.Encode(&resource)
+	if err != nil {
+		log.Fatalf("Failed to encode: %v", err)
+	}
+
+	f, err := os.Create(resourceOutPathMarshal)
+	if err != nil {
+		log.Fatalf("error creating resource file %v", err)
+	}
+	_, err = f.Write(header)
+	if err != nil {
+		log.Fatalf("error writing resource file header %v", err)
+	}
+	_, err = f.Write(yamlContent.Bytes())
+	if err != nil {
+		log.Fatalf("error writing resource file %v", err)
+	}
+	err = f.Close()
+	if err != nil {
+		log.Fatalf("error closing resource file %v", err)
 	}
+	log.Printf("Generated resource %s", resourceOutPathMarshal)
 }
 
 type resourceOp struct {
@@ -278,11 +288,54 @@ func stripVersion(path string) string {
 	return re.ReplaceAllString(path, "")
 }
 
-func buildResource(filePath, resourceName string, in *resource, root *openapi3.T) api.Resource {
+func buildSingleton(resourceName string, in *resource, root *openapi3.T) api.Resource {
+	resource := api.Resource{}
+	resourcePath := in.update.path
+
+	op := root.Paths.Find(resourcePath).Patch
+	parsedObjects := parseOpenApi(resourcePath, resourceName, op)
+
+	parameters := parsedObjects[0].([]*api.Type)
+	properties := parsedObjects[1].([]*api.Type)
+
+	baseUrl := baseUrl(resourcePath)
+	selfLink := baseUrl
+
+	resource.Name = resourceName
+	resource.BaseUrl = baseUrl
+	resource.Parameters = parameters
+	resource.Properties = properties
+	resource.SelfLink = selfLink
+	resource.CreateUrl = fmt.Sprintf("%s=?updateMask=*", baseUrl)
+
+	resource.CreateVerb = "PATCH"
+
+	resource.UpdateVerb = "PATCH"
+	resource.UpdateMask = true
+	if in.update.async {
+		resource.AutogenAsync = true
+		async := api.NewAsync()
+		async.Operation.BaseUrl = "{{op_id}}"
+		async.Result.ResourceInsideResponse = true
+		// Clear the default, we will attach the right values below
+		async.Actions = nil
+		resource.Async = async
+		resource.Async.Actions = append(resource.Async.Actions, "update")
+	}
+
+	resource.ExcludeDelete = true
+
+	resource = attachStandardFunctionality(resource)
+
+	return resource
+}
+
+func buildResource(resourceName string, in *resource, root *openapi3.T) api.Resource {
 	resource := api.Resource{}
 	resourcePath := in.create.path
 
-	parsedObjects := parseOpenApi(resourcePath, resourceName, root)
+	op := root.Paths.Find(resourcePath).Post
+	parsedObjects := parseOpenApi(resourcePath, resourceName, op)
 
 	parameters := parsedObjects[0].([]*api.Type)
 	properties := parsedObjects[1].([]*api.Type)
@@ -296,10 +349,7 @@ func buildResource(filePath, resourceName string, in *resource, root *openapi3.T
 	resource.Parameters = parameters
 	resource.Properties = properties
 	resource.SelfLink = selfLink
-	resource.IdFormat = selfLink
-	resource.ImportFormat = []string{selfLink}
 	resource.CreateUrl = fmt.Sprintf("%s?%s={{%s}}", baseUrl, queryParam, google.Underscore(queryParam))
-	resource.Description = "Description"
 
 	resource.AutogenAsync = true
 	async := api.NewAsync()
@@ -325,28 +375,42 @@ func buildResource(filePath, resourceName string, in *resource, root *openapi3.T
 		resource.Async.Actions = append(resource.Async.Actions, "delete")
 	}
 
+	resource = attachStandardFunctionality(resource)
+
+	return resource
+}
+
+// Standard functionality between regular and singleton resources
+func attachStandardFunctionality(resource api.Resource) api.Resource {
+	resource.Description = "Description"
+
+	resource.IdFormat = resource.SelfLink
+	resource.ImportFormat = []string{resource.SelfLink}
+
 	example := r.Examples{}
 	example.Name = "name_of_example_file"
 	example.PrimaryResourceId = "example"
 	example.Vars = map[string]string{"resource_name": "test-resource"}
 
 	resource.Examples = []*r.Examples{&example}
 
-	resourceNameBytes := []byte(resourceName)
+	resourceNameBytes := []byte(resource.Name)
 	// Write the status as an encoded string to flag when a YAML file has been
 	// copy and pasted without actually using this tool
 	resource.AutogenStatus = base64.StdEncoding.EncodeToString(resourceNameBytes)
 
 	return resource
 }
 
-func parseOpenApi(resourcePath, resourceName string, root *openapi3.T) []any {
+func parseOpenApi(resourcePath, resourceName string, op *openapi3.Operation) []any {
+	if op == nil {
+		log.Fatalf("error parsing nil OpenAPI operation for resource: %v", resourceName)
+	}
 	returnArray := []any{}
-	path := root.Paths.Find(resourcePath)
 
 	parameters := []*api.Type{}
 	var idParam string
-	for _, param := range path.Post.Parameters {
+	for _, param := range op.Parameters {
 		if strings.Contains(strings.ToLower(param.Value.Name), strings.ToLower(resourceName)) {
 			idParam = param.Value.Name
 		}
@@ -357,7 +421,7 @@ func parseOpenApi(resourcePath, resourceName string, root *openapi3.T) []any {
 		}
 		paramObj.Description = trimDescription(description)
 
-		if param.Value.Name == "requestId" || param.Value.Name == "validateOnly" || paramObj.Name == "" {
+		if param.Value.Name == "requestId" || param.Value.Name == "validateOnly" || paramObj.Name == "" || paramObj.Name == "updateMask" {
 			continue
 		}
 
@@ -366,7 +430,7 @@ func parseOpenApi(resourcePath, resourceName string, root *openapi3.T) []any {
 		parameters = append(parameters, &paramObj)
 	}
 
-	properties := buildProperties(path.Post.RequestBody.Value.Content["application/json"].Schema.Value.Properties, path.Post.RequestBody.Value.Content["application/json"].Schema.Value.Required)
+	properties := buildProperties(op.RequestBody.Value.Content["application/json"].Schema.Value.Properties, op.RequestBody.Value.Content["application/json"].Schema.Value.Required)
 
 	returnArray = append(returnArray, parameters)
 	returnArray = append(returnArray, properties)

mmv1/openapi_generate/parser_test.go

@@ -45,7 +45,7 @@ func TestFindResources(t *testing.T) {
 		t.Fatalf("Could not validate data %s", err)
 	}
 	res := findResources(doc)
-	if len(res) != 2 {
+	if len(res) != 3 {
 		t.Fatalf("Expected 2 resources, found: %d", len(res))
 	}
 	if !res["Food"].create.async {
@@ -54,4 +54,7 @@ func TestFindResources(t *testing.T) {
 	if res["Pet"].create.async {
 		t.Error("Pet resource is not supposed to be detected as async")
 	}
+	if res["Breeds"].update == nil {
+		t.Error("Singleton update should be found")
+	}
 }

mmv1/openapi_generate/test_data/test_api.yaml

@@ -165,6 +165,57 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/Error"
+  /animals/{animalId}/breeds:
+    get:
+      summary: Info for a specific breed
+      operationId: showBreeds
+      tags:
+        - breed
+      parameters:
+        - name: animalId
+          in: path
+          required: true
+          description: The id of the animal breeds to retrieve
+          schema:
+            type: string
+      responses:
+        200:
+          description: Expected response to a valid request
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Breeds"
+        default:
+          description: unexpected error
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Error"
+    patch:
+      summary: Update breeds
+      operationId: UpdateBreeds
+      tags:
+        - breeds
+      parameters:
+        - name: animalId
+          in: path
+          required: true
+          description: The id of the animal breeds to update
+          schema:
+            type: string
+      requestBody:
+        description: "Required. The breed being updated"
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/Breeds"
+      responses:
+        default:
+          description: Result
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Breeds"
 components:
   schemas:
     Pet:
@@ -190,10 +241,20 @@ components:
       properties:
         name:
           type: string
+    Breed:
+      required:
+        - name
+      properties:
+        name:
+          type: string
     Foods:
       type: array
       items:
         $ref: "#/components/schemas/Food"
+    Breeds:
+      type: array
+      items:
+        $ref: "#/components/schemas/Breed"
     Pets:
       type: array
       items: