cherry pick 'Neptune Analytics - Logger' from #19

Author: AndreaNassisi

package.json

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

src/NeptuneSchema.js

@@ -14,15 +14,17 @@ import axios from "axios";
 import { aws4Interceptor } from "aws4-axios";
 import { fromNodeProviderChain  } from "@aws-sdk/credential-providers";
 import { NeptunedataClient, ExecuteOpenCypherQueryCommand } from "@aws-sdk/client-neptunedata";
+import { loggerLog } from "./logger.js";
 
 let HOST = '';
 let PORT = 8182;
 let REGION = ''
 let SAMPLE = 5000;
-let VERBOSE = false; 
+let VERBOSE = false;
+let NEPTUNE_TYPE = 'neptune-db'; 
 let language = 'openCypher';
 let useSDK = false;
-
+let msg = '';
 
 async function getAWSCredentials() {
     const credentialProvider = fromNodeProviderChain();
@@ -31,7 +33,7 @@ async function getAWSCredentials() {
     const interceptor = aws4Interceptor({
         options: {
             region: REGION,
-            service: "neptune-db",
+            service: NEPTUNE_TYPE,
         },
         credentials: cred
     });
@@ -55,6 +57,7 @@ function consoleOut(text) {
     if (VERBOSE) {
         console.log(text);
     }
+    loggerLog(text);
 }
 
 
@@ -67,11 +70,18 @@ async function queryNeptune(q) {
         const response = await axios.post(`https://${HOST}:${PORT}/${language}`, `query=${encodeURIComponent(q)}`);
         return response.data;    
         } catch (error) {
-            console.error("Http query request failed: ", error.message);
-            consoleOut("Trying with the AWS SDK");            
-            const response = await queryNeptuneSDK(q);
-            useSDK = true;
-            return response;             
+            msg = `Http query request failed: ${error.message}`;
+            consoleOut.error(msg);
+            loggerLog(msg);
+            
+            if (NEPTUNE_TYPE == 'neptune-db') {
+                consoleOut("Trying with the AWS SDK");            
+                const response = await queryNeptuneSDK(q);
+                useSDK = true;
+                return response; 
+            }
+            
+            throw new Error('AWS SDK for Neptune Analytics is not available, yet.');
         }
     } 
 }
@@ -91,7 +101,9 @@ async function queryNeptuneSDK(q) {
         return response;
 
     } catch (error) {        
-        console.error("SDK query request failed: ", error.message);
+        msg = `SDK query request failed: ${error.message}`;
+        consoleOut.error(msg);
+        loggerLog(msg);        
         process.exit(1);
     }
 }
