add graphql

Author: ryanhs

README.md

@@ -20,14 +20,24 @@ then you can use this so called "sdk".
 ```javascript
 const sdk = require('sdk');
 
-
 ```
 
+
+### Configurations
+
+Most of commont configuration may be added via environment variables. (with prefix `SDK_`).
+This way, the app can be changed without touching the code.
+
+For example, you develop it in redis stream, zipkin memory, cache memory.
+But in the server you use kafka stream, zipkin http, and cache with redis. Just use `SDK_` prefix env.
+
+
 ## Integration
 
 This curated list is not really binding into a Framework.
 Please feel free to use any framework to use. \*as long as its compatible :-)
 
+
 ## Utilities
 
 ### Cache
@@ -75,14 +85,50 @@ Bunyan ringbuffer is enabled by default. So we can use to track logs, even in un
 try to get ringBuffer object? this how we do that: `sdk.log.ringBuffer`.
 
 
-### Metrics
+## Metrics
+
+### Zipkin
+
+For easier tracer, we can use zipkin as tracer exporter.
+Just enable it with config `ZIPKIN_ENABLE` or via env `SDK_ZIPKIN_ENABLE` set to `true`.
 
+Env Variables example:
+
+```
+SDK_ZIPKIN_ENABLE: true,
+SDK_ZIPKIN_DRIVER: 'http',
+SDK_ZIPKIN_HTTP_ENDPOINT: 'http://zipkin-service:9411/api/v2/spans',
+```
 
 ## Stream
 
 
 ## Graphql
 
+A binding for ApolloClient graphql.
+
+> if you enable zipkin, then its zipkin wrapped also
+
+**Example**:
+
+```javascript
+await sdk.enable_graphql({
+  uri: 'https://some-graphql-server.com/graphql',
+  remoteServiceName: 'fakeql',
+});
+
+const query = `
+  query {
+    user (id: 1) {
+      id
+      name
+      phone
+    }
+  }
+`;
+
+const response = await sdk.graphql.query({ query, throwError: true, withCache: false });
+```
 
 ## Authorization
 

jest.setup.js

@@ -16,5 +16,5 @@ fetchMock.dontMock();
 // fake timer
 // jest.useFakeTimers();
 
-// timeout 10s
-// jest.setTimeout(10000);
+// timeout 30s
+jest.setTimeout(30000);

package.json

@@ -33,6 +33,9 @@
     ]
   },
   "dependencies": {
+    "apollo-cache-inmemory": "^1.6.5",
+    "apollo-client": "^2.6.8",
+    "apollo-link-http": "^1.5.17",
     "aws-sdk": "^2.669.0",
     "bluebird": "^3.7.2",
     "bunyan": "^1.8.12",
@@ -43,13 +46,17 @@
     "cache-manager": "^3.3.0",
     "cache-manager-redis-store": "^2.0.0",
     "connection-string": "^3.2.2",
+    "crypto": "^1.0.1",
     "flaverr": "^1.10.0",
+    "graphql": "^14.5.8",
+    "graphql-tag": "^2.10.3",
     "lodash": "^4.17.15",
     "machine": "^15.2.2",
-    "moment": "^2.25.3",
+    "node-fetch": "^2.6.0",
     "rxjs": "^6.5.5",
     "uuid": "^8.0.0",
     "zipkin": "^0.21.0",
+    "zipkin-instrumentation-fetch": "^0.21.0",
     "zipkin-transport-http": "^0.21.0"
   }
 }

src/graphql/connect.js

