Add support for objects with properties that omit the type field (#80)

* add negative test

* add fix for empty object type

* add changelog

Author: austinvalle

.changes/unreleased/ENHANCEMENTS-20231020-170209.yaml

@@ -0,0 +1,6 @@
+kind: ENHANCEMENTS
+body: Schemas that have the `properties` keyword defined with no type will now default
+  to `object`
+time: 2023-10-20T17:02:09.205328-04:00
+custom:
+  Issue: "79"

internal/cmd/testdata/edgecase/generator_config.yml

@@ -30,4 +30,8 @@ data_sources:
   map_test:
     read:
       path: /map_test
+      method: GET
+  obj_no_type:
+    read:
+      path: /obj_no_type
       method: GET

internal/cmd/testdata/edgecase/openapi_spec.yml

@@ -4,6 +4,24 @@ info:
   description: This is a fake API spec that was built to test some of the less common API schema structures and their mapping in the OpenAPI to Framework code generator
   version: 1.0.0
 paths:
+  /obj_no_type:
+    get:
+      summary: Test for objects that have no types!
+      responses:
+        "200":
+          description: OK
+          content:
+            application/json:
+              schema:
+                properties:
+                  string_prop:
+                    description: String inside an object!
+                    type: string
+                  nested_obj:
+                    properties:
+                      bool_prop:
+                        description: Bool inside a nested object!
+                        type: boolean
   /nested_collections:
     get:
       summary: Test for nested collections (list within a list, set within a list, map within a list)

internal/cmd/testdata/edgecase/provider_code_spec.json

@@ -120,6 +120,35 @@
 				]
 			}
 		},
+		{
+			"name": "obj_no_type",
+			"schema": {
+				"attributes": [
+					{
+						"name": "nested_obj",
+						"single_nested": {
+							"computed_optional_required": "computed",
+							"attributes": [
+								{
+									"name": "bool_prop",
+									"bool": {
+										"computed_optional_required": "computed",
+										"description": "Bool inside a nested object!"
+									}
+								}
+							]
+						}
+					},
+					{
+						"name": "string_prop",
+						"string": {
+							"computed_optional_required": "computed",
+							"description": "String inside an object!"
+						}
+					}
+				]
+			}
+		},
 		{
 			"name": "set_test",
 			"schema": {

internal/mapper/oas/build.go

@@ -224,6 +224,12 @@ func getMultiTypeSchema(proxyOne *base.SchemaProxy, proxyTwo *base.SchemaProxy)
 func retrieveType(schema *base.Schema) (string, *SchemaError) {
 	switch len(schema.Type) {
 	case 0:
+		// Properties are only valid applying to objects, it's possible tools might omit the type
+		// https://github.com/hashicorp/terraform-plugin-codegen-openapi/issues/79
+		if len(schema.Properties) > 0 {
+			return util.OAS_type_object, nil
+		}
+
 		return "", SchemaErrorFromProxy(errors.New("no 'type' array or supported allOf, oneOf, anyOf constraint - attribute cannot be created"), schema.ParentProxy)
 	case 1:
 		return schema.Type[0], nil

internal/mapper/oas/build_test.go

@@ -18,8 +18,6 @@ import (
 	high "github.com/pb33f/libopenapi/datamodel/high/v3"
 )
 
-// TODO: write tests for error paths (nullable types + build schema functions)
-
 func TestBuildSchemaFromRequest(t *testing.T) {
 	t.Parallel()
 
@@ -126,7 +124,6 @@ func TestBuildSchemaFromRequest(t *testing.T) {
 			}
 		})
 	}
-
 }
 
 func TestBuildSchemaFromRequest_Errors(t *testing.T) {
@@ -337,7 +334,6 @@ func TestBuildSchemaFromResponse(t *testing.T) {
 			}
 		})
 	}
-
 }
 
 func TestBuildSchemaFromResponse_Errors(t *testing.T) {
@@ -469,7 +465,6 @@ func TestBuildSchemaFromResponse_Errors(t *testing.T) {
 			}
 		})
 	}
-
 }
 
 func TestBuildSchema_MultiTypes(t *testing.T) {
@@ -1209,3 +1204,83 @@ func TestBuildSchema_Errors(t *testing.T) {
 		})
 	}
 }
+
+func TestBuildSchema_EdgeCases(t *testing.T) {
+	t.Parallel()
+
+	testCases := map[string]struct {
+		schemaProxy        *base.SchemaProxy
+		expectedAttributes attrmapper.ResourceAttributes
+	}{
+		"no type with properties - defaults to object": {
+			schemaProxy: base.CreateSchemaProxy(&base.Schema{
+				Type:     []string{},
+				Required: []string{"string", "object"},
+				Properties: map[string]*base.SchemaProxy{
+					"string": base.CreateSchemaProxy(&base.Schema{
+						Type:        []string{"string"},
+						Description: "hey there! I'm a string type, required.",
+					}),
+					"object": base.CreateSchemaProxy(&base.Schema{
+						Type:        []string{},
+						Required:    []string{"bool"},
+						Description: "hey there! I'm an object type, required.",
+						Properties: map[string]*base.SchemaProxy{
+							"bool": base.CreateSchemaProxy(&base.Schema{
+								Type:        []string{"boolean"},
+								Description: "hey there! I'm a bool type, required.",
+							}),
+						},
+					}),
+				},
+			}),
+			expectedAttributes: attrmapper.ResourceAttributes{
+				&attrmapper.ResourceSingleNestedAttribute{
+					Name: "object",
+					Attributes: attrmapper.ResourceAttributes{
+						&attrmapper.ResourceBoolAttribute{
+							Name: "bool",
+							BoolAttribute: resource.BoolAttribute{
+								ComputedOptionalRequired: schema.Required,
+								Description:              pointer("hey there! I'm a bool type, required."),
+							},
+						},
+					},
+					SingleNestedAttribute: resource.SingleNestedAttribute{
+						ComputedOptionalRequired: schema.Required,
+						Description:              pointer("hey there! I'm an object type, required."),
+					},
+				},
+				&attrmapper.ResourceStringAttribute{
+					Name: "string",
+					StringAttribute: resource.StringAttribute{
+						ComputedOptionalRequired: schema.Required,
+						Description:              pointer("hey there! I'm a string type, required."),
+					},
+				},
+			},
+		},
+	}
+
+	for name, testCase := range testCases {
+		name, testCase := name, testCase
+
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			schema, err := oas.BuildSchema(testCase.schemaProxy, oas.SchemaOpts{}, oas.GlobalSchemaOpts{})
+			if err != nil {
+				t.Fatalf("unexpected error: %s", err)
+			}
+
+			attributes, err := schema.BuildResourceAttributes()
+			if err != nil {
+				t.Fatalf("unexpected error: %s", err)
+			}
+
+			if diff := cmp.Diff(attributes, testCase.expectedAttributes); diff != "" {
+				t.Errorf("unexpected difference: %s", diff)
+			}
+		})
+	}
+}