@ocap/gql 1.6.5 → 1.6.10

package/lib/index.js

@@ -1,74 +1,94 @@
+const get = require('lodash/get');
+const { createServer } = require('http');
 const { graphqlHTTP } = require('express-graphql');
 const { buildSchema } = require('graphql');
 const schemaSource = require('@ocap/schema');
 
-const wrapResolver = async (keys, callback) => {
-  try {
-    const result = await callback();
-
-    const resultsMap = {};
-    if (Array.isArray(keys)) {
-      keys.forEach((key) => {
-        resultsMap[key] = result[key];
-      });
-    } else {
-      resultsMap[keys] = result;
-    }
-
-    return {
-      code: 'OK',
-      page: result ? result.paging || {} : null,
-      ...resultsMap,
-    };
-  } catch (err) {
-    console.error('GraphQL API Error', err);
-    const tmpKeys = Array.isArray(keys) ? keys : [keys];
-    const tmpKeysMap = tmpKeys.reduce((acc, k) => {
-      acc[k] = null;
-      return acc;
-    }, {});
-
-    return {
-      code: err.code,
-      message: err.message,
-      ...tmpKeysMap,
-    };
+// const debug = require('debug')(require('../package.json').name);
+const createWebSocketServer = require('./ws');
+
+const wrapResolver = async (name, keys, callback) => {
+  const result = await callback();
+
+  const resultsMap = {};
+  if (Array.isArray(keys)) {
+    keys.forEach((key) => {
+      resultsMap[key] = result[key];
+    });
+  } else {
+    resultsMap[keys] = result;
   }
+
+  return {
+    code: 'OK',
+    page: result ? result.paging || {} : null,
+    ...resultsMap,
+  };
 };
 
-const createResolvers = (resolver) => ({
-  sendTx: (args) => wrapResolver('hash', () => resolver.sendTx(args)),
-  subscribe: (args) => wrapResolver('value', () => resolver.subscribe(args)),
-  unsubscribe: (args) => wrapResolver('result', () => resolver.unsubscribe(args)),
-
-  getAccountState: (args) => wrapResolver('state', () => resolver.getAccountState(args)),
-  getAssetState: (args) => wrapResolver('state', () => resolver.getAssetState(args)),
-
-  getBlock: (args) => wrapResolver('block', () => resolver.getBlock(args)),
-  getBlocks: (args) => wrapResolver('blocks', () => resolver.getBlocks(args)),
-  getChainInfo: (args) => wrapResolver('info', () => resolver.getChainInfo(args)),
-  getConfig: (args) => wrapResolver('config', () => resolver.getConfig(args)),
-  getDelegateState: (args) => wrapResolver('state', () => resolver.getDelegateState(args)),
-  getForgeState: (args) => wrapResolver('state', () => resolver.getForgeState(args)),
-  getForgeStats: (args) => wrapResolver('forgeStats', () => resolver.getForgeStats(args)),
-  getHealthStatus: (args) => wrapResolver('healthStatus', () => resolver.getHealthStatus(args)),
-  getNetInfo: (args) => wrapResolver('netInfo', () => resolver.getNetInfo(args)),
-  getNodeInfo: (args) => wrapResolver('info', () => resolver.getNodeInfo(args)),
-  getSwapState: (args) => wrapResolver('state', () => resolver.getSwapState(args)),
-  getSwapStatistics: (args) => wrapResolver('statistics', () => resolver.getSwapStatistics(args)),
-  getTx: (args) => wrapResolver('info', () => resolver.getTx(args)),
-  getUnconfirmedTxs: (args) => wrapResolver('unconfirmedTxs', () => resolver.getUnconfirmedTxs(args)),
-  getValidatorsInfo: (args) => wrapResolver('validatorsInfo', () => resolver.getValidatorsInfo(args)),
-  listAssetTransactions: (args) => wrapResolver('transactions', () => resolver.listAssetTransactions(args)),
-  listAssets: (args) => wrapResolver(['assets', 'account'], () => resolver.listAssets(args)),
-  listBlocks: (args) => wrapResolver('blocks', () => resolver.listBlocks(args)),
-  listStakes: (args) => wrapResolver('stakes', () => resolver.listStakes(args)),
-  listSwap: (args) => wrapResolver('swap', () => resolver.listSwap(args)),
-  listTopAccounts: (args) => wrapResolver('accounts', () => resolver.listTopAccounts(args)),
-  listTransactions: (args) => wrapResolver('transactions', () => resolver.listTransactions(args)),
-});
-
-module.exports = (resolver, graphiql = true) =>
+// eslint-disable-next-line no-unused-vars
+const formatContext = (ctx = {}) => {
+  const featureSwitch = {};
+  return { featureSwitch };
+};
+
+const resolvers = [
+  { fn: 'sendTx', dataKey: 'hash' },
+
+  { fn: 'subscribe', dataKey: 'value' },
+  { fn: 'unsubscribe', dataKey: 'result' },
+
+  { fn: 'getAccountState', dataKey: 'state' },
+  { fn: 'getAssetState', dataKey: 'state' },
+  { fn: 'getFactoryState', dataKey: 'state' },
+  { fn: 'getDelegateState', dataKey: 'state' },
+  { fn: 'getTokenState', dataKey: 'state' },
+  { fn: 'getForgeState', dataKey: 'state' },
+  { fn: 'getStakeState', dataKey: 'state' },
+  { fn: 'getEvidenceState', dataKey: 'state' },
+  { fn: 'getRollupState', dataKey: 'state' },
+  { fn: 'getRollupBlock', dataKey: 'block' },
+
+  { fn: 'getAccountTokens', dataKey: 'tokens' },
+  { fn: 'getBlock', dataKey: 'block' },
+  { fn: 'getBlocks', dataKey: 'blocks' },
+  { fn: 'getChainInfo', dataKey: 'info' },
+  { fn: 'getConfig', dataKey: 'config' },
+  { fn: 'getForgeStats', dataKey: 'forgeStats' },
+  { fn: 'getNetInfo', dataKey: 'netInfo' },
+  { fn: 'getNodeInfo', dataKey: 'info' },
+  { fn: 'getTx', dataKey: 'info' },
+  { fn: 'getUnconfirmedTxs', dataKey: 'unconfirmedTxs' },
+  { fn: 'getValidatorsInfo', dataKey: 'validatorsInfo' },
+
+  { fn: 'listTransactions', dataKey: ['transactions'] },
+  { fn: 'listAssets', dataKey: ['assets', 'account'] },
+  { fn: 'listAssetTransactions', dataKey: ['transactions'] },
+  { fn: 'listFactories', dataKey: ['factories'] },
+  { fn: 'listTokens', dataKey: ['tokens'] },
+  { fn: 'listTopAccounts', dataKey: ['accounts'] },
+  { fn: 'listBlocks', dataKey: ['blocks'] },
+  { fn: 'listStakes', dataKey: ['stakes'] },
+  { fn: 'listRollups', dataKey: ['rollups'] },
+  { fn: 'listRollupBlocks', dataKey: ['blocks'] },
+  { fn: 'listRollupValidators', dataKey: ['validators'] },
+
+  { fn: 'search', dataKey: ['results'] },
+];
+
+const createResolvers = (resolver) =>
+  resolvers.reduce((acc, { fn, dataKey }) => {
+    acc[fn] = (args, ctx) => wrapResolver(fn, dataKey, () => resolver[fn](args, formatContext(ctx)));
+    return acc;
+  }, {});
+
+const defaultErrorHandler = (err) => {
+  if (process.env.NODE_ENV !== 'test') {
+    console.error('GraphQLError', err.originalError || err);
+  }
+};
+
+const createHttpHandler = ({ resolver, onError = defaultErrorHandler, graphiql = true }) =>
   graphqlHTTP({
     schema: buildSchema(schemaSource),
     rootValue: createResolvers(resolver),
@@ -76,7 +96,34 @@ module.exports = (resolver, graphiql = true) =>
     // NOTE: following is required because of following gql query validation issue
     // https://stackoverflow.com/questions/56695262/graphql-error-fieldsconflict-fields-have-different-list-shapes
     customValidateFn: () => true,
+
+    // format custom error code
+    customFormatErrorFn: (err) => {
+      onError(err);
+
+      const isProd = process.env.NODE_ENV === 'production';
+      return {
+        code: get(err, 'originalError.code', 'INTERNAL'),
+        message: err.message,
+        locations: err.locations || [],
+        stack: isProd ? [] : get(err, 'originalError.stack', '').split('\n'),
+        path: err.path,
+      };
+    },
   });
 
-module.exports.wrapResolver = wrapResolver;
-module.exports.createResolvers = createResolvers;
+const createSocketHandler = ({ app, indexdb }) => {
+  const httpServer = createServer(app);
+  const wsServer = createWebSocketServer({ indexdb });
+  wsServer.attach(httpServer);
+
+  return httpServer;
+};
+
+module.exports = {
+  createHttpHandler,
+  createSocketHandler,
+  wrapResolver,
+  createResolvers,
+  formatContext,
+};

package/lib/ws.js

@@ -0,0 +1,31 @@
+const { WsServer } = require('@arcblock/ws');
+
+module.exports = function createWebsocketServer({ indexdb }) {
+  const wsServer = new WsServer({});
+
+  const mutableTables = ['account', 'asset', 'delegation', 'rollup', 'stake'];
+  const appendOnlyTables = ['tx', 'token', 'rollupBlock', 'factory'];
+  const map = { insert: 'create', update: 'update' };
+
+  // For entities that support updating
+  mutableTables.forEach((table) => {
+    ['insert', 'update'].forEach((action) => {
+      indexdb[table].on(action, (data) => wsServer.broadcast([table, map[action]].join('.'), data));
+    });
+  });
+
+  // For entities that are immutable after creation
+  appendOnlyTables.forEach((table) => {
+    ['insert'].forEach((action) => {
+      indexdb[table].on(action, (data) => wsServer.broadcast([table, map[action]].join('.'), data));
+    });
+  });
+
+  // For tx sub topic
+  indexdb.tx.on('insert', (tx) => {
+    const typeUrl = tx.tx.itxJson.type_url.split(':').pop();
+    wsServer.broadcast(`tx.${typeUrl}`, tx);
+  });
+
+  return wsServer;
+};

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.6.5",
+  "version": "1.6.10",
   "description": "Resolver middleware for ocap adapters",
   "main": "lib/index.js",
   "files": [
@@ -12,20 +12,26 @@
   "scripts": {
     "lint": "eslint tests lib",
     "lint:fix": "eslint --fix tests lib",
-    "test": "node tools/jest.js",
+    "test": "jest --forceExit --detectOpenHandles",
     "coverage": "npm run test -- --coverage"
   },
   "keywords": [],
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
+  "contributors": [
+    "wangshijun <shijun@arcblock.io> (https://github.com/wangshijun)"
+  ],
   "license": "MIT",
   "dependencies": {
-    "@ocap/schema": "^1.6.5",
+    "@arcblock/ws": "1.6.10",
+    "@ocap/schema": "1.6.10",
+    "debug": "^4.3.3",
     "express-graphql": "^0.12.0",
-    "graphql": "14.6.0"
+    "graphql": "14.6.0",
+    "lodash": "^4.17.21"
   },
   "devDependencies": {
     "express": "^4.17.1",
-    "jest": "^26.6.3"
+    "jest": "^27.3.1"
   },
-  "gitHead": "5779448f13824de38978df3c84c9da0c1e1ad989"
+  "gitHead": "ab272e8db3a15c6571cc7fae7cc3d3e0fdd4bdb1"
 }