wip(ApiParser): GraphQL type constructor from elasticsearch API code

Author: nodkz

.eslintrc

@@ -18,7 +18,8 @@
       "exports": "always-multiline",
       "functions": "ignore",
     }],
-    "no-plusplus": 0
+    "no-plusplus": 0,
+    "import/no-extraneous-dependencies": 0
   },
   "env": {
     "jasmine": true,

.flowconfig

@@ -1,5 +1,34 @@
 [ignore]
-.*/node_modules/.*
+.*/node_modules/ajv.*
+.*/node_modules/acorn.*
+.*/node_modules/async.*
+.*/node_modules/babel.*
+.*/node_modules/bluebird.*
+.*/node_modules/caniuse-db.*
+.*/node_modules/config-chain.*
+.*/node_modules/conventional-changelog.*
+.*/node_modules/core-js.*
+.*/node_modules/cssstyle.*
+.*/node_modules/diff.*
+.*/node_modules/es5-ext.*
+.*/node_modules/escope.*
+.*/node_modules/escodegen.*
+.*/node_modules/eslint.*
+.*/node_modules/github.*
+.*/node_modules/fsevents.*
+.*/node_modules/jsdoctypeparser.*
+.*/node_modules/jsdom.*
+.*/node_modules/iconv.*
+.*/node_modules/istanbul.*
+.*/node_modules/handlebars.*
+.*/node_modules/markdown.*
+.*/node_modules/node-notifier.*
+.*/node_modules/npmconf.*
+.*/node_modules/prettier.*
+.*/node_modules/source-map.*
+.*/node_modules/travis.*
+.*/node_modules/uglify.*
+.*/node_modules/yargs.*
 
 [include]
 

.gitignore

@@ -44,3 +44,4 @@ node_modules
 
 coverage
 .nyc_output
+flow-typed

package.json

@@ -36,6 +36,7 @@
     "babel-preset-env": "^1.1.8",
     "cz-conventional-changelog": "^2.0.0",
     "dox": "^0.9.0",
+    "elasticsearch": "^12.1.3",
     "eslint": "^3.14.1",
     "eslint-config-airbnb-base": "^11.0.1",
     "eslint-config-prettier": "^1.0.2",

scripts/apiParser/search.txt renamed to scripts/apiParser/__mocks__/apiPartial.js

@@ -1,3 +1,5 @@
+/* eslint-disable */
+
 /**
  * Perform a [search](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/search-search.html) request
  *
@@ -417,3 +419,75 @@ api.updateByQuery = ca({
   ],
   method: 'POST'
 });
+
+/**
+ * Perform a [cat.allocation](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-allocation.html) request
+ *
+ * @param {Object} params - An object with parameters used to carry out this action
+ * @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
+ * @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
+ * @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
+ * @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
+ * @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
+ * @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
+ * @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
+ * @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
+ * @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information
+ */
+api.cat.prototype.allocation = ca({
+  params: {
+    format: {
+      type: 'string'
+    },
+    bytes: {
+      type: 'enum',
+      options: [
+        'b',
+        'k',
+        'kb',
+        'm',
+        'mb',
+        'g',
+        'gb',
+        't',
+        'tb',
+        'p',
+        'pb'
+      ]
+    },
+    local: {
+      type: 'boolean'
+    },
+    masterTimeout: {
+      type: 'time',
+      name: 'master_timeout'
+    },
+    h: {
+      type: 'list'
+    },
+    help: {
+      type: 'boolean',
+      'default': false
+    },
+    s: {
+      type: 'list'
+    },
+    v: {
+      type: 'boolean',
+      'default': false
+    }
+  },
+  urls: [
+    {
+      fmt: '/_cat/allocation/<%=nodeId%>',
+      req: {
+        nodeId: {
+          type: 'list'
+        }
+      }
+    },
+    {
+      fmt: '/_cat/allocation'
+    }
+  ]
+});

scripts/apiParser/createTypes.js

@@ -0,0 +1,213 @@
+/* @flow */
+/* eslint-disable no-param-reassign */
+
+import dox from 'dox';
+import fs from 'fs';
+import {
+  GraphQLString,
+  GraphQLFloat,
+  GraphQLBoolean,
+  GraphQLInputObjectType,
+  GraphQLEnumType,
+} from 'graphql';
+import { GraphQLJSON, upperFirst } from 'graphql-compose';
+
+import type { GraphQLArgumentConfig } from 'graphql/type/definition';
+
+export type ElasticParamConfigT = {
+  type: string,
+  name?: string,
+  options?: mixed,
+  default?: mixed,
+};
+
+export type ElasticCaSettingsT = {
+  params: {
+    [name: string]: ElasticParamConfigT,
+  },
+  urls: {
+    fmt: string,
+    req: {
+      [name: string]: ElasticParamConfigT,
+    },
+  }[],
+};
+
+export const apiSources = {
+  elastic5: '../../node_modules/elasticsearch/src/lib/apis/5_x.js',
+};
+
+export function loadApiFile(absolutePath: string): string {
+  const str = fs.readFileSync(absolutePath, 'utf8');
+
+  // remove invalid markup
+  // {<<api-param-type-boolean,`Boolean`>>} converted to {Boolean}
+  const strCleaned = str.replace(/{<<.+`(.*)`.+}/gi, '{$1}');
+
+  return strCleaned;
+}
+
+export function parseSource(source: string) {
+  const result = {};
+
+  if (!source || typeof source !== 'string') {
+    throw Error('Empty source. It should be non-empty string.');
+  }
+
+  const parsed = dox.parseComments(source, { raw: true });
+  if (!parsed || !Array.isArray(parsed)) {
+    throw Error('Incorrect responce from dox.parseComments');
+  }
+
+  parsed.forEach(item => {
+    if (!item.ctx || !item.ctx.string) {
+      return;
+    }
+
+    let description;
+    if (item.description && item.description.full) {
+      description = cleanupDescription(item.description.full);
+    }
+
+    const params = {};
+    if (Array.isArray(item.tags)) {
+      item.tags.forEach(tag => {
+        if (!tag || tag.type !== 'param') return;
+        if (tag.name === 'params') return;
+
+        const name = cleanupParamName(tag.name);
+        if (!name) return;
+
+        params[name] = {
+          name,
+          description: cleanupDescription(tag.description),
+        };
+      });
+    }
+
+    // parseParamsFromCode(item.code);
+
+    result[item.ctx.string] = {
+      description,
+      params,
+    };
+  });
+
+  // console.dir(parsed, {depth: 4, colors: 1})
+
+  return result;
+}
+
+export function cleanupDescription(str: ?string): ?string {
+  if (typeof str === 'string') {
+    if (str.startsWith('- ')) {
+      str = str.substr(2);
+    }
+    str = str.trim();
+
+    return str;
+  }
+  return undefined;
+}
+
+export function cleanupParamName(str: ?string): ?string {
+  if (typeof str === 'string') {
+    if (str.startsWith('param.')) {
+      str = str.substr(6);
+    }
+    str = str.trim();
+
+    return str;
+  }
+  return undefined;
+}
+
+export function codeToSettings(code: string): mixed {
+  // find code in ca({});
+  const reg = /ca\((\{(.|\n)+\})\);/g;
+  const matches = reg.exec(code);
+  if (matches[1]) {
+    return eval('(' + matches[1] + ')'); // eslint-disable-line no-eval
+  }
+  return undefined;
+}
+
+export function settingsToParams(settings: ElasticCaSettingsT): mixed {
+  const result = {};
+  const { params, urls } = settings;
+  if (params) {
+    Object.keys(params).forEach(k => {
+      const fieldConfig = paramToGraphQLArgConfig(params[k], k);
+      if (fieldConfig) {
+        result[k] = fieldConfig;
+      }
+    });
+  }
+
+  if (Array.isArray(urls)) {
+    urls.forEach(url => {
+      if (url.req) {
+        Object.keys(url.req).forEach(k => {
+          const fieldConfig = paramToGraphQLArgConfig(url.req[k], k);
+          if (fieldConfig) {
+            result[k] = fieldConfig;
+          }
+        });
+      }
+    });
+  }
+
+  return result;
+}
+
+export function paramToGraphQLArgConfig(
+  paramCfg: ElasticParamConfigT,
+  fieldName: string
+): GraphQLArgumentConfig {
+  const result: GraphQLArgumentConfig = {
+    type: paramTypeToGraphQL(paramCfg, fieldName),
+  };
+  if (paramCfg.default) {
+    result.defaultValue = paramCfg.default;
+  }
+
+  return result;
+}
+
+export function paramTypeToGraphQL(
+  paramCfg: ElasticParamConfigT,
+  fieldName: string
+): GraphQLInputObjectType {
+  switch (paramCfg.type) {
+    case 'string':
+      return GraphQLString;
+    case 'boolean':
+      return GraphQLBoolean;
+    case 'number':
+      return GraphQLFloat;
+    case 'time':
+      return GraphQLString;
+    case 'list':
+      return GraphQLJSON;
+    case 'enum':
+      if (Array.isArray(paramCfg.options)) {
+        const values = paramCfg.options.reduce(
+          (result, val) => {
+            // $FlowFixMe
+            result[val] = { value: val }; // eslint-disable-line no-param-reassign
+            return result;
+          },
+          {}
+        );
+
+        return new GraphQLEnumType({
+          name: `Elastic${upperFirst(fieldName)}`,
+          values,
+        });
+      }
+      return GraphQLString;
+    default:
+      console.log(`New type '${paramCfg.type}' in elastic params setting.`); // eslint-disable-line
+      return GraphQLJSON;
+  }
+}