Added ability to create Apollo zip using an input graphQL schema file instead of discovering the schema by querying neptune. For consistency with App Sync pipeline and CDK workflows, this workflow requires setting a new endpoint argument --create-update-apollo-server-neptune-endpoint in addition to the existing --input-schema-file argument.

Other changes:

-fixed bugs resolving gremlin queries and added resolver tests for these scenarios
-changed schema file in zip to have output. prefix for consistency with the resolver file
-bumped the version from 1.1.1 to 1.2.0-beta.1

Author: andreachild

README.md

@@ -275,15 +275,24 @@ See CDK end to end example [here](https://github.com/aws/amazon-neptune-for-grap
 # Generate Apollo Server Artifacts
 If you prefer to use Apollo Server instead of AWS App Sync, the utility can generate a ZIP file of Apollo Server artifacts with the CLI option `--create-update-apollo-server` for a standalone server or `--create-update-apollo-server-subgraph` for federated systems.
 
-For example:
+Example of starting with a neptune database with data from which to determine the graphQL schema:
 ```
 neptune-for-graphql \
   --input-graphdb-schema-neptune-endpoint abc.us-west-2.neptune.amazonaws.com:8182 \
   --create-update-apollo-server \
   --output-resolver-query-https
 ```
 
-The command above will generate an `apollo-server-<identifier>-<timestamp>.zip` file which can then be deployed locally by following these steps:
+Example of starting with a graphQL schema file:
+```
+neptune-for-graphql \
+  --input-schema-file airports.source.schema.graphql \
+  --create-update-apollo-server-neptune-endpoint abc.us-west-2.neptune.amazonaws.com:8182 \
+  --create-update-apollo-server \
+  --output-resolver-query-https
+```
+
+The example commands above will generate the file `apollo-server-<identifier>-<timestamp>.zip`, which can then be deployed locally by following these steps:
 1. unzip `apollo-server-<identifier>-<timestamp>.zip`
 2. change directory into the unzipped folder
 3. execute `npm install` to install required dependencies

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws/neptune-for-graphql",
-  "version": "1.1.1",
+  "version": "1.2.0-beta.1",
   "description": "CLI utility to create and maintain a GraphQL API for Amazon Neptune",
   "keywords": [
     "Amazon Neptune",

package.json

@@ -146,6 +146,8 @@ Parameters
 
 [--create-update-apollo-server                              -asvr]
 [--create-update-apollo-server-subgraph                     -asub]
+[--create-update-apollo-server-neptune-endpoint             -ase ]  default: --input-graphdb-schema-neptune-endpoint if exists
+[ ... more apollo options to come in future roadmap              ]
 
 [--output-aws-pipeline-cdk                                  -c   ]
 [--output-aws-pipeline-cdk-name <value>                     -cn  ]  default: Neptune DB name from --input-graphdb-schema-neptune-endpoint if exists

src/help.js

@@ -55,6 +55,7 @@ let queryClient = 'sdk';          // or 'http'
 let isNeptuneIAMAuth = false;
 let createUpdateApolloServer = false;
 let createUpdateApolloServerSubgraph = false;
+let createUpdateApolloServerEndpoint = '';
 let createUpdatePipeline = false;
 let createUpdatePipelineName = '';
 let createUpdatePipelineEndpoint = '';
@@ -197,6 +198,10 @@ function processArgs() {
                 createUpdatePipeline = false;
                 inputCDKpipeline = false;
             break;
+            case '-ase':
+            case '--create-update-apollo-server-neptune-endpoint':
+                createUpdateApolloServerEndpoint = array[index + 1];
+                break;
             case '-p':
             case '--create-update-aws-pipeline':
                 createUpdatePipeline = true;
@@ -314,10 +319,15 @@ function createOutputFolder() {
 
 function validateArgs() {
     // TODO more argument validation
-    if (queryClient !== 'http' && (createUpdateApolloServerSubgraph || createUpdateApolloServer)) {
+    const createApollo = createUpdateApolloServerSubgraph || createUpdateApolloServer;
+    if (queryClient !== 'http' && createApollo) {
         console.error(`Neptune querying using ${queryClient} is not yet supported for Apollo Server. Please use option --output-resolver-query-https.`);
         process.exit(1);
     }
+    if (createApollo && !inputGraphDBSchemaNeptuneEndpoint && !createUpdateApolloServerEndpoint) {
+        console.error(`Apollo artifact creation requires a neptune endpoint. Please specify option --input-graphdb-schema-neptune-endpoint or --create-update-apollo-server-neptune-endpoint.`);
+        process.exit(1);
+    }
 }
 
 async function main() {
@@ -351,7 +361,12 @@ async function main() {
     let neptuneInfo;
     // Check if any of the Neptune endpoints are a neptune analytic endpoint and if so, set the neptuneType and IAM to required
     // only one of these endpoints are expected to be non-empty at the same time
-    const nonEmptyEndpoints = [inputGraphDBSchemaNeptuneEndpoint, createUpdatePipelineEndpoint, inputCDKpipelineEndpoint].filter(endpoint => endpoint !== '');
+    const nonEmptyEndpoints = [
+        inputGraphDBSchemaNeptuneEndpoint, 
+        createUpdatePipelineEndpoint, 
+        inputCDKpipelineEndpoint, 
+        createUpdateApolloServerEndpoint
+    ].filter(endpoint => endpoint !== '');
     if (nonEmptyEndpoints.length > 0) {
         neptuneInfo = parseNeptuneEndpoint(nonEmptyEndpoints[0]);
         neptuneType = neptuneInfo.neptuneType;

src/main.js

@@ -81,7 +81,7 @@ export async function createApolloDeploymentPackage({zipFilePath, resolverFilePa
         includePaths: [
             {source: path.join(modulePath, '/../templates/ApolloServer')},
             {source: resolverFilePath, target: 'output.resolver.graphql.js'},
-            {source: schemaFilePath, target: 'schema.graphql'},
+            {source: schemaFilePath, target: 'output.schema.graphql'},
             // querying neptune using SDK not yet supported
             {source: path.join(modulePath, '/../templates/queryHttpNeptune.mjs')}
         ],

src/zipPackage.js

@@ -8,7 +8,7 @@ import dotenv from 'dotenv';
 
 dotenv.config();
 
-const typeDefs = gql(readFileSync('./schema.graphql', 'utf-8'));
+const typeDefs = gql(readFileSync('./output.schema.graphql', 'utf-8'));
 const queryDefinition = typeDefs.definitions.find(
     definition => definition.kind === 'ObjectTypeDefinition' && definition.name.value === 'Query'
 );

templates/ApolloServer/index.mjs

@@ -1,6 +1,6 @@
 {
   "name": "neptune-apollo-server",
-  "version": "1.0.0",
+  "version": "1.2.0-beta.1",
   "description": "",
   "license": "Apache-2.0",
   "author": "",

templates/ApolloServer/package.json

@@ -10,7 +10,7 @@ express or implied. See the License for the specific language governing
 permissions and limitations under the License.
 */
 
-import { astFromValue, buildASTSchema, typeFromAST, GraphQLID } from 'graphql';
+import { astFromValue, buildASTSchema, typeFromAST, GraphQLID, GraphQLInputObjectType } from 'graphql';
 import { gql } from 'graphql-tag'; // GraphQL library to parse the GraphQL query
 
 const useCallSubquery = false;
@@ -36,7 +36,7 @@ export function resolveGraphDBQueryFromAppSyncEvent(event) {
     return resolveGraphDBQueryFromEvent({
         field: event.field,
         arguments: event.arguments,
-        selectionSet: gql`${event.selectionSetGraphQL}`.definitions[0].selectionSet
+        selectionSet: event.selectionSetGraphQL ? gql`${event.selectionSetGraphQL}`.definitions[0].selectionSet : {}
     });
 }
 
@@ -58,15 +58,17 @@ export function resolveGraphDBQueryFromEvent(event) {
         if (value) {
             const inputType = typeFromAST(schema, inputDef.type);
             const astValue = astFromValue(value, inputType);
-            // retrieve an ID field which may not necessarily be named 'id'
-            const idField = Object.values(inputType.getFields()).find(field => field.type.name === GraphQLID.name);
-            if (idField) {
-                // check if id was an input arg
-                const idValue = astValue.fields.find(f => f.name.value === idField.name);
-                if (idValue?.value?.kind === 'IntValue') {
-                    // graphql astFromValue function can convert ID integer strings into integer type
-                    // if input args contain an id and the graphql library has interpreted the value as an int, change it to treat the value as a string
-                    idValue.value.kind = 'StringValue';
+            if (inputType instanceof GraphQLInputObjectType) {
+                // retrieve an ID field which may not necessarily be named 'id'
+                const idField = Object.values(inputType.getFields()).find(field => field.type.name === GraphQLID.name);
+                if (idField) {
+                    // check if id was an input arg
+                    const idValue = astValue.fields.find(f => f.name.value === idField.name);
+                    if (idValue?.value?.kind === 'IntValue') {
+                        // graphql astFromValue function can convert ID integer strings into integer type
+                        // if input args contain an id and the graphql library has interpreted the value as an int, change it to treat the value as a string
+                        idValue.value.kind = 'StringValue';
+                    }
                 }
             }
             args.push({

templates/JSResolverOCHTTPSTemplate.js

@@ -1,6 +1,6 @@
 {
   "name": "lambda4appsyncgraphsdk",
-  "version": "1.1.1",
+  "version": "1.2.0-beta.1",
   "description": "AWS Lambda function to bridge AppSync to Neptune Analytics",
   "main": "index.mjs",
   "type": "module",

templates/Lambda4AppSyncGraphSDK/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "lambda4appsynchttp",
-  "version": "1.1.1",
+  "version": "1.2.0-beta.1",
   "description": "AWS Lambda function to bridge AppSync to Neptune or Neptune Analytics",
   "main": "index.mjs",
   "type": "module",

templates/Lambda4AppSyncGraphSDK/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lambda4appsyncsdk",
-  "version": "1.1.1",
+  "version": "1.2.0-beta.1",
   "description": "AWS Lambda function to bridge AppSync to Neptune",
   "main": "index.mjs",
   "type": "module",

templates/Lambda4AppSyncHTTP/package-lock.json

@@ -105,6 +105,36 @@ describe('AppSync resolver', () => {
         });
     });
 
+    test('should resolve gremlin query with argument', () => {
+        const result = resolve({
+            field: 'getAirportWithGremlin',
+            arguments: { code: 'YVR' },
+            selectionSetGraphQL: '{ city }'
+        });
+
+        expect(result).toMatchObject({
+            query: "g.V().has('airport', 'code', 'YVR').elementMap()",
+            parameters: {},
+            language: 'gremlin',
+            refactorOutput: null
+        });
+    });
+
+    test('should resolve gremlin query without arguments or selection set', () => {
+        const result = resolve({
+            field: 'getCountriesCount',
+            arguments: { },
+            selectionSetGraphQL: ''
+        });
+
+        expect(result).toMatchObject({
+            query: "g.V().hasLabel('country').count()",
+            parameters: {},
+            language: 'gremlin',
+            refactorOutput: null
+        });
+    });
+
     function resolve(event) {
         return resolverModule.resolveGraphDBQueryFromAppSyncEvent(event);
     }

templates/Lambda4AppSyncHTTP/package.json

@@ -1,5 +1,7 @@
 [
     { "type": "Airport", "field": "outboundRoutesCountAdd", "action": "add", "value":"outboundRoutesCountAdd: Int @graphQuery(statement: \"MATCH (this)-[r:route]->(a) RETURN count(r)\")"},    
     { "type": "Mutation", "field": "deleteNodeVersion", "action": "remove", "value": "" },
-    { "type": "Mutation", "field": "createNodeVersion", "action": "remove", "value": "" }
+    { "type": "Mutation", "field": "createNodeVersion", "action": "remove", "value": "" },
+    { "type": "Query", "field": "getAirportWithGremlin", "action": "add", "value":"getAirportWithGremlin(code:String): Airport @graphQuery(statement: \"g.V().has('airport', 'code', '$code').elementMap()\")"},
+    { "type": "Query", "field": "getCountriesCount", "action": "add", "value":"getCountriesCount: Int @graphQuery(statement: \"g.V().hasLabel('country').count()\")"}
 ]