Fix query from AppSync with an empty filter object (#61)

Build the query/mutation's selection set using the `graphql` utilities,
instead of building manually. This will avoid any edge cases with the
provided arguments. The schema is assumed to be valid: validation should
be taken care of ahead of time in `schemaModelValidator` and we also
currently do not define the built-in directives (e.g. `@id`,
`@relationship`) required to make it a valid schema.

- break out lookup functions for type/field definitions
- update `outputReference` resolvers
- add unit tests
- fix query result tests that were sensitive to object key order (use
  `toEqual` instead of strict JSON string equality)
- also check output file size of `.cjs` resolver in test `Case01.02`
- fix running test `Case01.04` (use `.cjs` extension)

closes #44

* Change `resolveGraphDBQuery` to accept AST param

Callers can now pass in GraphQL ASTs directly. Saves a redundant
print/parse in `resolveGraphDBQueryFromAppSyncEvent`.

For backwards-compatibility, callers *can* continue to pass in a query
string.

- update `outputReference` resolvers
- update tests to pass in ASTs instead of strings

see #61 (comment)

Author: danielfinke

templates/JSResolverOCHTTPSTemplate.js

@@ -10,6 +10,7 @@ express or implied. See the License for the specific language governing
 permissions and limitations under the License.
 */
 
+const { astFromValue, buildASTSchema, typeFromAST } = require('graphql');
 const gql = require('graphql-tag'); // GraphQL library to parse the GraphQL query
 
 const useCallSubquery = false;
@@ -20,36 +21,50 @@ const schemaDataModelJSON = `INSERT SCHEMA DATA MODEL HERE`;
 
 const schemaDataModel = JSON.parse(schemaDataModelJSON);
 
+const schema = buildASTSchema(schemaDataModel, { assumeValidSDL: true });
+
 
 function resolveGraphDBQueryFromAppSyncEvent(event) {        
-    let query = '{\n';
-    let args = '';
-  
-    Object.keys(event.arguments).forEach(key => {
-        if (typeof event.arguments[key] === 'object') {
-            args += key + ': {';
-            let obj = event.arguments[key];
-            Object.keys(obj).forEach(key2 => {
-                args += key2 + ': "' + obj[key2] + '", '
+    const fieldDef = getFieldDef(event.field);
+
+    const args = [];
+    for (const inputDef of fieldDef.arguments) {
+        const value = event.arguments[inputDef.name.value];
+
+        if (value) {
+            const inputType = typeFromAST(schema, inputDef.type);
+            args.push({
+                kind: 'Argument',
+                name: { kind: 'Name', value: inputDef.name.value },
+                value: astFromValue(value, inputType)
             });
-            args = args.substring(0, args.length - 2);
-            args += '}';
-        }  else {
-            args += key + ': "' + event.arguments[key] + '", '
-            args = args.substring(0, args.length - 2);
         }
-    });
-  
-    if (args != '') {                   
-        query += event.field + '(' + args + ') ';
-      } else {
-          query += event.field + ' ';
-      }
-        
-    query += event.selectionSetGraphQL;    
-    query += '\n}';
-  
-    const graphQuery = resolveGraphDBQuery(query);
+    }
+
+    const fieldNode = {
+        kind: 'Field',
+        name: { kind: 'Name', value: event.field },
+        arguments: args,
+        selectionSet:
+            event.selectionSetGraphQL !== ''
+                ? gql`${event.selectionSetGraphQL}`.definitions[0].selectionSet
+                : undefined,
+    };
+    const obj = {
+        kind: 'Document',
+        definitions: [
+            {
+                kind: 'OperationDefinition',
+                operation: 'query',
+                selectionSet: {
+                    kind: 'SelectionSet',
+                    selections: [fieldNode]
+                }
+            }
+        ]
+    };
+
+    const graphQuery = resolveGraphDBQuery(obj);
     return graphQuery;
 }
 
@@ -65,6 +80,35 @@ const returnString = [];    // openCypher return statements
 let parameters = {};      // openCypher query parameters
 
 
+function getRootTypeDefs() {
+    return getTypeDefs(['Query', 'Mutation']);
+}
+
+
+function getTypeDefs(typeNameOrNames) {
+    if (!Array.isArray(typeNameOrNames)) {
+        typeNameOrNames = [typeNameOrNames];
+    }
+
+    return schemaDataModel.definitions.filter(
+        def => def.kind === 'ObjectTypeDefinition' && typeNameOrNames.includes(def.name.value)
+    );
+}
+
+
+function getFieldDef(fieldName) {
+    const rootTypeDefs = getRootTypeDefs();
+
+    for (const rootDef of rootTypeDefs) {
+        const fieldDef = rootDef.fields.find(def => def.name.value === fieldName);
+
+        if (fieldDef) {
+            return fieldDef;
+        }
+    }
+}
+
+
 function getTypeAlias(typeName) {
     let alias = null;
     schemaDataModel.definitions.forEach(def => {
@@ -1018,14 +1062,27 @@ function resolveGremlinQuery(obj, querySchemaInfo) {
 }
 
 
-// Function takes the graphql query and output the graphDB query
-function resolveGraphDBQuery(query) {
+function parseQueryInput(queryObjOrStr) {
+    // Backwards compatibility
+    if (typeof queryObjOrStr === 'string') {
+        return gql(queryObjOrStr);
+    }
+
+    // Already in AST format
+    return queryObjOrStr;
+}
+
+
+/**
+ * Accepts a GraphQL document or query string and outputs the graphDB query.
+ *
+ * @param {(Object|string)} queryObjOrStr the GraphQL document containing an operation to resolve
+ * @returns {string}
+ */
+function resolveGraphDBQuery(queryObjOrStr) {
     let executeQuery =  { query:'', parameters: {}, language: 'opencypher', refactorOutput: null };
-        
-    // create a gql object from the query, gql is GraphQL Query Language
-    const obj = gql`
-        ${query}
-    `;
+
+    const obj = parseQueryInput(queryObjOrStr);
 
     const querySchemaInfo = getSchemaQueryInfo(obj.definitions[0].selectionSet.selections[0].name.value);
 

test/TestCases/Case01/Case01.04.test.js

@@ -4,7 +4,7 @@ import { readJSONFile, testResolverQueriesResults } from '../../testLib';
 
 const casetest = readJSONFile('./test/TestCases/Case01/case.json');
 
-await testResolverQueriesResults(   './TestCases/Case01/output/output.resolver.graphql.js',
+await testResolverQueriesResults(   './TestCases/Case01/output/output.resolver.graphql.cjs',
                                     './test/TestCases/Case01/queries',
                                     casetest.host,
                                     casetest.port);

test/TestCases/Case01/Case01.05.test.js

@@ -0,0 +1,63 @@
+
+import { jest } from '@jest/globals';
+import { loadResolver } from '../../testLib';
+
+describe('AppSync resolver', () => {
+    let resolverModule;
+
+    beforeAll(async () => {
+        resolverModule = await loadResolver('./TestCases/Case01/output/output.resolver.graphql.cjs');
+    });
+
+    test('should resolve queries with a filter', () => {
+        const result = resolve({
+            field: 'getNodeAirport',
+            arguments: { filter: { code: 'SEA' } },
+            selectionSetGraphQL: '{ city }'
+        });
+
+        expect(result).toEqual({
+            query: 'MATCH (getNodeAirport_Airport:`airport`{code: $getNodeAirport_Airport_code})\n' +
+                'RETURN {city: getNodeAirport_Airport.`city`} LIMIT 1',
+            parameters: { getNodeAirport_Airport_code: 'SEA' },
+            language: 'opencypher',
+            refactorOutput: null
+        });
+    });
+
+    test('should resolve queries with an empty filter object', () => {
+        const result = resolve({
+            field: 'getNodeAirport',
+            arguments: { filter: {} },
+            selectionSetGraphQL: '{ city }'
+        });
+
+        expect(result).toEqual({
+            query: 'MATCH (getNodeAirport_Airport:`airport`)\n' +
+                'RETURN {city: getNodeAirport_Airport.`city`} LIMIT 1',
+            parameters: {},
+            language: 'opencypher',
+            refactorOutput: null
+        });
+    });
+
+    test('should resolve queries without a filter', () => {
+        const result = resolve({
+            field: 'getNodeAirport',
+            arguments: {},
+            selectionSetGraphQL: '{ city }'
+        });
+
+        expect(result).toEqual({
+            query: 'MATCH (getNodeAirport_Airport:`airport`)\n' +
+                'RETURN {city: getNodeAirport_Airport.`city`} LIMIT 1',
+            parameters: {},
+            language: 'opencypher',
+            refactorOutput: null
+        });
+    });
+
+    function resolve(event) {
+        return resolverModule.resolveGraphDBQueryFromAppSyncEvent(event);
+    }
+});

test/TestCases/Case01/case.json

@@ -9,6 +9,6 @@
             "--output-no-lambda-zip"],
     "host": "<AIR_ROUTES_DB_HOST>",
     "port": "<AIR_ROUTES_DB_PORT>",
-    "testOutputFilesSize": ["output.resolver.graphql.js", "output.schema.graphql", "output.source.schema.graphql"],
+    "testOutputFilesSize": ["output.resolver.graphql.cjs", "output.resolver.graphql.js", "output.schema.graphql", "output.source.schema.graphql"],
     "testOutputFilesContent": ["output.schema.graphql", "output.source.schema.graphql"]
 }