Support x-google-lro (#16028)

Author: nicdumz

mmv1/openapi_generate/parser.go

@@ -26,6 +26,7 @@ import (
 	"path/filepath"
 	"regexp"
 	"slices"
+	"strconv"
 	"strings"
 
 	"log"
@@ -92,12 +93,15 @@ func (parser Parser) WriteYaml(filePath string) {
 	doc, _ := loader.LoadFromFile(filePath)
 	_ = doc.Validate(ctx)
 
-	resourcePaths := findResources(doc)
+	resources := findResources(doc)
 	productPath := buildProduct(filePath, parser.Output, doc, header)
 
 	log.Printf("Generated product %+v/product.yaml", productPath)
-	for _, pathArray := range resourcePaths {
-		resource := buildResource(filePath, pathArray[0], pathArray[1], doc)
+	for name, resource := range resources {
+		if resource.create == nil {
+			continue
+		}
+		resource := buildResource(filePath, name, resource, doc)
 
 		// marshal method
 		var yamlContent bytes.Buffer
@@ -130,24 +134,69 @@ func (parser Parser) WriteYaml(filePath string) {
 	}
 }
 
-func findResources(doc *openapi3.T) [][]string {
-	var resourcePaths [][]string
+type resourceOp struct {
+	path  string
+	async bool
+}
 
-	pathMap := doc.Paths.Map()
-	for key, pathValue := range pathMap {
-		if pathValue.Post == nil {
-			continue
+type resource struct {
+	// nil if not defined
+	create, update, delete *resourceOp
+}
+
+func anyToBool(a any) bool {
+	switch v := a.(type) {
+	case bool:
+		return v
+	case string:
+		if b, err := strconv.ParseBool(v); err == nil {
+			return b
+		}
+		panic(fmt.Sprintf("cannot parse expected boolean value, found string: %q", v))
+	default:
+		panic(fmt.Sprintf("unexpected type: %T", v))
+	}
+}
+
+func buildOperation(resourcePath string, op *openapi3.Operation, prefix string) (string, *resourceOp) {
+	if op == nil {
+		return "", nil
+	}
+	if strings.HasPrefix(op.OperationID, prefix) {
+		resourceName := strings.Replace(op.OperationID, prefix, "", 1)
+		async := false
+		if a, ok := op.Extensions["x-google-lro"]; ok {
+			async = anyToBool(a)
+		}
+		return resourceName, &resourceOp{path: resourcePath, async: async}
+	}
+	return "", nil
+}
+
+func findResources(doc *openapi3.T) map[string]*resource {
+	resources := make(map[string]*resource)
+	getDefault := func(n string) *resource {
+		r, ok := resources[n]
+		if !ok {
+			r = &resource{}
+			resources[n] = r
 		}
+		return r
+	}
 
-		// Not very clever way of identifying create resource methods
-		if strings.HasPrefix(pathValue.Post.OperationID, "Create") {
-			resourcePath := key
-			resourceName := strings.Replace(pathValue.Post.OperationID, "Create", "", 1)
-			resourcePaths = append(resourcePaths, []string{resourcePath, resourceName})
+	for key, pathValue := range doc.Paths.Map() {
+		if name, op := buildOperation(key, pathValue.Post, "Create"); op != nil {
+			getDefault(name).create = op
+		}
+		if name, op := buildOperation(key, pathValue.Delete, "Delete"); op != nil {
+			getDefault(name).delete = op
+		}
+		if name, op := buildOperation(key, pathValue.Patch, "Update"); op != nil {
+			getDefault(name).update = op
 		}
 	}
 
-	return resourcePaths
+	return resources
 }
 
 func buildProduct(filePath, output string, root *openapi3.T, header []byte) string {
@@ -229,8 +278,9 @@ func stripVersion(path string) string {
 	return re.ReplaceAllString(path, "")
 }
 
-func buildResource(filePath, resourcePath, resourceName string, root *openapi3.T) api.Resource {
+func buildResource(filePath, resourceName string, in *resource, root *openapi3.T) api.Resource {
 	resource := api.Resource{}
+	resourcePath := in.create.path
 
 	parsedObjects := parseOpenApi(resourcePath, resourceName, root)
 
@@ -255,14 +305,25 @@ func buildResource(filePath, resourcePath, resourceName string, root *openapi3.T
 	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
+	if in.create.async {
+		resource.Async.Actions = append(resource.Async.Actions, "create")
+	}
 
-	if hasUpdate(resourceName, root) {
+	if in.update != nil {
 		resource.UpdateVerb = "PATCH"
 		resource.UpdateMask = true
+		if in.update.async {
+			resource.Async.Actions = append(resource.Async.Actions, "update")
+		}
 	} else {
 		resource.Immutable = true
 	}
+	if in.delete != nil && in.delete.async {
+		resource.Async.Actions = append(resource.Async.Actions, "delete")
+	}
 
 	example := r.Examples{}
 	example.Name = "name_of_example_file"
@@ -279,20 +340,6 @@ func buildResource(filePath, resourcePath, resourceName string, root *openapi3.T
 	return resource
 }
 
-func hasUpdate(resourceName string, root *openapi3.T) bool {
-	// Create and Update have different paths in the OpenAPI spec, so look
-	// through all paths to find one that matches the expected operation name
-	for _, pathValue := range root.Paths.Map() {
-		if pathValue.Patch == nil {
-			continue
-		}
-		if pathValue.Patch.OperationID == fmt.Sprintf("Update%s", resourceName) {
-			return true
-		}
-	}
-	return false
-}
-
 func parseOpenApi(resourcePath, resourceName string, root *openapi3.T) []any {
 	returnArray := []any{}
 	path := root.Paths.Find(resourcePath)

mmv1/openapi_generate/parser_test.go

@@ -14,10 +14,16 @@ func TestMapType(t *testing.T) {
 	_ = NewOpenapiParser("/fake", "/fake")
 	ctx := t.Context()
 	loader := &openapi3.Loader{Context: ctx, IsExternalRefsAllowed: true}
-	doc, _ := loader.LoadFromData(testData)
-	_ = doc.Validate(ctx)
+	doc, err := loader.LoadFromData(testData)
+	if err != nil {
+		t.Fatalf("Could not load data %s", err)
+	}
+	err = doc.Validate(ctx)
+	if err != nil {
+		t.Fatalf("Could not validate data %s", err)
+	}
 
-	petSchema := doc.Paths.Map()["/pets"].Post.Parameters[0].Value.Schema
+	petSchema := doc.Paths.Map()["/pets"].Post.RequestBody.Value.Content["application/json"].Schema
 	mmObject := WriteObject("pet", petSchema, propType(petSchema), false)
 	if mmObject.KeyName == "" || mmObject.Type != "Map" {
 		t.Error("Failed to parse map type")
@@ -26,3 +32,26 @@ func TestMapType(t *testing.T) {
 		t.Errorf("Expected 4 properties, found %d", len(mmObject.ValueType.Properties))
 	}
 }
+
+func TestFindResources(t *testing.T) {
+	ctx := t.Context()
+	loader := &openapi3.Loader{Context: ctx, IsExternalRefsAllowed: true}
+	doc, err := loader.LoadFromData(testData)
+	if err != nil {
+		t.Fatalf("Could not load data %s", err)
+	}
+	err = doc.Validate(ctx)
+	if err != nil {
+		t.Fatalf("Could not validate data %s", err)
+	}
+	res := findResources(doc)
+	if len(res) != 2 {
+		t.Fatalf("Expected 2 resources, found: %d", len(res))
+	}
+	if !res["Food"].create.async {
+		t.Error("Food resource is supposed to be detected as async and is not")
+	}
+	if res["Pet"].create.async {
+		t.Error("Pet resource is not supposed to be detected as async")
+	}
+}

mmv1/openapi_generate/test_data/test_api.yaml

@@ -41,18 +41,18 @@ paths:
                 $ref: "#/components/schemas/Error"
     post:
       summary: Create a pet
-      operationId: createPets
+      operationId: CreatePet
       tags:
         - pets
       parameters:
-        - name: pet
-          in: body
-          required: true
-          description: The pet to create
-          schema:
-            type: object
-            additionalProperties:
-              $ref: "#/components/schemas/Pet"
+      requestBody:
+        description: "Required. The pets being created"
+        content:
+          application/json:
+            schema:
+              type: object
+              additionalProperties:
+                $ref: "#/components/schemas/Pet"
       responses:
         201:
           description: Null response
@@ -88,9 +88,87 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/Error"
+  /foods:
+    get:
+      summary: List all foods
+      operationId: listFoods
+      tags:
+        - foods
+      parameters:
+        - name: limit
+          in: query
+          description: How many items to return at one time (max 100)
+          required: false
+          schema:
+            type: integer
+            format: int32
+      responses:
+        200:
+          description: An paged array of foods
+          headers:
+            x-next:
+              description: A link to the next page of responses
+              schema:
+                type: string
+          content:
+            application/json:    
+              schema:
+                $ref: "#/components/schemas/Foods"
+        default:
+          description: unexpected error
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Error"
+    post:
+      summary: Create a food
+      operationId: CreateFood
+      tags:
+        - foods
+      x-google-lro: true
+      requestBody:
+        description: "Required. The food being created"
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/Food"
+      responses:
+        default:
+          description: Successful operation
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/CreateFoodOperation"
+  /foods/{foodId}:
+    get:
+      summary: Info for a specific food
+      operationId: showFoodById
+      tags:
+        - foods
+      parameters:
+        - name: foodId
+          in: path
+          required: true
+          description: The id of the food to retrieve
+          schema:
+            type: string
+      responses:
+        200:
+          description: Expected response to a valid request
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Foods"
+        default:
+          description: unexpected error
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Error"
 components:
   schemas:
     Pet:
+      type: object
       required:
         - id
         - name
@@ -112,10 +190,19 @@ components:
       properties:
         name:
           type: string
+    Foods:
+      type: array
+      items:
+        $ref: "#/components/schemas/Food"
     Pets:
       type: array
       items:
         $ref: "#/components/schemas/Pet"
+    CreateFoodOperation:
+      type: object
+      properties:
+        name:
+          type: string
     Error:
       required:
         - code