Allow enum types in schema (aws#95)

Fix schema generation with enums such that they are not interpreted as edges and can be used for query and mutation input.

Author: andreachild

CHANGELOG.md

@@ -26,6 +26,7 @@ This release contains new support for Apollo Server integration.
 * Fixed bug with ID argument type conversion and added Apollo arguments to help menu (#74)
 * Upgraded axios and babel versions to fix security warnings (#90)
 * Fixed failing integration test by excluding `node_modules` from Apollo zip (#94)
+* Fixed enum types in schema to be included in input types (#95)
 
 ### Features
 

src/schemaModelValidator.js

@@ -16,9 +16,11 @@ import {gql} from 'graphql-tag'
 import { loggerInfo, yellow } from "./logger.js";
 
 let quiet = false;
+// TODO change variables to local scope instead of global so this module can be used against multiple schemas
 const typesToAdd = [];
 const queriesToAdd = [];
 const mutationsToAdd = [];
+const enumTypes = [];
 
 function lowercaseFirstCharacter(inputString) {
     if (inputString.length === 0) {     
@@ -238,7 +240,7 @@ function idFieldToInputValue({ name, type }) {
 
 
 function getInputFields(objTypeDef) {
-    return objTypeDef.fields.filter(field => isScalar(nullable(field.type)));
+    return objTypeDef.fields.filter(field => isScalarOrEnum(nullable(field.type)));
 }
 
 
@@ -247,9 +249,9 @@ function nullable(type) {
 }
 
 
-function isScalar(type) {
-    const scalarTypes = ['String', 'Int', 'Float', 'Boolean', 'ID'];
-    return type.kind === 'NamedType' && scalarTypes.includes(type.name.value);
+function isScalarOrEnum(type) {
+    const scalarOrEnumTypes = ['String', 'Int', 'Float', 'Boolean', 'ID', ...enumTypes];
+    return type.kind === 'NamedType' && scalarOrEnumTypes.includes(type.name.value);
 }
 
 
@@ -259,6 +261,10 @@ function inferGraphDatabaseDirectives(schemaModel) {
     let referencedType = '';
     let edgeName = '';
 
+    schemaModel.definitions
+        .filter(definition => definition.kind === 'EnumTypeDefinition')
+        .forEach(definition => enumTypes.push(definition.name.value));
+
     schemaModel.definitions.forEach(def => {
         if (def.kind == 'ObjectTypeDefinition') {
             if (!(def.name.value == 'Query' || def.name.value == 'Mutation')) {
@@ -296,7 +302,8 @@ function inferGraphDatabaseDirectives(schemaModel) {
                     } else if (field.type.name.value !== 'String' && 
                                field.type.name.value !== 'Int' && 
                                field.type.name.value !== 'Float' && 
-                               field.type.name.value !== 'Boolean') {
+                               field.type.name.value !== 'Boolean' &&
+                               !enumTypes.includes(field.type.name.value)) {
 
                         referencedType = field.type.name.value;
                         edgeName = referencedType + 'Edge';

src/test/directive-id.graphql

@@ -2,8 +2,15 @@ type User {
     userId: ID! @id
     firstName: String
     lastName: String
+    role: Role
 }
 
 type Group {
     name: String
 }
+
+enum Role {
+    ADMIN
+    USER
+    GUEST
+}

src/test/schemaModelValidator.test.js

@@ -13,6 +13,15 @@ describe('validatedSchemaModel', () => {
         model = validatedSchemaModel(schemaParser(schema));
     });
 
+    test('types definitions should be as expected', () => {
+        const objectTypes = model.definitions.filter(def => def.kind === 'ObjectTypeDefinition').map(def => def.name.value);
+        expect(objectTypes).toEqual(expect.arrayContaining(['User','Group','Query', 'Mutation']));
+        const inputTypes = model.definitions.filter(def => def.kind === 'InputObjectTypeDefinition').map(def => def.name.value);
+        expect(inputTypes).toEqual(expect.arrayContaining(['UserInput','GroupInput','Options']));
+        const enumTypes = model.definitions.filter(def => def.kind === 'EnumTypeDefinition').map(def => def.name.value);
+        expect(enumTypes).toEqual(expect.arrayContaining(['Role']));
+    });
+
     test('should only add _id field to object types without ID fields', () => {
         const objTypeDefs = model.definitions.filter(def => def.kind === 'ObjectTypeDefinition');
         const userType = objTypeDefs.find(def => def.name.value === 'User');
@@ -49,6 +58,15 @@ describe('validatedSchemaModel', () => {
         });
     });
 
+    test('should allow enum types as input fields', () => {
+        const roleEnumType = model.definitions.find(def => def.kind === 'EnumTypeDefinition' && def.name.value === 'Role');
+        expect(roleEnumType.values.map(value => value.name.value)).toEqual(expect.arrayContaining(['USER','ADMIN','GUEST']));
+        
+        const userInput = model.definitions.find(def => def.kind === 'InputObjectTypeDefinition' && def.name.value === 'UserInput');
+        const userRoleField = userInput.fields.find(field => field.name.value === 'role');
+        expect(userRoleField.type.name.value).toEqual('Role');
+    });
+
     function getIdFields(objTypeDef) {
         return objTypeDef.fields.filter(
             field =>

templates/queryHttpNeptune.mjs

@@ -33,6 +33,9 @@ export async function queryNeptune(neptuneUrl, resolvedQuery, options = {logging
         };
 
         let response;
+        if (loggingEnabled) {
+            console.log("Query: ", JSON.stringify(resolvedQuery, null, 2));
+        }
         if (resolvedQuery.language === 'opencypher') {
             response = await axios.post(`${neptuneUrl}/opencypher`, {
                 query: resolvedQuery.query, parameters: JSON.stringify(resolvedQuery.parameters)