make openapi property order idempotent.

example/bookstore/v1/bookstore.proto

@@ -61,12 +61,6 @@ service Bookstore {
 
 // A Book resource.
 message Book {
-  // Field for edition.
-  int32 edition = 4;
-
-  // Field for isbn.
-  string isbn = 1;
-
   // Field for price.
   float price = 2;
 
@@ -78,6 +72,12 @@ message Book {
 
   // Field for id.
   string id = 10001;
+
+  // Field for edition.
+  int32 edition = 4;
+
+  // Field for isbn.
+  string isbn = 1;
 }
 
 // A Create request for a  Book resource.

example/bookstore/v1/bookstore.swagger.json

@@ -298,15 +298,6 @@
     "v1Book": {
       "type": "object",
       "properties": {
-        "edition": {
-          "type": "integer",
-          "format": "int32",
-          "description": "Field for edition."
-        },
-        "isbn": {
-          "type": "string",
-          "description": "Field for isbn."
-        },
         "price": {
           "type": "number",
           "format": "float",
@@ -323,6 +314,15 @@
         "id": {
           "type": "string",
           "description": "Field for id."
+        },
+        "edition": {
+          "type": "integer",
+          "format": "int32",
+          "description": "Field for edition."
+        },
+        "isbn": {
+          "type": "string",
+          "description": "Field for isbn."
         }
       },
       "description": "A Book resource."

example/bookstore/v1/bookstore_openapi.json

@@ -110,9 +110,9 @@
     "Book": {
       "type": "object",
       "required": [
+        "published",
         "isbn",
-        "price",
-        "published"
+        "price"
       ],
       "properties": {
         "edition": {

writer/openapi/openapi.go

@@ -19,7 +19,7 @@ func init() {
 
 func WriteServiceToOpenAPI(ps *parser.ParsedService) ([]byte, error) {
 	openAPI, err := convertToOpenAPI(ps)
-	if(err != nil) {
+	if err != nil {
 		return nil, err
 	}
 
@@ -35,10 +35,10 @@ func convertToOpenAPI(service *parser.ParsedService) (*OpenAPI, error) {
 	definitions := Definitions{}
 	for _, r := range service.ResourceByType {
 		d, err := resourceToSchema(r)
-		if(err != nil) {
+		if err != nil {
 			return nil, err
 		}
-		definitions[r.Kind] = d;
+		definitions[r.Kind] = d
 		schemaRef := fmt.Sprintf("#/definitions/%v", r.Kind)
 		if r.Methods.List != nil {
 			log.Printf("resource plural: %s", r.Plural)
@@ -166,19 +166,19 @@ func convertToOpenAPI(service *parser.ParsedService) (*OpenAPI, error) {
 func resourceToSchema(r *parser.ParsedResource) (Schema, error) {
 	properties := Properties{}
 	required := []string{}
-	for name, p := range r.Properties {
-		t, err := openAPIType(p)
-		if(err != nil ) {
+	for _, f := range r.GetFieldsSortedByNumber() {
+		t, err := openAPIType(f)
+		if err != nil {
 			return Schema{}, err
 		}
-		properties[name] = Schema{
+		properties[f.Name] = Schema{
 			Type:         t.openapi_type,
 			Format:       t.openapi_format,
-			XTerraformID: name == constants.FIELD_ID_NAME,
-			ReadOnly:     p.ReadOnly,
+			XTerraformID: f.Name == constants.FIELD_ID_NAME,
+			ReadOnly:     f.ReadOnly,
 		}
-		if p.Required {
-			required = append(required, name)
+		if f.Required {
+			required = append(required, f.Name)
 		}
 	}
 	return Schema{

writer/openapi/utils.go

@@ -3,41 +3,42 @@ package openapi
 import (
 	"fmt"
 
+	"github.com/aep-dev/aepc/parser"
 	"github.com/aep-dev/aepc/schema"
 )
 
 type TypeInfo struct {
-	 openapi_type string
-	 openapi_format string
+	openapi_type   string
+	openapi_format string
 }
 
-func openAPIType(p *schema.Property) (TypeInfo, error) {
-	t := "";
-	f := "";
+func openAPIType(p *parser.ParsedProperty) (TypeInfo, error) {
+	t := ""
+	f := ""
 
-	switch(p.Type) {
-		case schema.Type_STRING:
-			t = "string"
-		case schema.Type_DOUBLE:
-			t = "number"
-			f = "double"
-		case schema.Type_FLOAT:
-			t = "number"
-			f = "float"
-		case schema.Type_INT32:
-			t = "integer"
-			f = "int32"
-		case schema.Type_INT64:
-			t = "integer"
-			f = "int64"
-		case schema.Type_BOOLEAN:
-			t = "boolean"
-		default:
-			return TypeInfo{}, fmt.Errorf("%s does not have openapi type support", p.Type)
+	switch p.Type {
+	case schema.Type_STRING:
+		t = "string"
+	case schema.Type_DOUBLE:
+		t = "number"
+		f = "double"
+	case schema.Type_FLOAT:
+		t = "number"
+		f = "float"
+	case schema.Type_INT32:
+		t = "integer"
+		f = "int32"
+	case schema.Type_INT64:
+		t = "integer"
+		f = "int64"
+	case schema.Type_BOOLEAN:
+		t = "boolean"
+	default:
+		return TypeInfo{}, fmt.Errorf("%s does not have openapi type support", p.Type)
 	}
 
 	return TypeInfo{
-		openapi_type: t,
+		openapi_type:   t,
 		openapi_format: f,
 	}, nil
-}
+}