Changed code to upload schema onto lambda, made resolver template take in schema file as separate file instead of input, made template static by not accepting any input including the timestamp. Also updated integration tests to succeed with these changes (#79)

Author: flora-jin

doc/todoExample.md

@@ -21,7 +21,7 @@ Let's now run this schema through the utility and create the GraphQL API in AWS
 
 `neptune-for-graphql --input-schema-file ./samples/todo.schema.graphql --create-update-aws-pipeline --create-update-aws-pipeline-name TodoExample --create-update-aws-pipeline-neptune-endpoint` <*your-neptune-database-endpoint:port*> ` --output-resolver-query-https`
 
-Te utility created a new file in the *output* folder called *TodoExample.source.graphql*, and the GraphQL API in AppSync. As you can see below, the utility inferenced:
+The utility created a new file in the *output* folder called *TodoExample.source.graphql*, and the GraphQL API in AppSync. As you can see below, the utility inferenced:
 
 - In the type *Todo* it added *@relationship* for a new type *CommentEdge*. This is instructing the resolver to connect *Todo* to *Comment* using a graph database edge called *CommentEdge*.
 - A new input called *TodoInput* was added to help the queries and the mutations.

package.json

@@ -41,7 +41,7 @@
     "neptune-for-graphql.mjs",
     "./templates/CDKTemplate.js",
     "./templates/queryHttpNeptune.mjs",
-    "./templates/JSResolverOCHTTPSTemplate.js",
+    "./templates/JSResolverOCHTTPS.js",
     "./templates/Lambda4AppSyncHTTP/index.mjs",
     "./templates/Lambda4AppSyncHTTP/package.json",
     "./templates/Lambda4AppSyncSDK/index.mjs",

src/main.js

@@ -16,7 +16,6 @@ import { graphDBInferenceSchema } from './graphdb.js';
 import { changeGraphQLSchema } from './changes.js';
 import { schemaParser, schemaStringify } from './schemaParser.js';
 import { validatedSchemaModel} from './schemaModelValidator.js';
-import { resolverJS } from './resolverJS.js';
 import { getNeptuneSchema, setGetNeptuneSchemaParameters } from './NeptuneSchema.js';
 import { createUpdateAWSpipeline, removeAWSpipelineResources } from './pipelineResources.js'
 import { createAWSpipelineCDK } from './CDKPipelineApp.js'
@@ -519,11 +518,40 @@ async function main() {
         // Validate schema
         schemaModel = validatedSchemaModel(schemaModel, quiet);
 
-        // Generate AWS Lambda resolver for AppSync and Amazon Neptune        
-        outputLambdaResolver = resolverJS(schemaModel, queryLanguage, queryClient, __dirname);
+        // Generate schema for resolver
+        const queryDataModelJSON = JSON.stringify(schemaModel, null, 2);
+
+        let resolverSchemaFile;
+        if (createUpdatePipelineName == '') {
+            resolverSchemaFile = `${outputFolderPath}/output.resolver.schema.json`
+        } else {
+            resolverSchemaFile = `${outputFolderPath}/${createUpdatePipelineName}.resolver.schema.json`
+        }
+
+        try {
+            writeFileSync(resolverSchemaFile, queryDataModelJSON);
+            loggerInfo('Wrote schema for resolver to file: ' + yellow(resolverSchemaFile), {toConsole: true});
+        } catch (err) {
+            loggerError('Error writing schema for resolver to file: ' + yellow(resolverSchemaFile), err);
+        }
+
+        // Generate AWS Lambda resolver for AppSync and Amazon Neptune
+        if (queryLanguage == 'opencypher') {
+            try {
+                outputLambdaResolver = readFileSync(__dirname + '/../templates/JSResolverOCHTTPS.js');
+            } catch (err) {
+                loggerError('No resolver template found.', err);
+            }
+        }
 
         // Generate generic Javascript resolver
-        outputJSResolver = resolverJS(schemaModel, queryLanguage, queryClient, __dirname);
+        if (queryLanguage == 'opencypher') {
+            try {
+                outputJSResolver = readFileSync(__dirname + '/../templates/JSResolverOCHTTPS.js');
+            } catch (err) {
+                loggerError('No resolver template found.', err);
+            }
+        }
     }
 
     // ****************************************************************************
@@ -614,6 +642,12 @@ async function main() {
         // output Apollo zip
         if (createUpdateApolloServer || createUpdateApolloServerSubgraph) {
             const apolloZipPath = path.join(outputFolderPath, `apollo-server-${neptuneInfo.graphName}-${new Date().getTime()}.zip`);
+            let resolverSchemaFilePath;
+            if (createUpdatePipelineName == '') {
+                resolverSchemaFilePath = path.join(outputFolderPath, 'output.resolver.schema.json');
+            } else {
+                resolverSchemaFilePath = path.join(outputFolderPath, `${createUpdatePipelineName}.resolver.schema.json`);
+            }
             try {
                 if (!quiet) {
                     spinner = ora('Creating Apollo server ZIP file ...').start();
@@ -622,6 +656,7 @@ async function main() {
                     zipFilePath: apolloZipPath,
                     resolverFilePath: outputLambdaResolverFile,
                     schemaFilePath: outputSchemaFile,
+                    resolverSchemaFilePath: resolverSchemaFilePath,
                     neptuneInfo: neptuneInfo,
                     isSubgraph: createUpdateApolloServerSubgraph
                 });

src/pipelineResources.js

@@ -396,10 +396,12 @@ async function createLambdaRole() {
  */
 async function createDeploymentPackage(templateFolderPath, resolverFilePath) {
     const zipFilePath = path.join(thisOutputFolderPath, `${NAME}.zip`);
+    const resolverSchemaFilePath = path.join(thisOutputFolderPath, `${NAME}.resolver.schema.json`)
     await createLambdaDeploymentPackage({
         outputZipFilePath: zipFilePath,
         templateFolderPath: templateFolderPath,
-        resolverFilePath: resolverFilePath
+        resolverFilePath: resolverFilePath,
+        resolverSchemaFilePath: resolverSchemaFilePath
     });
     await sleep(2000);
     const fileContent = await fs.readFileSync(zipFilePath);

src/resolverJS.js

@@ -41,15 +41,22 @@ async function createZip({targetZipFilePath, includePaths = [], includeContent =
  * @param outputZipFilePath the path to where the zip should be created
  * @param templateFolderPath the path to the template folder that contains contents to add to the zip
  * @param resolverFilePath the path to the resolver file that should be added to the zip
+ * @param resolverSchemaFilePath the path to the resolver schema file that should be added to the zip
  * @returns {Promise<Buffer<ArrayBufferLike>>}
  */
-export async function createLambdaDeploymentPackage({outputZipFilePath, templateFolderPath, resolverFilePath}) {
+export async function createLambdaDeploymentPackage({outputZipFilePath, templateFolderPath, resolverFilePath, resolverSchemaFilePath}) {
     const filePaths = [{source: templateFolderPath}, {source: resolverFilePath, target: 'output.resolver.graphql.js'}];
     if (templateFolderPath.includes('HTTP')) {
         filePaths.push({
             source: path.join(getModulePath(), '/../templates/queryHttpNeptune.mjs')
         })
     }
+
+    filePaths.push({
+        source: resolverSchemaFilePath,
+        target: 'output.resolver.schema.json'
+    })
+
     await createZip({
         targetZipFilePath: outputZipFilePath,
         includePaths: filePaths
@@ -62,11 +69,12 @@ export async function createLambdaDeploymentPackage({outputZipFilePath, template
  * @param zipFilePath the file path where the zip should be created
  * @param resolverFilePath path to the resolver file to include in the zip
  * @param schemaFilePath path to the schema file to include in the zip
+ * @param resolverSchemaFilePath path to the resolver schema file to include in the zip
  * @param neptuneInfo object containing neptune db/graph related information such as URL, region, etc
  * @param isSubgraph true if the service should be deployed as a subgraph
  * @returns {Promise<void>}
  */
-export async function createApolloDeploymentPackage({zipFilePath, resolverFilePath, schemaFilePath, neptuneInfo, isSubgraph = false}) {
+export async function createApolloDeploymentPackage({zipFilePath, resolverFilePath, schemaFilePath, resolverSchemaFilePath, neptuneInfo, isSubgraph = false}) {
     const envVars = [
         `NEPTUNE_TYPE=${neptuneInfo.neptuneType}`,
         `NEPTUNE_HOST=${neptuneInfo.host}`,
@@ -82,6 +90,8 @@ export async function createApolloDeploymentPackage({zipFilePath, resolverFilePa
             {source: path.join(modulePath, '/../templates/ApolloServer')},
             {source: resolverFilePath, target: 'output.resolver.graphql.js'},
             {source: schemaFilePath, target: 'output.schema.graphql'},
+            {source: resolverSchemaFilePath, target: 'output.resolver.schema.json'},
+
             // querying neptune using SDK not yet supported
             {source: path.join(modulePath, '/../templates/queryHttpNeptune.mjs')}
         ],

src/zipPackage.js

@@ -4,7 +4,8 @@ import {aws4Interceptor} from 'aws4-axios';
 import {fromNodeProviderChain} from '@aws-sdk/credential-providers';
 import dotenv from 'dotenv';
 import {queryNeptune} from './queryHttpNeptune.mjs'
-import {resolveGraphDBQueryFromEvent} from "./output.resolver.graphql.js";
+import {resolveGraphDBQueryFromEvent, initSchema} from "./output.resolver.graphql.js";
+import {readFileSync} from "fs";
 
 
 dotenv.config();
@@ -23,6 +24,9 @@ axios.interceptors.request.use(interceptor);
 rax.attach();
 
 export async function resolveEvent(event) {
+    const schemaDataModelJSON = readFileSync('output.resolver.schema.json', 'utf-8');
+    let schemaModel = JSON.parse(schemaDataModelJSON);
+    initSchema(schemaModel);
     const resolved = resolveGraphDBQueryFromEvent(event);
     try {
         return queryNeptune(`https://${process.env.NEPTUNE_HOST}:${process.env.NEPTUNE_PORT}`, resolved, {loggingEnabled: loggingEnabled});

templates/ApolloServer/neptune.mjs

@@ -15,14 +15,18 @@ import { gql } from 'graphql-tag'; // GraphQL library to parse the GraphQL query
 
 const useCallSubquery = false;
 
-// TIMESTAMP HERE
-
-const schemaDataModelJSON = `INSERT SCHEMA DATA MODEL HERE`;
-    
-const schemaDataModel = JSON.parse(schemaDataModelJSON);
-
-const schema = buildASTSchema(schemaDataModel, { assumeValidSDL: true });
+let schemaDataModel;
+let schema;
 
+/**
+ * Initializes the schema from a given file path
+ *
+ * @param {object} schemaModel the path to the JSON schema data mode
+ */
+export function initSchema(schemaModel) {
+    schemaDataModel = schemaModel;
+    schema = buildASTSchema(schemaDataModel, { assumeValidSDL: true });
+}
 
 /**
  * Resolves a graph db query from a given App Sync graphQL query event.

templates/JSResolverOCHTTPSTemplate.js templates/JSResolverOCHTTPS.js

@@ -1,5 +1,6 @@
 import {ExecuteQueryCommand, NeptuneGraphClient} from "@aws-sdk/client-neptune-graph";
-import {resolveGraphDBQueryFromAppSyncEvent} from './output.resolver.graphql.js';
+import {resolveGraphDBQueryFromAppSyncEvent, initSchema} from './output.resolver.graphql.js';
+import {readFileSync} from "fs";
 
 const PROTOCOL = 'https';
 const QUERY_LANGUAGE = 'OPEN_CYPHER';
@@ -49,6 +50,9 @@ function log(message) {
  */
 function resolveGraphQuery(event) {
     try {
+        const schemaDataModelJSON = readFileSync('output.resolver.schema.json', 'utf-8');
+        let schemaModel = JSON.parse(schemaDataModelJSON);
+        initSchema(schemaModel);
         let resolver = resolveGraphDBQueryFromAppSyncEvent(event);
         if (resolver.language !== RESOLVER_LANGUAGE) {
             return onError('Unsupported resolver language:' + resolver.language)

templates/Lambda4AppSyncGraphSDK/index.mjs

@@ -1,8 +1,9 @@
 import axios from "axios";
 import * as rax from 'retry-axios';
 import { aws4Interceptor } from "aws4-axios";
-import {resolveGraphDBQueryFromAppSyncEvent} from './output.resolver.graphql.js';
+import {resolveGraphDBQueryFromAppSyncEvent, initSchema} from './output.resolver.graphql.js';
 import {queryNeptune} from "./queryHttpNeptune.mjs";
+import {readFileSync} from "fs";
 
 const LOGGING_ENABLED = process.env.LOGGING_ENABLED;
 
@@ -43,6 +44,9 @@ export const handler = async (event) => {
     // Create Neptune query from GraphQL query
     try {
         if (LOGGING_ENABLED) console.log("Event: ", event);
+        const schemaDataModelJSON = readFileSync('output.resolver.schema.json', 'utf-8');
+        let schemaModel = JSON.parse(schemaDataModelJSON);
+        initSchema(schemaModel);
         const resolver = resolveGraphDBQueryFromAppSyncEvent(event);
         if (LOGGING_ENABLED) console.log("Resolver: ", resolver);
         return queryNeptune(`https://${process.env.NEPTUNE_HOST}:${process.env.NEPTUNE_PORT}`, resolver, {loggingEnabled: LOGGING_ENABLED})

templates/Lambda4AppSyncHTTP/index.mjs

@@ -1,5 +1,6 @@
 import { NeptunedataClient, ExecuteOpenCypherQueryCommand, ExecuteGremlinQueryCommand } from "@aws-sdk/client-neptunedata";
-import {resolveGraphDBQueryFromAppSyncEvent, refactorGremlinqueryOutput} from './output.resolver.graphql.js';
+import {resolveGraphDBQueryFromAppSyncEvent, refactorGremlinqueryOutput, initSchema} from './output.resolver.graphql.js';
+import {readFileSync} from "fs";
 
 const LOGGING_ENABLED = process.env.LOGGING_ENABLED;
 
@@ -40,6 +41,9 @@ export const handler = async(event) => {
     let resolver = { query:'', parameters:{}, language: 'opencypher', fieldsAlias: {} };
 
     try {
+        const schemaDataModelJSON = readFileSync('output.resolver.schema.json', 'utf-8');
+        let schemaModel = JSON.parse(schemaDataModelJSON);
+        initSchema(schemaModel);
         resolver = resolveGraphDBQueryFromAppSyncEvent(event);
         if (LOGGING_ENABLED) console.log(JSON.stringify(resolver, null, 2));
     } catch (error) {

templates/Lambda4AppSyncSDK/index.mjs

@@ -3,4 +3,4 @@ import { jest } from '@jest/globals';
 import { testResolverQueries } from '../../testLib';
 
 
-await testResolverQueries('./TestCases/Case01/output/output.resolver.graphql.js', './test/TestCases/Case01/queries');
+await testResolverQueries('./TestCases/Case01/output/output.resolver.graphql.js', './test/TestCases/Case01/queries', './test/TestCases/Case01/output/output.resolver.schema.json');

test/TestCases/Case01/Case01.03.test.js

@@ -6,5 +6,6 @@ const casetest = readJSONFile('./test/TestCases/Case01/case.json');
 
 await testResolverQueriesResults(   './TestCases/Case01/output/output.resolver.graphql.js',
                                     './test/TestCases/Case01/queries',
+                                    './test/TestCases/Case01/output/output.resolver.schema.json',
                                     casetest.host,
                                     casetest.port);

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

@@ -1,12 +1,16 @@
 
 import { jest } from '@jest/globals';
 import { loadResolver } from '../../testLib';
+import {readFileSync} from "fs";
 
 describe('AppSync resolver', () => {
     let resolverModule;
 
     beforeAll(async () => {
         resolverModule = await loadResolver('./TestCases/Case01/output/output.resolver.graphql.js');
+        const schemaDataModelJSON = readFileSync('./test/TestCases/Case01/output/output.resolver.schema.json', 'utf-8');
+        let schemaModel = JSON.parse(schemaDataModelJSON);
+        resolverModule.initSchema(schemaModel);
     });
 
     test('should resolve queries with a filter', () => {