Add tests utilizing anyOf and oneOf with allOf

Signed-off-by: Alan Cha <[email protected]>

Author: Alan-Cha

packages/openapi-to-graphql/lib/preprocessor.js

@@ -991,6 +991,28 @@ function resolveAllOf(
         )
       }
 
+      // Collapse oneOf if applicable
+      if ('oneOf' in resolvedSchema) {
+        if (!('oneOf' in collapsedSchema)) {
+          collapsedSchema.oneOf = []
+        }
+
+        resolvedSchema.oneOf.forEach(oneOfProperty => {
+          collapsedSchema.oneOf.push(oneOfProperty)
+        })
+      }
+
+      // Collapse anyOf if applicable
+      if ('anyOf' in resolvedSchema) {
+        if (!('anyOf' in collapsedSchema)) {
+          collapsedSchema.anyOf = []
+        }
+
+        resolvedSchema.anyOf.forEach(anyOfProperty => {
+          collapsedSchema.anyOf.push(anyOfProperty)
+        })
+      }
+
       // Collapse required if applicable
       if ('required' in resolvedSchema) {
         if (!('required' in collapsedSchema)) {
@@ -1059,6 +1081,11 @@ function getMemberSchemaData(
   return result
 }
 
+/**
+ * Check to see if there are cases of nested oneOf fields in the member schemas
+ *
+ * We currently cannot handle complex cases of oneOf and anyOf
+ */
 function hasNestedOneOfUsage(
   collapsedSchema: SchemaObject,
   oas: Oas3
@@ -1082,6 +1109,11 @@ function hasNestedOneOfUsage(
   )
 }
 
+/**
+ * Check to see if there are cases of nested anyOf fields in the member schemas
+ *
+ * We currently cannot handle complex cases of oneOf and anyOf
+ */
 function hasNestedAnyOfUsage(
   collapsedSchema: SchemaObject,
   oas: Oas3
@@ -1105,6 +1137,12 @@ function hasNestedAnyOfUsage(
   )
 }
 
+/**
+ * Create a data definition for anyOf is applicable
+ *
+ * anyOf should resolve into an object that contains the superset of all
+ * properties from the member schemas
+ */
 function createDataDefFromAnyOf(
   saneName: string,
   saneInputName: string,
@@ -1138,6 +1176,12 @@ function createDataDefFromAnyOf(
         } = {}
         const incompatibleProperties = new Set<string>()
 
+        /**
+         * TODO: Check for consistent properties across all member schemas and
+         * make them into non-nullable properties by manipulating the
+         * required field
+         */
+
         if (typeof collapsedSchema.properties === 'object') {
           Object.keys(collapsedSchema.properties).forEach(propertyName => {
             allProperties[propertyName] = [
@@ -1211,9 +1255,9 @@ function createDataDefFromAnyOf(
           })
         })
 
-        //  Add in incompatible properties
+        // Add in incompatible properties
         incompatibleProperties.forEach(propertyName => {
-          //  TODO: add description
+          // TODO: add description
           def.subDefinitions[propertyName] = {
             targetGraphQLType: 'json'
           }

packages/openapi-to-graphql/lib/preprocessor.js.map

@@ -14,7 +14,7 @@ import { Options } from '../lib/types/options'
 import { startServer, stopServer } from './example_api_server'
 
 const oas = require('./fixtures/example_oas4.json')
-const PORT = 3004
+const PORT = 3007
 // Update PORT for this test case:
 oas.servers[0].variables.port.default = String(PORT)
 
@@ -384,6 +384,93 @@ test('anyOf test with extraneous member schemas with external type\n\nEquivalent
   })
 })
 
+/**
+ * anyOf contains two member schemas and allOf contains an additional one
+ *
+ * None of the schemas have conflicts so all three should be utilized
+ */
+test('Basic anyOf test with allOf\n\nEquivalent to GET /anyOf10', () => {
+  return graphql(createdSchema, anyOfQuery).then(result => {
+    expect(
+      result.data['__schema'].queryType.fields.find(field => {
+        return field.name === 'anyOf10'
+      })
+    ).toEqual({
+      name: 'anyOf10',
+      description: 'Basic anyOf test with allOf\n\nEquivalent to GET /anyOf10',
+      type: {
+        name: 'AnyOf10',
+        kind: 'OBJECT',
+        fields: [
+          {
+            name: 'anotherAttribute',
+            type: {
+              name: 'String'
+            }
+          },
+          {
+            name: 'commonAttribute',
+            type: {
+              name: 'String'
+            }
+          },
+          {
+            name: 'differentAttribute',
+            type: {
+              name: 'String'
+            }
+          }
+        ]
+      }
+    })
+  })
+})
+
+/**
+ * anyOf contains two member schemas and allOf contains an additional one that
+ * is nested in another anyOf
+ *
+ * Resolving the allOf should correctly collapse all of the (nested) anyOfs
+ * and allow all three schemas to be utilized
+ */
+test('anyOf test with allOf, requiring anyOf collapse\n\nEquivalent to GET /anyOf11', () => {
+  return graphql(createdSchema, anyOfQuery).then(result => {
+    expect(
+      result.data['__schema'].queryType.fields.find(field => {
+        return field.name === 'anyOf11'
+      })
+    ).toEqual({
+      name: 'anyOf11',
+      description:
+        'anyOf test with allOf, requiring anyOf collapse\n\nEquivalent to GET /anyOf11',
+      type: {
+        name: 'AnyOf11',
+        kind: 'OBJECT',
+        fields: [
+          {
+            name: 'anotherAttribute',
+            type: {
+              name: 'String'
+            }
+          },
+          {
+            name: 'commonAttribute',
+            type: {
+              name: 'String'
+            }
+          },
+          {
+            name: 'differentAttribute',
+            type: {
+              name: 'String'
+            }
+          }
+        ]
+      }
+    })
+  })
+})
+
 /**
  * oneOf contains two member schemas
  *
@@ -503,3 +590,106 @@ test('oneOf test with extraneous member schemas\n\nEquivalent to GET /oneOf4', (
     })
   })
 })
+
+/**
+ * oneOf contains two member schemas and an allOf
+ *
+ * Only schemas within the oneOf should be utilized
+ *
+ * TODO: verify this behavior and also create a test with additional root properties
+ */
+test('Basic oneOf test with allOf\n\nEquivalent to GET /oneOf5', () => {
+  return graphql(createdSchema, oneOfQuery).then(result => {
+    expect(
+      result.data['__schema'].queryType.fields.find(field => {
+        return field.name === 'oneOf5'
+      })
+    ).toEqual({
+      name: 'oneOf5',
+      description: 'Basic oneOf test with allOf\n\nEquivalent to GET /oneOf5',
+      type: {
+        name: 'OneOf5',
+        kind: 'UNION',
+        possibleTypes: [
+          {
+            name: 'CommonAttributeObject',
+            fields: [
+              {
+                type: {
+                  name: 'String'
+                }
+              }
+            ]
+          },
+          {
+            name: 'DifferentAttributeObject',
+            fields: [
+              {
+                type: {
+                  name: 'String'
+                }
+              }
+            ]
+          }
+        ]
+      }
+    })
+  })
+})
+
+/**
+ * oneOf contains two member schemas and allOf contains an additional one that
+ * is nested in another oneOf
+ *
+ * Resolving the allOf should correctly collapse all of the (nested) oneOfs
+ * and allow all three schemas to be utilized
+ */
+test('oneOf test with allOf, requiring oneOf collapse\n\nEquivalent to GET /oneOf6', () => {
+  return graphql(createdSchema, oneOfQuery).then(result => {
+    expect(
+      result.data['__schema'].queryType.fields.find(field => {
+        return field.name === 'oneOf6'
+      })
+    ).toEqual({
+      name: 'oneOf6',
+      description:
+        'oneOf test with allOf, requiring oneOf collapse\n\nEquivalent to GET /oneOf6',
+      type: {
+        name: 'OneOf6',
+        kind: 'UNION',
+        possibleTypes: [
+          {
+            name: 'CommonAttributeObject',
+            fields: [
+              {
+                type: {
+                  name: 'String'
+                }
+              }
+            ]
+          },
+          {
+            name: 'DifferentAttributeObject',
+            fields: [
+              {
+                type: {
+                  name: 'String'
+                }
+              }
+            ]
+          },
+          {
+            name: 'AnotherAttributeObject',
+            fields: [
+              {
+                type: {
+                  name: 'String'
+                }
+              }
+            ]
+          }
+        ]
+      }
+    })
+  })
+})