feat: Exposed main methods, options renaming, small clean-ups.

Author: nodkz

src/__tests__/mappingConverter-test.js

@@ -1,6 +1,6 @@
 /* @flow */
 
-import { TypeComposer, InputTypeComposer, GraphQLJSON } from 'graphql-compose';
+import { TypeComposer, GraphQLJSON } from 'graphql-compose';
 
 import {
   GraphQLString,
@@ -14,10 +14,7 @@ import {
 import {
   convertToSourceTC,
   propertyToSourceGraphQLType,
-  convertToAggregatableITC,
   inputPropertiesToGraphQLTypes,
-  convertToSearchableITC,
-  convertToAnalyzedITC,
   getSubFields,
 } from '../mappingConverter';
 
@@ -173,7 +170,7 @@ describe('PropertiesConverter', () => {
   describe('inputPropertiesToGraphQLTypes()', () => {
     it('should throw error on incorrect prop', () => {
       expect(() => {
-        inputPropertiesToGraphQLTypes({}, () => true);
+        inputPropertiesToGraphQLTypes({});
       }).toThrowError('incorrect Elastic property config');
     });
 
@@ -182,35 +179,31 @@ describe('PropertiesConverter', () => {
         {
           type: 'text',
         },
-        () => true,
         'lastname'
       );
       expect(fields._all.lastname).toEqual(GraphQLString);
       expect(fields.text.lastname).toEqual(GraphQLString);
     });
 
     it('should accept mapping', () => {
-      const fields = inputPropertiesToGraphQLTypes(mapping, () => true);
+      const fields = inputPropertiesToGraphQLTypes(mapping);
       expect(Object.keys(fields._all).length).toBeGreaterThan(2);
     });
 
     it('should convert nested fields', () => {
-      const fields = inputPropertiesToGraphQLTypes(
-        {
-          properties: {
-            name: {
-              type: 'text',
-              fields: {
-                keyword: {
-                  type: 'keyword',
-                  ignore_above: 256,
-                },
+      const fields = inputPropertiesToGraphQLTypes({
+        properties: {
+          name: {
+            type: 'text',
+            fields: {
+              keyword: {
+                type: 'keyword',
+                ignore_above: 256,
               },
             },
           },
         },
-        () => true
-      );
+      });
       expect(Object.keys(fields._all).length).toEqual(2);
       expect(Object.keys(fields._all)).toEqual(
         expect.arrayContaining(['name', 'name__keyword'])
@@ -223,53 +216,18 @@ describe('PropertiesConverter', () => {
       );
     });
 
-    it('should use filterFn', () => {
-      const fields = inputPropertiesToGraphQLTypes(
-        {
-          properties: {
-            name: {
-              type: 'text',
-              fields: {
-                keyword: {
-                  type: 'keyword',
-                  ignore_above: 256,
-                },
-              },
-            },
-          },
-        },
-        prop => prop.type !== 'text'
-      );
-      expect(Object.keys(fields._all).length).toEqual(1);
-      expect(Object.keys(fields._all)).toEqual(
-        expect.arrayContaining(['name__keyword'])
-      );
-      expect(Object.keys(fields.keyword).length).toEqual(1);
-      expect(Object.keys(fields.keyword)).toEqual(
-        expect.arrayContaining(['name__keyword'])
-      );
-    });
-
     it('should not return index:false fields', () => {
-      const itc = convertToSearchableITC(mapping, 'SearchInput');
-      expect(itc.getFieldNames()).not.toEqual(
-        expect.arrayContaining(['noIndex'])
-      );
-
-      const fields = inputPropertiesToGraphQLTypes(
-        {
-          properties: {
-            name: {
-              type: 'text',
-              index: false,
-            },
-            date: {
-              type: 'date',
-            },
+      const fields = inputPropertiesToGraphQLTypes({
+        properties: {
+          name: {
+            type: 'text',
+            index: false,
+          },
+          date: {
+            type: 'date',
           },
         },
-        prop => prop.type !== 'text'
-      );
+      });
       expect(Object.keys(fields._all).length).toEqual(1);
       expect(Object.keys(fields._all)).toEqual(
         expect.arrayContaining(['date'])
@@ -281,116 +239,6 @@ describe('PropertiesConverter', () => {
     });
   });
 
-  describe('convertToAggregatableITC()', () => {
-    it('should throw error on empty mapping', () => {
-      // $FlowFixMe
-      expect(() => convertToAggregatableITC()).toThrowError(
-        'incorrect mapping'
-      );
-    });
-
-    it('should throw error on empty typeName', () => {
-      expect(() => {
-        // $FlowFixMe
-        convertToAggregatableITC(mapping);
-      }).toThrowError('empty name');
-    });
-
-    it('should return InputTypeComposer', () => {
-      const itc = convertToAggregatableITC(mapping, 'AggsInput');
-      expect(itc).toBeInstanceOf(InputTypeComposer);
-      expect(itc.getTypeName()).toBe('AggsInput');
-      expect(itc.getFieldNames().length).toBeGreaterThan(1);
-    });
-
-    it('should return array of aggregatable fields', () => {
-      const itc = convertToAggregatableITC(mapping, 'AggsInput');
-      expect(itc.getFieldNames()).toEqual(
-        expect.arrayContaining([
-          'name__keyword',
-          'birthday',
-          'avatarUrl__thumb__keyword',
-        ])
-      );
-    });
-
-    it('should not return text fields', () => {
-      const itc = convertToAggregatableITC(mapping, 'AggsInput');
-      expect(itc.getFieldNames()).not.toEqual(
-        expect.arrayContaining(['lastname'])
-      );
-    });
-  });
-
-  describe('convertToSearchableITC()', () => {
-    it('should throw error on empty mapping', () => {
-      // $FlowFixMe
-      expect(() => convertToSearchableITC()).toThrowError('incorrect mapping');
-    });
-
-    it('should throw error on empty typeName', () => {
-      expect(() => {
-        // $FlowFixMe
-        convertToSearchableITC(mapping);
-      }).toThrowError('empty name');
-    });
-
-    it('should return InputTypeComposer', () => {
-      const itc = convertToSearchableITC(mapping, 'SearchInput');
-      expect(itc).toBeInstanceOf(InputTypeComposer);
-      expect(itc.getTypeName()).toBe('SearchInput');
-      expect(itc.getFieldNames().length).toBeGreaterThan(1);
-    });
-
-    it('should return array of searchable fields', () => {
-      const itc = convertToSearchableITC(mapping, 'SearchInput');
-      expect(itc.getFieldNames()).toEqual(
-        expect.arrayContaining([
-          'name__keyword',
-          'name',
-          'avatarUrl__big',
-          'avatarUrl__thumb__keyword',
-          'avatarUrl__thumb',
-          'lastname',
-          'birthday',
-        ])
-      );
-    });
-  });
-
-  describe('convertToAnalyzedITC()', () => {
-    it('should throw error on empty mapping', () => {
-      // $FlowFixMe
-      expect(() => convertToAnalyzedITC()).toThrowError('incorrect mapping');
-    });
-
-    it('should throw error on empty typeName', () => {
-      expect(() => {
-        // $FlowFixMe
-        convertToAnalyzedITC(mapping);
-      }).toThrowError('empty name');
-    });
-
-    it('should return InputTypeComposer', () => {
-      const itc = convertToAnalyzedITC(mapping, 'AnalyzedInput');
-      expect(itc).toBeInstanceOf(InputTypeComposer);
-      expect(itc.getTypeName()).toBe('AnalyzedInput');
-      expect(itc.getFieldNames().length).toBeGreaterThan(1);
-    });
-
-    it('should return array of searchable fields', () => {
-      const itc = convertToAnalyzedITC(mapping, 'AnalyzedInput');
-      expect(itc.getFieldNames()).toEqual(
-        expect.arrayContaining([
-          'name',
-          'avatarUrl__big',
-          'avatarUrl__thumb',
-          'lastname',
-        ])
-      );
-    });
-  });
-
   describe('getSubFields()', () => {
     it('should return array of sub fields', () => {
       expect(

src/composeWithElastic.js

@@ -4,36 +4,69 @@ import {
   inputPropertiesToGraphQLTypes,
 } from './mappingConverter';
 import type { ElasticMappingT } from './mappingConverter';
+import createSearchResolver from './resolvers/search';
+import createSearchConnectionResolver from './resolvers/searchConnection';
 
 export type composeWithElasticOptsT = {
-  typeName: string,
+  graphqlTypeName: string,
+  elasticIndex: string,
+  elasticType: string,
+  elasticMapping: ElasticMappingT,
+  elasticClient: Object,
   pluralFields?: string[],
 };
 
 export function composeWithElastic(
-  mapping: ElasticMappingT,
   opts: composeWithElasticOptsT = {}
 ): TypeComposer {
   if (!opts) {
     throw new Error('Opts is required argument for composeWithElastic()');
   }
 
-  if (typeof opts.typeName !== 'string' || !opts.typeName) {
+  if (!opts.elasticMapping || !opts.elasticMapping.properties) {
     throw new Error(
-      'Opts.typeName is required option for TypeName in composeWithElastic()'
+      'You provide incorrect elasticMapping property. It should be an object `{ properties: {} }`'
     );
   }
 
+  if (!opts.elasticIndex || typeof opts.elasticIndex !== 'string') {
+    throw new Error(
+      'Third arg for Resolver search() should contain `elasticIndex` string property from your Elastic server.'
+    );
+  }
+
+  if (!opts.elasticType || typeof opts.elasticType !== 'string') {
+    throw new Error(
+      'Third arg for Resolver search() should contain `elasticType` string property from your Elastic server.'
+    );
+  }
+
+  if (typeof opts.graphqlTypeName !== 'string' || !opts.graphqlTypeName) {
+    throw new Error(
+      'Opts.graphqlTypeName is required property for generated GraphQL Type name in composeWithElastic()'
+    );
+  }
+  opts.prefix = opts.graphqlTypeName; // eslint-disable-line
+
   if (opts.pluralFields && !Array.isArray(opts.pluralFields)) {
     throw new Error(
       'Opts.pluralFields should be an Array of strings with field names ' +
         'which are plural (you may use dot notation for nested fields).'
     );
   }
 
-  const tc = convertToSourceTC(mapping, opts.typeName, opts);
+  const fieldMap = inputPropertiesToGraphQLTypes(opts.elasticMapping);
+  const sourceTC = convertToSourceTC(
+    opts.elasticMapping,
+    opts.graphqlTypeName,
+    opts
+  );
+
+  const searchR = createSearchResolver(fieldMap, sourceTC, opts);
+  const searchConnectionR = createSearchConnectionResolver(searchR, opts);
 
-  const propsMap = inputPropertiesToGraphQLTypes(mapping);
+  sourceTC.addResolver(searchR);
+  sourceTC.addResolver(searchConnectionR);
 
-  return tc;
+  return sourceTC;
 }