@@ -100,10 +112,11 @@ async function queryNeptuneSDK(q) {
 async function getNodesNames() {
     let query = `MATCH (a) RETURN labels(a), count(a)`;
     let response = await queryNeptune(query);    
+    loggerLog('Getting nodes names');    
 
     try {
         response.results.forEach(result => {
-            schema.nodeStructures.push({ label: result['labels(a)'][0], properties: []});
+            schema.nodeStructures.push({ label: result['labels(a)'][0], properties: []});            
             consoleOut('  Found Node: ' + yellow(result['labels(a)'][0]));
         });        
     }
@@ -117,6 +130,7 @@ async function getNodesNames() {
 async function getEdgesNames() {
     let query = `MATCH ()-[e]->() RETURN type(e), count(e)`;
     let response = await queryNeptune(query);
+    loggerLog('Getting edges names');
 
     try {
         response.results.forEach(result => {
@@ -132,8 +146,9 @@ async function getEdgesNames() {
 }
 
 
-async function findFromAndToLabels(edgeStructure) {
-    let query = `MATCH (from)-[r:${edgeStructure.label}]->(to) RETURN DISTINCT labels(from) as fromLabel, labels(to) as toLabel`;
+async function checkEdgeDirection(direction) {
+    let query = `MATCH (from:${direction.from})-[r:${direction.edge.label}]->(to:${direction.to}) RETURN r as edge LIMIT 1`;
+    loggerLog(`Checking edge direction: ${query}`);
     let response = await queryNeptune(query);
     for (let result of response.results) {
         for (let fromLabel of result.fromLabel) {
@@ -190,7 +205,8 @@ function addUpdateEdgeProperty(edgeName, name, value) {
 
 
 async function getEdgeProperties(edge) {
-    let query = `MATCH ()-[n:${edge.label}]->() RETURN properties(n) as properties LIMIT ${SAMPLE}`;        
+    let query = `MATCH ()-[n:${edge.label}]->() RETURN properties(n) as properties LIMIT ${SAMPLE}`;
+    loggerLog(`Getting properties for edge: ${query}`);        
     try {
         let response = await queryNeptune(query);            
         let result = response.results;
@@ -214,7 +230,8 @@ async function getEdgesProperties() {
 
 
 async function getNodeProperties(node) {
-    let query = `MATCH (n:${node.label}) RETURN properties(n) as properties LIMIT ${SAMPLE}`;        
+    let query = `MATCH (n:${node.label}) RETURN properties(n) as properties LIMIT ${SAMPLE}`;
+    loggerLog(`Getting properties for node: ${query}`);
     try {
         let response = await queryNeptune(query);            
         let result = response.results;
@@ -238,10 +255,12 @@ async function getNodesProperties() {
 
 
 async function checkEdgeDirectionCardinality(d) {
-    let queryFrom = `MATCH (from:${d.from})-[r:${d.edge.label}]->(to:${d.to}) WITH to, count(from) as rels WHERE rels > 1 RETURN rels LIMIT 1`;     
+    let queryFrom = `MATCH (from:${d.from})-[r:${d.edge.label}]->(to:${d.to}) WITH to, count(from) as rels WHERE rels > 1 RETURN rels LIMIT 1`;
+    loggerLog(`Checking edge direction cardinality: ${queryFrom}`);     
     let responseFrom = await queryNeptune(queryFrom);
     let resultFrom = responseFrom.results[0];
-    let queryTo = `MATCH (from:${d.from})-[r:${d.edge.label}]->(to:${d.to}) WITH from, count(to) as rels WHERE rels > 1 RETURN rels LIMIT 1`;            
+    let queryTo = `MATCH (from:${d.from})-[r:${d.edge.label}]->(to:${d.to}) WITH from, count(to) as rels WHERE rels > 1 RETURN rels LIMIT 1`;
+    loggerLog(`Checking edge direction cardinality: ${queryTo}`);
     let responseTo = await queryNeptune(queryTo);
     let resultTo = responseTo.results[0];
     let c = '';
@@ -277,11 +296,12 @@ async function getEdgesDirectionsCardinality() {
 }
 
 
-function setGetNeptuneSchemaParameters(host, port, region, verbose = false) {
+function setGetNeptuneSchemaParameters(host, port, region, verbose = false, neptuneType) {
     HOST = host;
     PORT = port;
     REGION = region;
     VERBOSE = verbose;
+    NEPTUNE_TYPE = neptuneType;
 }
 
 

src/graphdb.js

@@ -69,12 +69,16 @@ function graphDBInferenceSchema (graphbSchema, addMutations) {
         }
 
         r += '\t_id: ID! @id\n';
-
+        
+        let properties = [];
         node.properties.forEach(property => {
+            properties.push(property.name);
+
             if (property.name == 'id')                
                 r+= `\tid: ID\n`;
             else
                 r+= `\t${property.name}: ${property.type}\n`;
+
         });
 
         let edgeTypes = [];
@@ -127,11 +131,15 @@ function graphDBInferenceSchema (graphbSchema, addMutations) {
         });
 
         // Add edge types        
-        edgeTypes.forEach(edgeType => {
+        edgeTypes.forEach(edgeType => {            
+            let collision = '';
+            if (properties.includes(edgeType))
+                collision = '_';
+
             if (changeCase) {
-                r += `\t${edgeType}:${toPascalCase(edgeType)}`
+                r += `\t${collision + edgeType}:${toPascalCase(edgeType)}`
             } else {
-                r += `\t${edgeType}:${edgeType}`
+                r += `\t${collision + edgeType}:${edgeType}`
             }
         });
 

src/logger.js

@@ -0,0 +1,22 @@
+import fs from 'fs';
+
+let LOG_FILE = './output/log.txt';
+
+function loggerInit(file) {
+    LOG_FILE = file;
+    fs.writeFile(LOG_FILE, '', (err) => {
+        return console.log(err);
+    });
+}
+
+function loggerLog(text) {
+    // remove yellow escape from text 
+    text = text.replaceAll(/\x1b\[33m/g, '');
+    text = text.replaceAll(/\x1b\[0m/g, '');
+
+    fs.appendFileSync(LOG_FILE, (new Date()).toISOString() + ' ' + text + '\n', (err) => {
+        return console.log(err);
+    })
+}
+
+export { loggerInit, loggerLog };