@@ -0,0 +1,159 @@
+const { ApolloClient } = require('apollo-client');
+const { InMemoryCache } = require('apollo-cache-inmemory');
+const { HttpLink } = require('apollo-link-http');
+const wrapFetch = require('zipkin-instrumentation-fetch');
+const fetch = require('node-fetch');
+const crypto = require('crypto');
+const flaverr = require('flaverr');
+const _ = require('lodash');
+const qgl = require('graphql-tag');
+
+const makeRequest = ({
+  sdk, method, client, remoteServiceName, logger,
+}) => (configs) => {
+  const { withCache = false, cacheOptions = {}, throwError = true } = configs;
+
+  const formatError = (err) => ({
+    message: err.message,
+    locations: [],
+    path: [],
+  });
+
+  // auto throw, if configs.throwError is true
+  const hash = crypto
+    .createHash('md5')
+    .update(JSON.stringify(_.pick(configs, ['query', 'mutation', 'variables'])))
+    .digest('hex')
+    .substr(0, 14);
+
+  const log = logger.child({ hash, method });
+
+  const sendRequest = () => {
+    log.trace('request sent!', configs);
+
+    // auto translate if gql is string
+    if (configs.query && typeof configs.query === 'string') {
+      configs.query = qgl(configs.query); // eslint-disable-line no-param-reassign
+    }
+    if (configs.mutation && typeof configs.mutation === 'string') {
+      configs.mutation = qgl(configs.mutation); // eslint-disable-line no-param-reassign
+    }
+
+    return client[method](configs)
+      .then((response) => {
+        if ((response.errors || []).length > 0 && throwError) {
+          throw flaverr(
+            _.pick(response.errors[0], ['code', 'httpStatusCode', 'locations', 'path']),
+            new Error(response.errors[0].message),
+          );
+        }
+
+        log.trace('response success!');
+        return ({
+          status: 200,
+          errors: response.errors || [],
+          ...response,
+          hash,
+        });
+      })
+      .catch((err) => {
+
+        if (throwError) {
+          // if there is more information
+          if (Array.isArray(err.graphQLErrors) && err.graphQLErrors.length > 0) {
+            throw flaverr(
+              _.pick(err.graphQLErrors[0], ['code', 'httpStatusCode', 'locations', 'path']),
+              err,
+            );
+          }
+
+          // else just throw error
+          throw err;
+        }
+
+        if (err.networkError) {
+          log.trace('failed! networkError', err);
+          return {
+            status: 500,
+            data: {},
+            errors: [formatError(new Error('Backend Error!')), formatError(err.networkError)],
+            hash,
+          };
+        }
+
+        log.trace('failed! UnknownError', err);
+
+        const originalErrors = (Array.isArray(err.graphQLErrors))
+          ? err.graphQLErrors.map(formatError)
+          : [formatError(err)];
+
+        return {
+          status: 200,
+          errors: [formatError(new Error('Unknown Error!')), ...originalErrors],
+          data: null,
+          hash,
+        };
+      });
+  };
+
+
+  if (withCache) {
+    return sdk.cache.wrap(`${remoteServiceName}/${hash}`, () => sendRequest(), cacheOptions);
+  }
+
+  return sendRequest();
+};
+
+module.exports = async ({
+  configs: {
+    defaultOptions = {}, url, uri, remoteServiceName = 'unnamed-remote-service',
+  },
+  sdk,
+}) => {
+  const logger = sdk.log.child({
+    service: 'graphql',
+    remoteServiceName,
+  });
+
+  const endpoint = url || uri; // -_- which one is right?
+
+  const defaultOptionsOverride = {
+    watchQuery: {
+      fetchPolicy: 'no-cache',
+      errorPolicy: 'ignore',
+    },
+    query: {
+      fetchPolicy: 'no-cache',
+      errorPolicy: 'all',
+    },
+    ...defaultOptions,
+  };
+
+  // default fetcher
+  let fetcher = fetch;
+
+  // add zipkin tracer if enabled
+  if (sdk.zipkinTracer) {
+    fetcher = wrapFetch(fetch, {
+      tracer: sdk.zipkinTracer,
+      remoteServiceName,
+    });
+  }
+
+  const cache = new InMemoryCache();
+  const link = new HttpLink({ fetch: fetcher, uri: endpoint });
+  const client = new ApolloClient({ cache, link, defaultOptions: defaultOptionsOverride });
+
+  logger.info(`graphql: graphql enabled! ${remoteServiceName}`);
+
+
+  return {
+    query: makeRequest({
+      method: 'query', sdk, client, remoteServiceName, logger,
+    }),
+    mutate: makeRequest({
+      method: 'mutate', sdk, client, remoteServiceName, logger,
+    }),
+    client,
+  };
+};

src/index.js

@@ -9,6 +9,9 @@ const { parseConfig } = require('./utils/config');
 // trackers
 const { createZipkinTracer } = require('./tracers/zipkin/index');
 
+// connect
+const connectGraphql = require('./graphql/connect');
+
 // default instance
 const defaultInstance = {
   configs: {},
@@ -31,13 +34,57 @@ const defaultInstance = {
   graphqls: { default: null },
 };
 
+
+// ---------------------------------------------------------------------------
+
 // just a small decoration, also used for test binding :-)
 function logoPrint() {
   const logo = '==== SDK-NODEJS Bootstrap! ====';
   this.log.trace(logo);
   return logo;
 }
 
+// ---------------------------------------------------------------------------
+
+async function enableGraphql(name = 'default', configs = {}) {
+  const sdk = this; // -_-
+
+  // direct config for default? ok then
+  if (typeof name === 'object') {
+    configs = name; // eslint-disable-line no-param-reassign
+    name = 'default'; // eslint-disable-line no-param-reassign
+  }
+
+  // connect and add to graphqls list
+  const connection = await connectGraphql({
+    configs: { remoteServiceName: name, ...configs },
+    sdk,
+  });
+  sdk.graphqls[name] = connection;
+
+  // default? add to default
+  if (name === 'default') {
+    sdk.graphql = connection;
+  }
+
+  return sdk.graphqls[name];
+}
+
+async function disableGraphql(name = 'default') {
+  const sdk = this; // -_-
+
+  // just delete instance
+  delete sdk.graphqls[name];
+
+  // if default, then remove default
+  if (name === 'default') {
+    sdk.graphql = null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+
 async function bootstrap(environment = 'production', configOverrides = {}, useEnv = true, overwriteGlobal = false) {
   // create new instance
   const instance = _.cloneDeep(defaultInstance);
@@ -58,6 +105,13 @@ async function bootstrap(environment = 'production', configOverrides = {}, useEn
     instance.zipkinTracer = await createZipkinTracer({ configs, sdk: instance });
   }
 
+  // integration with graphql, with back compatibility for camelcase
+  instance.enable_graphql = enableGraphql.bind(instance);
+  instance.disable_graphql = disableGraphql.bind(instance);
+  instance.enableGraphql = enableGraphql.bind(instance);
+  instance.disableGraphql = disableGraphql.bind(instance);
+
+
   // put it in global var for default usage later with getInstance()
   if (overwriteGlobal || !global.ncuratedSDK) {
     global.ncuratedSDK = instance;